diff --git a/.gitignore b/.gitignore index b59ef8e52..cd8331c82 100644 --- a/.gitignore +++ b/.gitignore @@ -577,3 +577,10 @@ builds/ install/ *.db +*.db-shm +*.db-wal +mx-workspace/ +.claude/ +.mcp.json +*_PROMPT.md +tests/InterpretIR/compile_commands.json diff --git a/IR_GAPS.md b/IR_GAPS.md new file mode 100644 index 000000000..790a6f51f --- /dev/null +++ b/IR_GAPS.md @@ -0,0 +1,74 @@ +# IR Gaps and Issues + +## DONE +- **MEM opcode** — Unified MEMORY opcode with 70 sub-opcodes (load/store x atomic x LE/BE x 8/16/32/64, bulk memory, string ops, bit-field access, cmpxchg, CONSUME_VA_PARAM). +- **LAST_VALUE** — Comma operator: evaluates all operands, returns last. +- **Pointer decrement fix** — `--ptr` correctly emits CONST(-1) with PTR_ADD. +- **IRObject methods** — source_declaration() and type() implemented. +- **EnterScopeInst/ExitScopeInst** — Instruction classes with scope() accessor. +- **Convenience methods** — IRBlock::parent_function(), IRFunction::containing(IRBlock/IRInstruction). +- **DesignatedInitExpr** — Unwrap to Initializer(). ImplicitValueInitExpr as zero. +- **Float builtins** — 41 FloatOp sub-opcodes. +- **Bit-field init fix** — Uses BIT_WRITE with exact bit_offset/bit_width. +- **Interpreter improvements** — Scope tracking (poison on EXIT_SCOPE), all string/memory ops. +- **Pointer compound assign fix** — `ptr += n` uses PTR_ADD, not ADD. +- **PTR_DIFF element_size** — Extracted from pointee type. +- **_Atomic plain load/store** — Correctly uses atomic ops. +- **BIT_READ** — Emitted in EmitLoadFromLValue for bit-field reads. +- **Switch case compensation** — Compensation blocks for switch→case scope crossings. +- **CFG predecessor fix** — Correct predecessor list updates in compensation. +- **Database teardown** — Isolated try/catch per step, leaked statement detection. +- **Sized opcodes** — All integer, pointer, atomic, overflow, and bitwise opcodes are width-specific (_8/_16/_32/_64). Float opcodes have _32/_64 variants. FloatOp and BitwiseOp sub-opcodes carry width. No unsized arithmetic/pointer opcodes remain in the enum. Interpreter is width-correct at all sizes. OpCode is uint8_t (251 values, gap-packed). +- **ABS opcode** — Moved from BitwiseOp sub-opcode to sized top-level opcode (ABS_8/16/32/64). +- **EXPECT/ASSUME removed** — Compiler hints with no runtime semantics; not emitted to IR. +- **Interpreter precision** — Float _32 ops use float precision, _64 use double. All casts (SEXT, ZEXT, TRUNC, int↔float, float↔float, BITCAST) are width-correct. Unsigned operations use correct unsigned types at each width. +- **Entity ID type safety** — Typed enums in IRBlockId, IRInstructionId, IRStructureId. +- **IRSwitchCase → IRSwitchCaseStructure** — Switch cases are now IRStructure entities. +- **ALLOCA sub-opcodes** — AllocaKind: LOCAL, ARG, RETURN, DYNAMIC. DynamicAllocaInst derived from AllocaInst. +- **EXPRESSION_SCOPE** — New StructureKind for call argument/return allocas. +- **PARAM_PTR** — Renamed from PARAM_READ. Returns pointer to caller's argument alloca. +- **RETURN_ADDRESS** — Renamed from RETURN_PTR (for __builtin_return_address). +- **VA_PACK removed** — Variadic args are regular operands. +- **VA_ARG → CONSUME_VA_PARAM** — New MemOp sub-opcode. +- **ArrayToPointerDecay fix** — Uses EmitLValue (address), not EmitRValue (load). +- **MEMCPY for direct assignment** — `a = b` with lvalue RHS always uses MEMCPY. +- **Scalar size guards** — IsScalarSize() check before DetermineMemOp; MEMCPY fallback for non-1/2/4/8. +- **String literal init** — Non-power-of-2 sizes use MEMCPY. +- **source_statement() assertion fix** — Checks entity ID is StmtId before calling StmtFor. +- **IRObject::source_declaration() assertion fix** — Checks entity ID is DeclId before calling DeclFor. +- **Interpreter moved to bin/InterpretIR/** — Separate from Examples. +- **mx-print-ir human-readable output** — Uses EnumeratorName() for all opcodes, sub-opcodes, kinds. +- **MX_EXPORT on IR enum EnumeratorName** — All IR enum name functions exported from shared library. +- **GNU statement expression** — Already handled: SCOPE + emit children + last expr value. +- **Compound literal** — Already handled: ALLOCA + EmitInitializer + scope-tracked. +- **EXPRESSION_SCOPE at call sites** — Calls wrapped in EXPRESSION_SCOPE with ALLOCA/ARG for each argument and ALLOCA/RETURN for return value. Scope popped at full-expression boundary. +- **RETURN_PTR in callee** — Callee emits RETURN_PTR to get pointer to caller's return storage, stores return value into it before RET. +- **PARAM_PTR without local copy** — Parameters no longer copied into local allocas. PARAM_PTR directly gives pointer to caller's ARG alloca. DeclRefExpr resolves to PARAM_PTR. +- **CallInst::return_alloca()** — Returns the ALLOCA/RETURN instruction for the return value. `has_return_value()` for void check. +- **IRObject string literal bytes** — Not needed; content accessible via AST StringLiteral through source_declaration(). + +## Remaining Gaps + +### Codegen +1. **C++ expressions** — Lambda, new/delete, this, constructors, destructors, etc. emit UNKNOWN. (C-only for now.) + +### API +6. **No IRInstruction::result_type() on base class** — Must downcast to get result type. A base-class method would simplify interpreters/printers. Deferred. +7. **No Index::ir_functions() enumerator** — Can't iterate all IR functions from an Index. + +### Interpreter +10. **Interpreter is monolithic** — ~1500-line switch in bin/InterpretIR. Plan exists to extract into lib/IR/Interpret/ with ValueFactory/Memory/Driver/Checker policy classes. See docs/InterpreterLibraryPlan.md. +11. **No multi-path exploration** — Single-path concrete execution only. Need COW memory + fork. +12. **No call inlining** — Interpreter doesn't step into callees. +13. **No external function modeling** — malloc/free/memcpy/printf etc. not modeled. + +### Codegen / Types +14. **`__int128` / `_BitInt(N>64)`** — Sized integer opcodes only cover 8/16/32/64-bit widths. Wider types (e.g., `__int128`, `_BitInt(128)`) currently round down to `_64`. These could be decomposed into paired 64-bit operations. + +### C23 +15. **`#embed` directive** — C23's `#embed` for embedding binary data. Not handled. + +### Documentation +15. **IR_GAPS.md** — This file (kept up to date). +16. **docs/IR.md** — Updated. +17. **docs/InterpreterLibraryPlan.md** — Written. diff --git a/IR_TODOS.md b/IR_TODOS.md new file mode 100644 index 000000000..015e404a4 --- /dev/null +++ b/IR_TODOS.md @@ -0,0 +1,57 @@ +# IR Implementation Progress + +## Plan: Structural IR Entities (robust-plotting-rocket.md) + +### Phase 1: FunctionKind + sourceDeclEntityId rename — COMPLETE + +### Phase 2: IRStructure entity + scope tracking — COMPLETE +- [x] StructureKind enum (18 kinds), IRStructure entity, IRStructureId +- [x] Structure capnp schema, entity providers, pack/unpack +- [x] Structure generation (PushStructure/PopStructure) for all control flow +- [x] FUNCTION_SCOPE, nested SCOPE for CompoundStmt, implicit SCOPE for for-init +- [x] ENTER_SCOPE/EXIT_SCOPE opcodes on all paths (including break/continue/return/goto) +- [x] Block parentStructureId, scope object association via AssociateObjectWithScope +- [x] IRFunction::body_scope(), IRBlock::parent_structure() accessors +- [x] SWITCH_CASE structures for each case/default +- [ ] IRSwitchCase → IRStructure(SWITCH_CASE) full migration (deferred) +- [ ] Full Python bindings (stub exists, requires bootstrap regen) + +### Phase 3: Control flow region structures — MERGED INTO PHASE 2 + +### Phase 4: Global initializer functions — COMPLETE +- [x] GenerateGlobalInit creates synthetic FunctionIR for globals with initializers +- [x] FunctionKind::GLOBAL_INITIALIZER, sourceDeclEntityId = VarDecl +- [x] Entry block with ADDRESS_OF → EmitRValue(init) → STORE → RET +- [x] VarDecl maps to its GLOBAL_INITIALIZER IRFunction + +## Known Extensions — PARTIALLY COMPLETE +- [x] MEMSET (opcode 68): dest, byte_value, size — lowered from memset/builtin calls +- [x] MEMCPY (opcode 69): dest, src, size — lowered from memcpy/memmove/builtin calls +- [x] MemsetInst, MemcpyInst instruction class wrappers +- [ ] VAR_INIT block kind + structure kind (for variable initialization regions) + +## Known Issues / Lies Remaining +1. IRSwitchCase still separate entity type (coexists with SWITCH_CASE structures) +2. string_bytes() missing on IRObject for string literals +3. Python bindings are stub only for IRStructure +4. Global initializer quality depends on EmitRValue handling of all init expressions +5. **Goto/Duff's device scope compensation**: `goto` that jumps into the middle + of a scope bypasses the normal ENTER_SCOPE path. An interpreter following + the goto would not see the scope entry for variables in that scope. Similarly, + Duff's device-style switch cases can interleave with loop bodies, creating + scope entry paths that don't go through ENTER_SCOPE. We need "compensation + blocks" — synthetic blocks inserted on goto/case edges that emit the + ENTER_SCOPE instructions for any scopes being entered. This is tricky because + the label/case might also be reachable from normal control flow (which already + has the ENTER_SCOPE), so we can't just add ENTER_SCOPE at the label — we need + it on the specific edge. Always using compensation blocks (even for the normal + case) would be the simplest correct solution. + +## Decisions Made +- Phase 3 merged into Phase 2 +- SWITCH_CASE structures coexist with IRSwitchCase for backward compat +- ENTER_SCOPE/EXIT_SCOPE carry IRStructureId extra in entity pool +- StructureKind embedded in IRStructureId (18 sub_kind offsets) +- Global initializer uses same EmitRValue path as function body codegen +- MEMSET/MEMCPY lowered from memset/memcpy/memmove and all __builtin_ variants +- Goto conservatively exits all scopes to FUNCTION_SCOPE diff --git a/bin/Bootstrap/PASTA.cpp b/bin/Bootstrap/PASTA.cpp index 809215754..2225c918b 100644 --- a/bin/Bootstrap/PASTA.cpp +++ b/bin/Bootstrap/PASTA.cpp @@ -2388,6 +2388,53 @@ MethodListPtr CodeGenerator::RunOnClass( make_parent("parent_statement", "MX_VISIT_STMT_LINK", "Stmt"); } + // `*::ir()` -- the IR entity corresponding to this AST entity. + // For FunctionDecl, returns IRFunction. For Stmt/Expr, returns IRInstruction. + // For CaseStmt/DefaultStmt, returns IRStructure (SWITCH_CASE). Etc. + if (class_name == "Decl" || class_name == "Stmt") { + auto sd = storage.AddMethod("UInt64"); // IR entity ID (any IR kind). + auto [cd_getter_name, cd_setter_name, cd_init_name] = NamesFor(sd); + + class_os + << " std::optional ir(void) const;\n"; + + serialize_inc_os + << " MX_VISIT_ENTITY_ID(" << class_name + << ", ir, " << sd << ")\n"; + + serialize_cpp_os + << " b." << cd_setter_name << "(es.IREntityId(e));\n"; + + lib_cpp_os + << "std::optional " << class_name << "::ir(void) const {\n" + << " auto raw = impl->reader." << cd_getter_name << "();\n" + << " if (raw == kInvalidEntityId) return std::nullopt;\n" + << " auto vid = EntityId(raw).Unpack();\n" + << " if (auto *p = std::get_if(&vid)) {\n" + << " if (auto ptr = impl->ep->IRFunctionFor(impl->ep, raw)) {\n" + << " return IRFunction(std::move(ptr));\n" + << " }\n" + << " } else if (auto *p = std::get_if(&vid)) {\n" + << " if (auto ptr = impl->ep->IRBlockFor(impl->ep, raw)) {\n" + << " return IRBlock(std::move(ptr));\n" + << " }\n" + << " } else if (auto *p = std::get_if(&vid)) {\n" + << " if (auto ptr = impl->ep->IRInstructionFor(impl->ep, raw)) {\n" + << " return IRInstruction(std::move(ptr));\n" + << " }\n" + << " } else if (auto *p = std::get_if(&vid)) {\n" + << " if (auto ptr = impl->ep->IRObjectFor(impl->ep, raw)) {\n" + << " return IRObject(std::move(ptr));\n" + << " }\n" + << " } else if (auto *p = std::get_if(&vid)) {\n" + << " if (auto ptr = impl->ep->IRStructureFor(impl->ep, raw)) {\n" + << " return IRStructure(std::move(ptr));\n" + << " }\n" + << " }\n" + << " return std::nullopt;\n" + << "}\n\n"; + } + // `Decl::is_definition` if (class_name == "Decl") { const auto def = storage.AddMethod("Bool"); @@ -4089,6 +4136,9 @@ void CodeGenerator::RunOnClassHierarchies(void) { << "#ifndef MX_VISIT_BASE\n" << "# define MX_VISIT_BASE(...)\n" << "#endif\n" + << "#ifndef MX_VISIT_ENTITY_ID\n" + << "# define MX_VISIT_ENTITY_ID(...)\n" + << "#endif\n" << "#ifndef MX_VISIT_DECL_LINK\n" << "# define MX_VISIT_DECL_LINK(...)\n" << "#endif\n" diff --git a/bin/Bootstrap/Python.cpp b/bin/Bootstrap/Python.cpp index 6054fb604..8ceb2268e 100644 --- a/bin/Bootstrap/Python.cpp +++ b/bin/Bootstrap/Python.cpp @@ -3,5 +3,13 @@ #include #include +#include +#include +#include +#include +#include +#include +#include + #include #include diff --git a/bin/Bootstrap/PythonBindings.py b/bin/Bootstrap/PythonBindings.py index 8f065d6f7..eef8d2c81 100644 --- a/bin/Bootstrap/PythonBindings.py +++ b/bin/Bootstrap/PythonBindings.py @@ -919,6 +919,13 @@ class UserToken; #include #include #include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -1794,6 +1801,11 @@ def wrap(schemas: Iterable[Schema], renamer: Renamer): "TemplateParameterList", "Macro", "Operation", + "IRFunction", + "IRBlock", + "IRInstruction", + "IRObject", + "IRStructure", ) VariantEntitySchema = make_schema_class("VariantEntity", "Entity", Schema) diff --git a/bin/CMakeLists.txt b/bin/CMakeLists.txt index b0afc7d08..38d9f7066 100644 --- a/bin/CMakeLists.txt +++ b/bin/CMakeLists.txt @@ -7,3 +7,4 @@ add_subdirectory("Examples") add_subdirectory("Index") +add_subdirectory("InterpretIR") diff --git a/bin/Examples/CMakeLists.txt b/bin/Examples/CMakeLists.txt index 8cb67a2db..385806fd5 100644 --- a/bin/Examples/CMakeLists.txt +++ b/bin/Examples/CMakeLists.txt @@ -91,3 +91,4 @@ define_example("mx-print-type-token-graph" "PrintTypeTokenGraph.cpp") define_example("mx-find-linked-structures" "FindLinkedStructures.cpp") define_example("mx-list-declarations-overlapping-macro-expansion" "ListDeclOverlappingMacroExpansions.cpp") +define_example("mx-print-ir" "PrintIR.cpp") diff --git a/bin/Examples/Harness.cpp b/bin/Examples/Harness.cpp index c24e1f4cb..71f060292 100644 --- a/bin/Examples/Harness.cpp +++ b/bin/Examples/Harness.cpp @@ -15,6 +15,7 @@ DEFINE_uint64(entity_id, mx::kInvalidEntityId, "ID of the entity to harness"); DEFINE_string(entity_name, "", "Name of the entity to harness"); +DEFINE_bool(deduplicate, true, "Deduplicate like names"); using SeenSet = std::set; using WorkList = std::vector; @@ -566,33 +567,35 @@ int main(int argc, char *argv[]) { std::unordered_map canon_id; // Figure out what top-level entities need to be renamed. - for (mx::PackedFragmentId frag_id : frags) { - for (mx::Decl tld : index.fragment(frag_id)->top_level_declarations()) { - tld = tld.canonical_declaration(); - std::optional nd = mx::NamedDecl::from(tld); - if (!nd) { - continue; - } + if (FLAGS_deduplicate) { + for (mx::PackedFragmentId frag_id : frags) { + for (mx::Decl tld : index.fragment(frag_id)->top_level_declarations()) { + tld = tld.canonical_declaration(); + std::optional nd = mx::NamedDecl::from(tld); + if (!nd) { + continue; + } - std::string_view name_view = nd->name(); - if (name_view.empty()) { - continue; - } + std::string_view name_view = nd->name(); + if (name_view.empty()) { + continue; + } - std::string name(name_view.data(), name_view.size()); - mx::RawEntityId eid = nd->id().Pack(); - mx::RawEntityId stored_eid = canon_id.emplace(name, eid).first->second; - if (eid != stored_eid) { - std::cout << "// Renaming " << name_view << '\n'; - needs_rename.insert(eid); - needs_rename.insert(stored_eid); + std::string name(name_view.data(), name_view.size()); + mx::RawEntityId eid = nd->id().Pack(); + mx::RawEntityId stored_eid = canon_id.emplace(name, eid).first->second; + if (eid != stored_eid) { + std::cout << "// Renaming " << name_view << '\n'; + needs_rename.insert(eid); + needs_rename.insert(stored_eid); + } } } - } - // Make sure our original entity isn't subject to renaming. - for (mx::Decl redecl : entity->redeclarations()) { - needs_rename.erase(redecl.id().Pack()); + // Make sure our original entity isn't subject to renaming. + for (mx::Decl redecl : entity->redeclarations()) { + needs_rename.erase(redecl.id().Pack()); + } } std::cerr @@ -642,9 +645,11 @@ int main(int argc, char *argv[]) { } std::cout << tag->name(); - if (mx::RawEntityId eid = tld.canonical_declaration().id().Pack(); - needs_rename.contains(eid)) { - std::cout << '_' << eid; + if (FLAGS_deduplicate) { + if (mx::RawEntityId eid = tld.canonical_declaration().id().Pack(); + needs_rename.contains(eid)) { + std::cout << '_' << eid; + } } std::cout << ";\n"; } @@ -685,7 +690,7 @@ int main(int argc, char *argv[]) { mx::Decl decl = std::get(ent).canonical_declaration(); mx::RawEntityId eid = decl.id().Pack(); - if (needs_rename.contains(eid)) { + if (FLAGS_deduplicate && needs_rename.contains(eid)) { std::cout << '_' << eid; } } diff --git a/bin/Examples/PrintIR.cpp b/bin/Examples/PrintIR.cpp new file mode 100644 index 000000000..5402847d5 --- /dev/null +++ b/bin/Examples/PrintIR.cpp @@ -0,0 +1,332 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Prints the IR for a named function in human-readable form. +// Usage: mx-print-ir --db DATABASE --entity_name FUNC_NAME [--all] +// +// With --all, prints IR for every function in the index. + +#include +#include +#include +#include +#include +#include +#include + +#include "Index.h" +#include +#include +#include +#include + +DEFINE_uint64(entity_id, mx::kInvalidEntityId, "ID of the entity"); +DEFINE_string(entity_name, "", "Name of the function to print IR for"); +DEFINE_bool(all, false, "Print IR for all functions"); + +namespace { + +// Extract offset from an entity ID for readable printing. +uint32_t OffsetOf(mx::EntityId eid) { + auto vid = eid.Unpack(); + if (auto *p = std::get_if(&vid)) return p->offset; + if (auto *p = std::get_if(&vid)) return p->offset; + if (auto *p = std::get_if(&vid)) return p->offset; + if (auto *p = std::get_if(&vid)) return p->offset; + if (auto *p = std::get_if(&vid)) return p->offset; + return static_cast(eid.Pack() & 0xFFFF); +} + +// Truncate and clean a string for display. +std::string Truncate(std::string_view data, size_t max_len = 50) { + std::string s(data.begin(), data.end()); + for (auto &c : s) { if (c == '\n' || c == '\r') c = ' '; } + if (s.size() > max_len) s = s.substr(0, max_len - 3) + "..."; + return s; +} + +// Print a single instruction (recursive for expression trees). +void PrintInstruction(std::ostream &os, const mx::IRInstruction &inst, + const std::string &indent, bool is_root) { + auto op = inst.opcode(); + + os << indent; + if (is_root) os << ">> "; + else os << " "; + + inst.format_ref(os); + os << " = "; + + // Opcode name. + os << mx::ir::EnumeratorName(op); + + // Sub-opcode / extra info for grouped opcodes. + if (auto ci = mx::ConstInst::from(inst)) { + auto sub = ci->sub_opcode(); + os << "/" << mx::ir::EnumeratorName(sub); + if (sub >= mx::ir::ConstOp::FLOAT32 && sub <= mx::ir::ConstOp::FLOAT64) { + os << " " << ci->float_value(); + } else if (sub == mx::ir::ConstOp::NULL_PTR) { + // no extra + } else if (sub >= mx::ir::ConstOp::UINT8 && + sub <= mx::ir::ConstOp::UINT64) { + os << " " << ci->unsigned_value(); + } else { + os << " " << ci->signed_value(); + } + } else if (auto mi = mx::MemoryInst::from(inst)) { + auto sub = mi->sub_opcode(); + os << "/" << mx::ir::EnumeratorName(sub); + if (mx::ir::IsBitAccess(sub)) { + os << " off=" << mi->bit_offset() << " w=" << mi->bit_width(); + } + } else if (auto ci = mx::CastInst::from(inst)) { + os << "/" << mx::ir::EnumeratorName(ci->sub_opcode()); + } else if (auto ri = mx::ReadModifyWriteInst::from(inst)) { + os << "(" << mx::ir::EnumeratorName(ri->underlying_op()); + if (ri->is_atomic()) os << " atomic"; + if (ri->is_big_endian()) os << " BE"; + os << " " << (ri->returns_new_value() ? "new" : "old"); + os << ")"; + } else if (auto bi = mx::BitwiseOpInst::from(inst)) { + os << "/" << mx::ir::EnumeratorName(bi->sub_opcode()); + } else if (auto fi = mx::FloatOpInst::from(inst)) { + os << "/" << mx::ir::EnumeratorName(fi->sub_opcode()); + } else if (auto ai = mx::AllocaInst::from(inst)) { + os << "/" << mx::ir::EnumeratorName(ai->alloca_kind()); + os << " size=" << ai->size_bytes() << " align=" << ai->align_bytes(); + } else if (auto pr = mx::ParamPtrInst::from(inst)) { + os << " idx=" << pr->parameter_index(); + } else if (op == mx::ir::OpCode::ENTER_SCOPE || + op == mx::ir::OpCode::EXIT_SCOPE) { + mx::IRStructure scope; + if (auto es = mx::EnterScopeInst::from(inst)) scope = es->scope(); + else if (auto es = mx::ExitScopeInst::from(inst)) scope = es->scope(); + if (scope.id() != mx::EntityId()) { + os << " " << mx::ir::EnumeratorName(scope.kind()); + } + } else if (auto gi = mx::GEPFieldInst::from(inst)) { + os << " offset=" << gi->byte_offset(); + auto fd = gi->field(); + os << " ." << fd.name(); + } else if (auto pi = mx::PtrAddInst::from(inst)) { + os << " elem_size=" << pi->element_size(); + } else if (op == mx::ir::OpCode::CALL) { + if (auto ci = mx::CallInst::from(inst)) { + if (auto target = ci->target()) { + os << " @" << target->name(); + } else if (ci->is_indirect()) { + os << " indirect"; + } + } + } else if (op == mx::ir::OpCode::SWITCH) { + if (auto si = mx::SwitchInst::from(inst)) { + os << " cases=" << si->num_cases() << " {"; + bool first = true; + for (auto sc : si->cases()) { + if (!first) os << ","; + first = false; + if (sc.is_default()) { + os << " default->block_" << OffsetOf(sc.target_block().id()); + } else if (sc.is_range()) { + os << " " << sc.low() << ".." << sc.high() + << "->block_" << OffsetOf(sc.target_block().id()); + } else { + os << " " << sc.low() + << "->block_" << OffsetOf(sc.target_block().id()); + } + } + os << " }"; + } + } + + // Operands. + unsigned n = inst.num_operands(); + if (n > 0) { + os << " ["; + for (unsigned i = 0; i < n; ++i) { + if (i) os << ", "; + auto operand = inst.nth_operand(i); + operand.format_ref(os); + } + os << "]"; + } + + // Source provenance. + if (auto src = inst.source_statement()) { + auto data = src->tokens().data(); + if (!data.empty()) { + os << " // " << Truncate(data); + } + } + + os << "\n"; +} + +// Print a block. +void PrintBlock(std::ostream &os, const mx::IRBlock &block) { + auto kind = block.kind(); + + os << " block_" << OffsetOf(block.id()) << " " + << mx::ir::EnumeratorName(kind); + + // Predecessors. + { + bool first = true; + for (auto pred : block.predecessors()) { + if (first) { os << " <- ["; first = false; } + else os << ", "; + os << "block_" << OffsetOf(pred.id()); + } + if (!first) os << "]"; + } + + os << ":\n"; + + // Top-level instructions (roots). + // Recursively print all sub-expressions depth-first before the root, + // deduplicating by entity ID. + std::set printed; + std::function print_subs; + print_subs = [&](const mx::IRInstruction &parent) { + for (auto sub : parent.operands()) { + auto sub_eid = mx::EntityId(sub.id()).Pack(); + if (printed.count(sub_eid)) continue; + print_subs(sub); + printed.insert(sub_eid); + PrintInstruction(os, sub, " ", false); + } + }; + for (auto inst : block.instructions()) { + print_subs(inst); + PrintInstruction(os, inst, " ", true); + } + + // Successors. + { + bool first = true; + for (auto succ : block.successors()) { + if (first) { os << " -> ["; first = false; } + else os << ", "; + os << "block_" << OffsetOf(succ.id()); + } + if (!first) os << "]\n"; + } +} + +// Print a function's IR. +void PrintFunction(std::ostream &os, const mx::IRFunction &func) { + auto kind = func.kind(); + os << "function "; + + if (auto decl = func.source_declaration()) { + if (auto nd = mx::NamedDecl::from(*decl)) { + os << nd->name(); + } + } + + os << " (" << mx::ir::EnumeratorName(kind) << ") {\n"; + + // Objects. + os << " objects:\n"; + for (auto obj : func.objects()) { + os << " obj_" << OffsetOf(obj.id()) + << " " << mx::ir::EnumeratorName(obj.kind()) + << " size=" << obj.size_bytes() + << " align=" << obj.align_bytes(); + if (auto vd = obj.source_declaration()) { + os << " (" << vd->name() << ")"; + } + os << "\n"; + } + + // Structure tree. + if (auto scope = func.body_scope()) { + os << " body_scope: " << mx::ir::EnumeratorName(scope->kind()) << "\n"; + } + + // Blocks in RPO. + os << "\n blocks:\n"; + auto entry = func.entry_block(); + PrintBlock(os, entry); + + for (auto block : func.blocks()) { + if (mx::EntityId(block.id()).Pack() == mx::EntityId(entry.id()).Pack()) + continue; + PrintBlock(os, block); + } + + os << "}\n\n"; +} + +} // namespace + +int main(int argc, char *argv[]) { + std::stringstream ss; + ss << "Usage: " << argv[0] + << " --db DATABASE [--entity_name NAME | --entity_id ID | --all]"; + google::SetUsageMessage(ss.str()); + google::ParseCommandLineFlags(&argc, &argv, false); + google::InitGoogleLogging(argv[0]); + + mx::Index index = InitExample(false); + + if (FLAGS_entity_id != mx::kInvalidEntityId) { + auto entity = index.entity(FLAGS_entity_id); + + if (auto *ir = std::get_if(&entity)) { + PrintFunction(std::cout, *ir); + } else if (auto *decl = std::get_if(&entity)) { + if (auto ir_var = decl->ir()) { + if (auto *ir = std::get_if(&*ir_var)) { + PrintFunction(std::cout, *ir); + } else { + LOG(ERROR) << "Entity " << FLAGS_entity_id << " has IR but not an IRFunction"; + return 1; + } + } else { + LOG(ERROR) << "No IR for entity " << FLAGS_entity_id; + return 1; + } + } else { + LOG(ERROR) << "Entity " << FLAGS_entity_id << " is not a Decl or IRFunction"; + return 1; + } + } else if (FLAGS_all) { + for (auto frag : mx::Fragment::in(index)) { + for (auto decl : mx::Decl::in(frag)) { + auto func_decl = mx::FunctionDecl::from(decl); + if (!func_decl) continue; + auto ir = mx::IRFunction::from(*func_decl); + if (!ir) continue; + PrintFunction(std::cout, *ir); + } + } + } else if (!FLAGS_entity_name.empty()) { + bool found = false; + for (auto frag : mx::Fragment::in(index)) { + for (auto decl : mx::Decl::in(frag)) { + auto func_decl = mx::FunctionDecl::from(decl); + if (!func_decl) continue; + if (std::string(func_decl->name()) != FLAGS_entity_name) continue; + auto ir = mx::IRFunction::from(*func_decl); + if (!ir) continue; + PrintFunction(std::cout, *ir); + found = true; + break; + } + if (found) break; + } + if (!found) { + LOG(ERROR) << "No IR found for '" << FLAGS_entity_name << "'"; + return 1; + } + } else { + LOG(ERROR) << "Specify --entity_name or --all"; + return 1; + } + + return 0; +} diff --git a/bin/Index/BuildPendingFragment.cpp b/bin/Index/BuildPendingFragment.cpp index 946382110..6d0cdf254 100644 --- a/bin/Index/BuildPendingFragment.cpp +++ b/bin/Index/BuildPendingFragment.cpp @@ -168,6 +168,10 @@ class FragmentBuilder final { } \ } +// IR entity IDs are populated separately in GenerateIR/SerializeIR. +#undef MX_VISIT_ENTITY_ID +#define MX_VISIT_ENTITY_ID(cls, api_method, storage) + #define MX_VISIT_PSEUDO MX_VISIT_ENTITY #define MX_VISIT_PSEUDO_LIST MX_VISIT_ENTITY_LIST #define MX_VISIT_OPTIONAL_PSEUDO MX_VISIT_OPTIONAL_ENTITY diff --git a/bin/Index/CMakeLists.txt b/bin/Index/CMakeLists.txt index 65255b867..83ed3048b 100644 --- a/bin/Index/CMakeLists.txt +++ b/bin/Index/CMakeLists.txt @@ -27,6 +27,10 @@ add_executable("${exe_name}" "Importer.h" "IndexCompileJob.cpp" "IndexCompileJob.h" + "IRGen.cpp" + "IRGen.h" + "SerializeIR.cpp" + "SerializeIR.h" "LabelEntitiesInFragment.h" "LabelEntitiesInFragment.cpp" "LabelParentEntitiesInFragment.cpp" diff --git a/bin/Index/Context.cpp b/bin/Index/Context.cpp index e56146702..2100e88b1 100644 --- a/bin/Index/Context.cpp +++ b/bin/Index/Context.cpp @@ -61,6 +61,9 @@ void GlobalIndexingState::InitializeProgressBars(void) { type_progress.reset(new ProgressBar("Type serialization", report_freq)); + + ir_progress.reset(new ProgressBar("IR generation", + report_freq)); } } // namespace indexer diff --git a/bin/Index/Context.h b/bin/Index/Context.h index cfc00e009..e2a9836f3 100644 --- a/bin/Index/Context.h +++ b/bin/Index/Context.h @@ -65,6 +65,9 @@ class GlobalIndexingState { // Tracks progress in saving tokenized files. std::unique_ptr file_progress; + // Tracks progress in IR generation. + std::unique_ptr ir_progress; + const unsigned num_workers; // Worker pool. diff --git a/bin/Index/EntityMapper.cpp b/bin/Index/EntityMapper.cpp index 14bc0c8dc..8421f9bc4 100644 --- a/bin/Index/EntityMapper.cpp +++ b/bin/Index/EntityMapper.cpp @@ -50,6 +50,18 @@ mx::RawEntityId EntityMapper::ParentStmtId(const void *entity) const { } } +mx::RawEntityId EntityMapper::IREntityId(const void *entity) const { + auto ast_eid = EntityId(entity); + if (ast_eid == mx::kInvalidEntityId) { + return mx::kInvalidEntityId; + } + auto it = ir_for_entity.find(ast_eid); + if (it != ir_for_entity.end()) { + return it->second; + } + return mx::kInvalidEntityId; +} + mx::RawEntityId EntityMapper::EntityId(const void *entity) const { if (!entity) { return mx::kInvalidEntityId; diff --git a/bin/Index/EntityMapper.h b/bin/Index/EntityMapper.h index 1b1a27ecd..29b4ce274 100644 --- a/bin/Index/EntityMapper.h +++ b/bin/Index/EntityMapper.h @@ -66,6 +66,10 @@ class EntityMapper final { EntityIdMap parent_decl_ids; EntityIdMap parent_stmt_ids; + // Reverse map: AST entity ID → IR instruction entity ID. + // Populated during IR generation, consumed during AST serialization. + std::unordered_map ir_for_entity; + // Entities map for tracking parent pointers EntityParentMap parent_decls; EntityParentMap parent_stmts; @@ -87,6 +91,27 @@ class EntityMapper final { return ParentStmtId(RawEntity(entity)); } + // Look up the IR entity ID for a given AST entity. + // Returns kInvalidEntityId if no IR entity maps to this entity. + // The returned ID may be an IRInstructionId, IRFunctionId, etc. + mx::RawEntityId IREntityId(const void *entity) const; + + template + inline mx::RawEntityId IREntityId(const Entity &entity) const { + return IREntityId(RawEntity(entity)); + } + + // Convenience aliases. + template + inline mx::RawEntityId IRInstructionId(const Entity &entity) const { + return IREntityId(entity); + } + + template + inline mx::RawEntityId IRFunctionId(const Entity &entity) const { + return IREntityId(entity); + } + inline mx::RawEntityId EntityId(std::nullptr_t entity) const noexcept { return mx::kInvalidEntityId; } diff --git a/bin/Index/IRGen.cpp b/bin/Index/IRGen.cpp new file mode 100644 index 000000000..4e555fdac --- /dev/null +++ b/bin/Index/IRGen.cpp @@ -0,0 +1,4646 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include "IRGen.h" +#include "EntityMapper.h" + +#include +#include +#include +#include +#include + +// We use raw Clang AST accessors for things PASTA doesn't expose +// (literal values, type sizes, etc.) +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace indexer { +namespace ir { + +using mx::RawEntityId; +using mx::kInvalidEntityId; +// PASTA enums for dispatch. These are converted to our unified OpCode. + +// Returns true if size_bytes is a valid scalar access size (1, 2, 4, or 8). +static bool IsScalarSize(unsigned size_bytes) { + return size_bytes == 1 || size_bytes == 2 || + size_bytes == 4 || size_bytes == 8; +} + +// Helper: determine ConstOp from width and signedness for integer constants. +static mx::ir::ConstOp IntConstOp(uint8_t width, bool is_signed = true) { + if (width <= 1) return mx::ir::ConstOp::BOOL; + if (width <= 8) return is_signed ? mx::ir::ConstOp::INT8 : mx::ir::ConstOp::UINT8; + if (width <= 16) return is_signed ? mx::ir::ConstOp::INT16 : mx::ir::ConstOp::UINT16; + if (width <= 32) return is_signed ? mx::ir::ConstOp::INT32 : mx::ir::ConstOp::UINT32; + return is_signed ? mx::ir::ConstOp::INT64 : mx::ir::ConstOp::UINT64; +} + + + +// Helper: determine ConstOp for float constants. +static mx::ir::ConstOp FloatConstOp(uint8_t width) { + if (width <= 16) return mx::ir::ConstOp::FLOAT16; + if (width <= 32) return mx::ir::ConstOp::FLOAT32; + return mx::ir::ConstOp::FLOAT64; +} + +// Integer operation groups for SizedIntOp. These are NOT opcodes — they're +// internal to IRGen for selecting the correct sized opcode. +enum class IntOp : uint8_t { + ADD, SUB, MUL, DIV, REM, + UDIV, UREM, USHR, + BIT_AND, BIT_OR, BIT_XOR, SHL, SHR, + CMP_EQ, CMP_NE, CMP_LT, CMP_LE, CMP_GT, CMP_GE, + UCMP_LT, UCMP_LE, UCMP_GT, UCMP_GE, + NEG, BIT_NOT, + // Keep these in sync with the enum layout — groups of 4 continue + // at ATOMIC_ADD_8 = 223. +}; + +// Atomic RMW groups. Stride-4 starting at ATOMIC_ADD_8 = 223. +enum class AtomicOp : uint8_t { + ATOMIC_ADD, ATOMIC_SUB, ATOMIC_AND, ATOMIC_OR, + ATOMIC_XOR, ATOMIC_NAND, ATOMIC_EXCHANGE, +}; + +static mx::ir::OpCode SizedAtomicOp(AtomicOp group, unsigned width_bytes) { + unsigned wi; + if (width_bytes <= 1) wi = 0; + else if (width_bytes <= 2) wi = 1; + else if (width_bytes <= 4) wi = 2; + else wi = 3; + return static_cast( + static_cast(mx::ir::OpCode::ATOMIC_ADD_8) + + static_cast(group) * 4 + wi); +} + +// Overflow-checked arithmetic groups. Stride-4 starting at ADD_OVERFLOW_8 = 56. +enum class OverflowOp : uint8_t { + ADD_OVERFLOW, SUB_OVERFLOW, MUL_OVERFLOW, +}; + +static mx::ir::OpCode SizedOverflowOp(OverflowOp group, unsigned width_bytes) { + unsigned wi; + if (width_bytes <= 1) wi = 0; + else if (width_bytes <= 2) wi = 1; + else if (width_bytes <= 4) wi = 2; + else wi = 3; + return static_cast( + static_cast(mx::ir::OpCode::ADD_OVERFLOW_8) + + static_cast(group) * 4 + wi); +} + +// Map an IntOp group + byte width to a sized OpCode. +// Non-power-of-2 widths round up (3→4, 6→8). Every call produces a sized opcode. +static mx::ir::OpCode SizedIntOp(IntOp group, unsigned width_bytes) { + unsigned wi; + if (width_bytes <= 1) wi = 0; + else if (width_bytes <= 2) wi = 1; + else if (width_bytes <= 4) wi = 2; + else wi = 3; + return static_cast( + static_cast(mx::ir::OpCode::ADD_8) + + static_cast(group) * 4 + wi); +} + +// Map a width to the corresponding BITWISE or ABS opcode. +// BITWISE_8=5,_16=6,_32=7,_64=8. ABS_8=9,_16=10,_32=11,_64=12. +static mx::ir::OpCode SizedBitwiseOp(unsigned width_bytes) { + if (width_bytes <= 1) return mx::ir::OpCode::BITWISE_8; + if (width_bytes <= 2) return mx::ir::OpCode::BITWISE_16; + if (width_bytes <= 4) return mx::ir::OpCode::BITWISE_32; + return mx::ir::OpCode::BITWISE_64; +} + +static mx::ir::OpCode SizedAbsOp(unsigned width_bytes) { + if (width_bytes <= 1) return mx::ir::OpCode::ABS_8; + if (width_bytes <= 2) return mx::ir::OpCode::ABS_16; + if (width_bytes <= 4) return mx::ir::OpCode::ABS_32; + return mx::ir::OpCode::ABS_64; +} + +// Map a pointer-producing op to its 32 or 64-bit variant. +static mx::ir::OpCode SizedPtrOp(mx::ir::OpCode base_32, unsigned ptr_bytes) { + // base_32 is the _32 variant; _64 is always base_32 + 1. + return (ptr_bytes <= 4) ? base_32 + : static_cast(static_cast(base_32) + 1); +} + +// Helper: determine CastOp from Clang CastKind and type info. +// src_signed: whether the source integer type is signed. +// dst_signed: whether the destination integer type is signed. +static mx::ir::CastOp DetermineCastOp( + pasta::CastKind ck, unsigned src_bits, unsigned dst_bits, + bool src_signed, bool dst_signed, bool src_float, bool dst_float) { + switch (ck) { + case pasta::CastKind::kBitCast: + return mx::ir::CastOp::BITCAST; + + case pasta::CastKind::kIntegralCast: { + if (dst_bits > src_bits) { + // Widening. + if (src_signed) { + // Sign-extend. + if (src_bits <= 8 && dst_bits <= 16) return mx::ir::CastOp::SEXT_I8_I16; + if (src_bits <= 8 && dst_bits <= 32) return mx::ir::CastOp::SEXT_I8_I32; + if (src_bits <= 8) return mx::ir::CastOp::SEXT_I8_I64; + if (src_bits <= 16 && dst_bits <= 32) return mx::ir::CastOp::SEXT_I16_I32; + if (src_bits <= 16) return mx::ir::CastOp::SEXT_I16_I64; + return mx::ir::CastOp::SEXT_I32_I64; + } else { + // Zero-extend. + if (src_bits <= 8 && dst_bits <= 16) return mx::ir::CastOp::ZEXT_I8_I16; + if (src_bits <= 8 && dst_bits <= 32) return mx::ir::CastOp::ZEXT_I8_I32; + if (src_bits <= 8) return mx::ir::CastOp::ZEXT_I8_I64; + if (src_bits <= 16 && dst_bits <= 32) return mx::ir::CastOp::ZEXT_I16_I32; + if (src_bits <= 16) return mx::ir::CastOp::ZEXT_I16_I64; + return mx::ir::CastOp::ZEXT_I32_I64; + } + } else if (dst_bits < src_bits) { + // Narrowing (truncate). + if (dst_bits <= 8 && src_bits <= 16) return mx::ir::CastOp::TRUNC_I16_I8; + if (dst_bits <= 8 && src_bits <= 32) return mx::ir::CastOp::TRUNC_I32_I8; + if (dst_bits <= 8) return mx::ir::CastOp::TRUNC_I64_I8; + if (dst_bits <= 16 && src_bits <= 32) return mx::ir::CastOp::TRUNC_I32_I16; + if (dst_bits <= 16) return mx::ir::CastOp::TRUNC_I64_I16; + return mx::ir::CastOp::TRUNC_I64_I32; + } + return mx::ir::CastOp::IDENTITY; + } + + case pasta::CastKind::kPointerToIntegral: + return dst_bits <= 32 ? mx::ir::CastOp::PTR_TO_I32 : mx::ir::CastOp::PTR_TO_I64; + + case pasta::CastKind::kIntegralToPointer: + return src_bits <= 32 ? mx::ir::CastOp::I32_TO_PTR : mx::ir::CastOp::I64_TO_PTR; + + case pasta::CastKind::kIntegralToFloating: { + if (src_signed) { + if (src_bits <= 8 && dst_bits <= 32) return mx::ir::CastOp::SI8_TO_F32; + if (src_bits <= 8) return mx::ir::CastOp::SI8_TO_F64; + if (src_bits <= 16 && dst_bits <= 32) return mx::ir::CastOp::SI16_TO_F32; + if (src_bits <= 16) return mx::ir::CastOp::SI16_TO_F64; + if (src_bits <= 32 && dst_bits <= 32) return mx::ir::CastOp::SI32_TO_F32; + if (src_bits <= 32) return mx::ir::CastOp::SI32_TO_F64; + if (dst_bits <= 32) return mx::ir::CastOp::SI64_TO_F32; + return mx::ir::CastOp::SI64_TO_F64; + } else { + if (src_bits <= 8 && dst_bits <= 32) return mx::ir::CastOp::UI8_TO_F32; + if (src_bits <= 8) return mx::ir::CastOp::UI8_TO_F64; + if (src_bits <= 16 && dst_bits <= 32) return mx::ir::CastOp::UI16_TO_F32; + if (src_bits <= 16) return mx::ir::CastOp::UI16_TO_F64; + if (src_bits <= 32 && dst_bits <= 32) return mx::ir::CastOp::UI32_TO_F32; + if (src_bits <= 32) return mx::ir::CastOp::UI32_TO_F64; + if (dst_bits <= 32) return mx::ir::CastOp::UI64_TO_F32; + return mx::ir::CastOp::UI64_TO_F64; + } + } + + case pasta::CastKind::kFloatingToIntegral: { + if (src_bits <= 32) { + if (dst_bits <= 8) return dst_signed ? mx::ir::CastOp::F32_TO_SI8 : mx::ir::CastOp::F32_TO_UI8; + if (dst_bits <= 16) return dst_signed ? mx::ir::CastOp::F32_TO_SI16 : mx::ir::CastOp::F32_TO_UI16; + if (dst_bits <= 32) return dst_signed ? mx::ir::CastOp::F32_TO_SI32 : mx::ir::CastOp::F32_TO_UI32; + return dst_signed ? mx::ir::CastOp::F32_TO_SI64 : mx::ir::CastOp::F32_TO_UI64; + } else { + if (dst_bits <= 8) return dst_signed ? mx::ir::CastOp::F64_TO_SI8 : mx::ir::CastOp::F64_TO_UI8; + if (dst_bits <= 16) return dst_signed ? mx::ir::CastOp::F64_TO_SI16 : mx::ir::CastOp::F64_TO_UI16; + if (dst_bits <= 32) return dst_signed ? mx::ir::CastOp::F64_TO_SI32 : mx::ir::CastOp::F64_TO_UI32; + return dst_signed ? mx::ir::CastOp::F64_TO_SI64 : mx::ir::CastOp::F64_TO_UI64; + } + } + + case pasta::CastKind::kFloatingCast: + if (src_bits <= 32 && dst_bits > 32) return mx::ir::CastOp::F32_TO_F64; + if (src_bits > 32 && dst_bits <= 32) return mx::ir::CastOp::F64_TO_F32; + return mx::ir::CastOp::IDENTITY; + + default: + return mx::ir::CastOp::BITCAST; + } +} + +// --------------------------------------------------------------------------- +// IRGenerator +// --------------------------------------------------------------------------- + +IRGenerator::IRGenerator(const pasta::AST &ast, const EntityMapper &em) + : ast_(ast), + em_(em), + ctx_(const_cast(ast.UnderlyingAST())) { + // Cache entity IDs and widths for built-in types. + auto size_qt = ctx_.getSizeType(); + size_type_width_ = static_cast(ctx_.getTypeSize(size_qt)); + size_type_eid_ = em_.EntityId(ast_.Adopt(size_qt.getTypePtr())); + + auto ptrdiff_qt = ctx_.getPointerDiffType(); + ptrdiff_type_width_ = static_cast(ctx_.getTypeSize(ptrdiff_qt)); + ptrdiff_type_eid_ = em_.EntityId(ast_.Adopt(ptrdiff_qt.getTypePtr())); +} + +std::optional IRGenerator::Generate( + const pasta::FunctionDecl &func) { + + auto body = func.Body(); + if (!body) return std::nullopt; + + try { + func_ = FunctionIR{}; + func_.func_decl_entity_id = EntityIdOf(func); + current_block_index_ = 0; + current_structure_index_ = UINT32_MAX; + next_obj_index_ = 0; + entity_to_object_.clear(); + object_to_alloca_.clear(); + address_taken_.clear(); + loop_stack_.clear(); + label_blocks_.clear(); + case_blocks_.clear(); + structure_stack_.clear(); + pending_gotos_.clear(); + label_structure_.clear(); + + // Pre-scan for address-taken variables. + ScanAddressTaken(*body); + + // Create parameters as objects. + auto params = func.Parameters(); + for (const auto ¶m : params) { + auto eid = EntityIdOf(param); + bool addr_taken = address_taken_.count(eid); + auto kind = addr_taken ? mx::ir::ObjectKind::PARAMETER + : mx::ir::ObjectKind::PARAMETER_VALUE; + MakeObject(kind, ¶m); + } + + // --- Frame block: all ALLOCAs (parameters + locals) --- + uint32_t frame = NewBlock(mx::ir::BlockKind::FRAME); + func_.entry_block_index = frame; + SwitchToBlock(frame); + + // Emit parameter ALLOCAs in the frame block. + for (const auto ¶m : params) { + uint32_t obj_idx = GetOrMakeObject(param); + InstructionIR alloca_inst; + alloca_inst.opcode = mx::ir::OpCode::ALLOCA; + alloca_inst.source_entity_id = EntityIdOf(param); + alloca_inst.object_index = obj_idx; + alloca_inst.type_entity_id = TypeEntityIdOf(param.Type()); + uint32_t alloca_idx = EmitTopLevel(std::move(alloca_inst)); + object_to_alloca_[obj_idx] = alloca_idx; + } + + // Emit local variable ALLOCAs in the frame block. + EmitEntryBlockAllocas(*body); + + // --- Entry block: logical start of the function body --- + uint32_t entry = NewBlock(mx::ir::BlockKind::ENTRY); + EmitBranch(entry); + SwitchToBlock(entry); + + // Push the function-level scope structure. + uint32_t func_scope = PushStructure( + mx::ir::StructureKind::FUNCTION_SCOPE, EntityIdOf(*body)); + func_.body_scope_index = func_scope; + AssociateBlockWithStructure(entry); + + // ENTER_SCOPE for the function body. + { + InstructionIR enter; + enter.opcode = mx::ir::OpCode::ENTER_SCOPE; + enter.source_entity_id = EntityIdOf(*body); + enter.structure_index = func_scope; + EmitTopLevel(std::move(enter)); + } + + // Emit PARAM_PTR for each parameter. PARAM_PTR gives a direct pointer + // to the caller's ARG alloca — no local copy. The parameter's "alloca" + // in DeclRefExpr resolution maps to this PARAM_PTR instruction. + for (uint32_t pi = 0; pi < params.size(); ++pi) { + const auto ¶m = params[pi]; + uint32_t obj_idx = GetOrMakeObject(param); + + InstructionIR pr; + pr.opcode = SizedPtrOp(mx::ir::OpCode::PARAM_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + pr.source_entity_id = EntityIdOf(param); + pr.type_entity_id = TypeEntityIdOf(param.Type()); + pr.int_value = static_cast(pi); // parameter index + uint32_t pr_idx = EmitInstruction(std::move(pr)); + + // Map the parameter object's alloca to the PARAM_PTR instruction, + // so DeclRefExpr for the param resolves to this pointer. + object_to_alloca_[obj_idx] = pr_idx; + } + + EmitBody(*body); + + // If the current block has no terminator, add an implicit void return. + { + auto &blk = func_.blocks[current_block_index_]; + bool needs_ret = blk.instruction_indices.empty(); + if (!needs_ret) { + auto last_op = func_.instructions[blk.instruction_indices.back()].opcode; + needs_ret = !mx::ir::IsTerminator(last_op); + } + if (needs_ret) { + // EXIT_SCOPE for the function scope before implicit return. + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = EntityIdOf(*body); + exit_inst.structure_index = func_scope; + EmitTopLevel(std::move(exit_inst)); + + InstructionIR ret; + ret.opcode = mx::ir::OpCode::RET; + EmitTopLevel(std::move(ret)); + } + } + + // Pop the function-level scope. + PopStructure(); + + // Insert compensation blocks for gotos that cross scope boundaries. + InsertGotoCompensationBlocks(); + + // Patch empty blocks before computing dominators. + // Empty blocks arise when all paths into a merge/exit block already + // terminated (e.g., both if-branches return), or from empty switch cases. + for (uint32_t bi = 0; bi < func_.blocks.size(); ++bi) { + auto &block = func_.blocks[bi]; + if (!block.instruction_indices.empty()) continue; + InstructionIR term; + term.parent_block_index = bi; + if (!block.successor_indices.empty()) { + term.opcode = mx::ir::OpCode::IMPLICIT_GOTO; + BranchTargetIR target; + target.block_index = block.successor_indices.front(); + term.branch_targets = {target}; + } else { + term.opcode = mx::ir::OpCode::IMPLICIT_UNREACHABLE; + } + term.is_root = true; + uint32_t idx = static_cast(func_.instructions.size()); + func_.instructions.push_back(std::move(term)); + block.instruction_indices.push_back(idx); + } + + // Compute dominators and RPO. + ComputeDominators(); + ComputeRPO(); + + // Verify block structure. + VerifyBlocks(); + + LOG(INFO) << "Generated IR for function entity " + << func_.func_decl_entity_id + << ": " << func_.blocks.size() << " blocks, " + << func_.instructions.size() << " instructions, " + << func_.objects.size() << " objects"; + + return std::move(func_); + + } catch (const std::exception &ex) { + LOG(ERROR) << "Exception during IR generation for function " + << func_.func_decl_entity_id << ": " << ex.what(); + return std::nullopt; + } catch (...) { + LOG(ERROR) << "Unknown exception during IR generation for function " + << func_.func_decl_entity_id; + return std::nullopt; + } +} + +std::optional IRGenerator::GenerateGlobalInit( + const pasta::VarDecl &var) { + + auto init = var.Initializer(); + if (!init) return std::nullopt; + + try { + func_ = FunctionIR{}; + func_.func_decl_entity_id = EntityIdOf(var); + func_.kind = (var.TLSKind() != pasta::VarDeclTLSKind::kNone) + ? mx::ir::FunctionKind::THREAD_LOCAL_INITIALIZER + : mx::ir::FunctionKind::GLOBAL_INITIALIZER; + current_block_index_ = 0; + current_structure_index_ = UINT32_MAX; + next_obj_index_ = 0; + entity_to_object_.clear(); + object_to_alloca_.clear(); + address_taken_.clear(); + loop_stack_.clear(); + label_blocks_.clear(); + case_blocks_.clear(); + structure_stack_.clear(); + + // --- Frame block (empty: address comes via parameter) --- + uint32_t frame = NewBlock(mx::ir::BlockKind::FRAME); + func_.entry_block_index = frame; + SwitchToBlock(frame); + + // --- Entry block: scope entry + initialization --- + uint32_t entry = NewBlock(mx::ir::BlockKind::ENTRY); + EmitBranch(entry); + SwitchToBlock(entry); + + // Push FUNCTION_SCOPE. + uint32_t func_scope = PushStructure( + mx::ir::StructureKind::FUNCTION_SCOPE, EntityIdOf(var)); + func_.body_scope_index = func_scope; + AssociateBlockWithStructure(entry); + + // ENTER_SCOPE for the function body. + { + InstructionIR enter; + enter.opcode = mx::ir::OpCode::ENTER_SCOPE; + enter.source_entity_id = EntityIdOf(var); + enter.structure_index = func_scope; + EmitTopLevel(std::move(enter)); + } + + // PARAM_PTR 0: the pointer to the global (passed by the caller). + InstructionIR pr; + pr.opcode = SizedPtrOp(mx::ir::OpCode::PARAM_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + pr.source_entity_id = EntityIdOf(var); + pr.type_entity_id = TypeEntityIdOf(var.Type()); + pr.int_value = 0; // parameter index 0 + uint32_t addr_idx = EmitInstruction(std::move(pr)); + + // Emit initialization (decomposes aggregates into element stores). + EmitInitializer(addr_idx, *init, EntityIdOf(var)); + + // EXIT_SCOPE + RET. + { + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = EntityIdOf(var); + exit_inst.structure_index = func_scope; + EmitTopLevel(std::move(exit_inst)); + } + { + InstructionIR ret; + ret.opcode = mx::ir::OpCode::RET; + EmitTopLevel(std::move(ret)); + } + + // Pop FUNCTION_SCOPE. + PopStructure(); + + // Patch empty blocks. + for (uint32_t bi = 0; bi < func_.blocks.size(); ++bi) { + auto &block = func_.blocks[bi]; + if (!block.instruction_indices.empty()) continue; + InstructionIR term; + term.parent_block_index = bi; + if (!block.successor_indices.empty()) { + term.opcode = mx::ir::OpCode::IMPLICIT_GOTO; + BranchTargetIR target; + target.block_index = block.successor_indices.front(); + term.branch_targets = {target}; + } else { + term.opcode = mx::ir::OpCode::IMPLICIT_UNREACHABLE; + } + term.is_root = true; + uint32_t idx = static_cast(func_.instructions.size()); + func_.instructions.push_back(std::move(term)); + block.instruction_indices.push_back(idx); + } + + ComputeDominators(); + ComputeRPO(); + VerifyBlocks(); + + LOG(INFO) << "Generated global init IR for var entity " + << func_.func_decl_entity_id + << ": " << func_.instructions.size() << " instructions"; + + return std::move(func_); + + } catch (const std::exception &ex) { + LOG(ERROR) << "Exception during IR generation for global initializer: " + << ex.what(); + return std::nullopt; + } catch (...) { + LOG(ERROR) << "Unknown exception during IR generation for global initializer"; + return std::nullopt; + } +} + +// --------------------------------------------------------------------------- +// Structure management +// --------------------------------------------------------------------------- + +uint32_t IRGenerator::PushStructure(mx::ir::StructureKind kind, + mx::RawEntityId source_eid) { + uint32_t idx = static_cast(func_.structures.size()); + StructureIR s; + s.kind = kind; + s.source_entity_id = source_eid; + s.parent_structure_index = current_structure_index_; + func_.structures.push_back(std::move(s)); + + // Register as child of parent. + if (current_structure_index_ != UINT32_MAX) { + StructureIR::ChildRef ref; + ref.index = idx; + ref.is_structure = true; + func_.structures[current_structure_index_].children.push_back(ref); + } + + structure_stack_.push_back(current_structure_index_); + current_structure_index_ = idx; + return idx; +} + +void IRGenerator::PopStructure() { + assert(!structure_stack_.empty()); + current_structure_index_ = structure_stack_.back(); + structure_stack_.pop_back(); +} + +void IRGenerator::AssociateBlockWithStructure(uint32_t block_idx) { + if (current_structure_index_ == UINT32_MAX) return; + func_.blocks[block_idx].parent_structure_index = current_structure_index_; + StructureIR::ChildRef ref; + ref.index = block_idx; + ref.is_structure = false; + func_.structures[current_structure_index_].children.push_back(ref); +} + +void IRGenerator::AssociateObjectWithScope(uint32_t obj_idx) { + // Walk up the structure stack to find the nearest scope. + uint32_t si = current_structure_index_; + while (si != UINT32_MAX) { + if (mx::ir::IsScope(func_.structures[si].kind)) { + func_.structures[si].object_indices.push_back(obj_idx); + return; + } + si = func_.structures[si].parent_structure_index; + } +} + +void IRGenerator::EmitScopeExits(uint32_t stop_structure_index) { + // Walk from current structure up to (but not including) stop, emitting + // EXIT_SCOPE for each SCOPE we pass through. + uint32_t si = current_structure_index_; + while (si != UINT32_MAX && si != stop_structure_index) { + if (mx::ir::IsScope(func_.structures[si].kind)) { + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = func_.structures[si].source_entity_id; + exit_inst.structure_index = si; + EmitTopLevel(std::move(exit_inst)); + } + si = func_.structures[si].parent_structure_index; + } +} + +// --------------------------------------------------------------------------- +// Block management +// --------------------------------------------------------------------------- + +uint32_t IRGenerator::NewBlock(mx::ir::BlockKind kind) { + uint32_t idx = static_cast(func_.blocks.size()); + BlockIR block; + block.kind = kind; + func_.blocks.push_back(std::move(block)); + return idx; +} + +// Switch to a new dead block after a terminator (break/continue/return/goto). +// The dead block gets an IMPLICIT_UNREACHABLE terminator immediately so that +// CurrentBlockTerminated() returns true and dead-code skipping works. +void IRGenerator::SwitchToDeadBlock() { + SwitchToBlock(NewBlock(mx::ir::BlockKind::UNREACHABLE)); + InstructionIR term; + term.opcode = mx::ir::OpCode::IMPLICIT_UNREACHABLE; + EmitTopLevel(std::move(term)); +} + +void IRGenerator::SwitchToBlock(uint32_t block_idx) { + current_block_index_ = block_idx; +} + +void IRGenerator::AddEdge(uint32_t from, uint32_t to) { + func_.blocks[from].successor_indices.push_back(to); + func_.blocks[to].predecessor_indices.push_back(from); +} + +uint32_t IRGenerator::EmitBranch(uint32_t target_block, + mx::RawEntityId source_eid) { + // Default: implicit goto (structural CFG edge). + return EmitBranchWithOpCode(mx::ir::OpCode::IMPLICIT_GOTO, target_block, + source_eid); +} + +uint32_t IRGenerator::EmitBranchWithOpCode(mx::ir::OpCode opcode, + uint32_t target_block, + mx::RawEntityId source_eid) { + // Don't emit a branch if the current block is already terminated. + auto &blk = func_.blocks[current_block_index_]; + if (!blk.instruction_indices.empty()) { + auto last_op = func_.instructions[blk.instruction_indices.back()].opcode; + if (mx::ir::IsTerminator(last_op)) { + return UINT32_MAX; + } + } + + InstructionIR br; + br.opcode = opcode; + br.source_entity_id = source_eid; + BranchTargetIR target; + target.block_index = target_block; + br.branch_targets = {target}; + uint32_t idx = EmitTopLevel(std::move(br)); + AddEdge(current_block_index_, target_block); + return idx; +} + +uint32_t IRGenerator::EmitCondBranch(uint32_t cond_idx, uint32_t true_block, + uint32_t false_block, + mx::RawEntityId source_eid) { + InstructionIR term; + term.opcode = mx::ir::OpCode::COND_BRANCH; + term.source_entity_id = source_eid; + term.operand_indices = {cond_idx}; + BranchTargetIR true_t, false_t; + true_t.block_index = true_block; + false_t.block_index = false_block; + term.branch_targets = {true_t, false_t}; + uint32_t idx = EmitTopLevel(std::move(term)); + AddEdge(current_block_index_, true_block); + AddEdge(current_block_index_, false_block); + return idx; +} + +uint32_t IRGenerator::EmitLoadFromLValue(const pasta::Expr &e) { + auto eid = EntityIdOf(e); + + // Bit-field read: emit BIT_READ instead of GEP_FIELD + LOAD. + if (auto me = pasta::MemberExpr::From(e)) { + auto member = me->MemberDeclaration(); + if (auto fd = pasta::FieldDecl::From(member)) { + if (fd->IsBitField()) { + // Emit base address (not through the MemberExpr itself). + uint32_t base_idx; + if (me->IsArrow()) { + base_idx = EmitRValue(me->Base()); + } else { + base_idx = EmitLValue(me->Base()); + } + + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + if (auto t = e.Type()) { + inst.type_entity_id = TypeEntityIdOf(*t); + } + inst.operand_indices = {base_idx}; + inst.target_entity_id = EntityIdOf(member); + + // Determine bit offset and width. + if (auto bits = fd->OffsetInBits()) { + inst.bit_offset = static_cast(*bits); + } + if (auto bw = fd->BitWidth()) { + auto *raw_bw = reinterpret_cast(bw->RawStmt()); + if (raw_bw) { + clang::Expr::EvalResult result; + if (raw_bw->EvaluateAsInt(result, ctx_)) { + inst.bit_width = static_cast( + result.Val.getInt().getZExtValue()); + } + } + } + + bool big_endian = ctx_.getTargetInfo().isBigEndian(); + inst.mem_op = static_cast( + big_endian ? mx::ir::MemOp::BIT_READ_BE + : mx::ir::MemOp::BIT_READ_LE); + return EmitInstruction(std::move(inst)); + } + } + } + + uint32_t addr_idx = EmitLValue(e); + + // Check if this is a large object that can't be scalar-loaded. + // For types > 8 bytes (structs, arrays, etc.), return the address directly — + // the "value" of a large object is its pointer. Callers that need to copy + // the object should use MEMCPY explicitly. + if (auto t = e.Type()) { + if (auto sz = TypeSizeBytes(*t)) { + if (!IsScalarSize(*sz)) { + return addr_idx; + } + } + } + + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + if (auto t = e.Type()) { + inst.type_entity_id = TypeEntityIdOf(*t); + unsigned sz = 8; + if (auto s = TypeSizeBytes(*t)) sz = *s; + bool is_atomic = t->IsAtomicType(); + bool is_float = t->IsFloatingType(); + inst.mem_op = static_cast( + DetermineMemOp(false, is_atomic, sz, is_float)); + } else { + inst.mem_op = static_cast( + DetermineMemOp(false, false, 8)); + } + inst.operand_indices = {addr_idx}; + return EmitInstruction(std::move(inst)); +} + +void IRGenerator::MarkConditionallyExecuted(uint32_t inst_idx) { + auto &inst = func_.instructions[inst_idx]; + inst.flags |= 0x4; // bit 2 = isConditionallyExecuted + // Recursively mark all operands (children in the expression tree). + for (auto op_idx : inst.operand_indices) { + MarkConditionallyExecuted(op_idx); + } +} + +// --------------------------------------------------------------------------- +// Address-taken pre-scan +// --------------------------------------------------------------------------- + +void IRGenerator::ScanAddressTaken(const pasta::Stmt &s) { + if (auto uo = pasta::UnaryOperator::From(s)) { + if (uo->Opcode() == pasta::UnaryOperatorKind::kAddressOf) { + auto sub = uo->SubExpression(); + while (true) { + if (auto pe = pasta::ParenExpr::From(sub)) { + sub = pe->SubExpression(); + continue; + } + if (auto ice = pasta::ImplicitCastExpr::From(sub)) { + sub = ice->SubExpression(); + continue; + } + break; + } + if (auto dre = pasta::DeclRefExpr::From(sub)) { + address_taken_.insert(EntityIdOf(dre->Declaration())); + } + } + } + + for (const auto &child : s.Children()) { + ScanAddressTaken(child); + } +} + +void IRGenerator::EmitEntryBlockAllocas(const pasta::Stmt &body) { + // Walk the body to find all VarDecls and emit allocas in the entry block. + std::function walk; + walk = [&](const pasta::Stmt &s) { + if (auto ds = pasta::DeclStmt::From(s)) { + for (const auto &decl : ds->Declarations()) { + auto vd = pasta::VarDecl::From(decl); + if (!vd) continue; + if (pasta::ParmVarDecl::From(decl)) continue; + + // Static/global-storage variables don't get local ALLOCAs. + // They're accessed via GLOBAL_PTR and initialized by + // GLOBAL_INITIALIZER functions. + if (vd->HasGlobalStorage()) continue; + + uint32_t obj_idx = GetOrMakeObject(decl); + + InstructionIR alloca_inst; + alloca_inst.opcode = mx::ir::OpCode::ALLOCA; + alloca_inst.source_entity_id = EntityIdOf(decl); + alloca_inst.object_index = obj_idx; + alloca_inst.type_entity_id = TypeEntityIdOf(vd->Type()); + // Skip VLAs in FRAME — they're emitted at declaration time + // in EmitDeclStmt with a runtime size operand. + if (vd->Type().IsVariablyModifiedType()) continue; + uint32_t alloca_idx = EmitTopLevel(std::move(alloca_inst)); + object_to_alloca_[obj_idx] = alloca_idx; + } + } + for (const auto &child : s.Children()) { + walk(child); + } + }; + walk(body); +} + +// --------------------------------------------------------------------------- +// Object management +// --------------------------------------------------------------------------- + +uint32_t IRGenerator::MakeObject(mx::ir::ObjectKind kind, + const pasta::Decl *decl) { + ObjectIR obj; + obj.kind = kind; + + if (decl) { + obj.source_decl_id = EntityIdOf(*decl); + // Name is accessible via source_decl_id -> NamedDecl::Name() + if (auto vd = pasta::VarDecl::From(*decl)) { + { + auto vt = vd->Type(); + obj.type_entity_id = TypeEntityIdOf(vt); + // type_str removed -- use Multiplier Type APIs to render + if (auto sz = TypeSizeBytes(vt)) obj.size_bytes = *sz; + if (auto al = TypeAlignBytes(vt)) obj.align_bytes = *al; + } + } + } + + uint32_t idx = next_obj_index_++; + func_.objects.push_back(std::move(obj)); + + if (decl) { + auto eid = EntityIdOf(*decl); + if (eid != kInvalidEntityId) { + entity_to_object_[eid] = idx; + } + } + + return idx; +} + +uint32_t IRGenerator::GetOrMakeObject(const pasta::Decl &decl) { + auto eid = EntityIdOf(decl); + if (eid != kInvalidEntityId) { + auto it = entity_to_object_.find(eid); + if (it != entity_to_object_.end()) return it->second; + } + + mx::ir::ObjectKind kind = mx::ir::ObjectKind::LOCAL; + if (auto vd = pasta::VarDecl::From(decl)) { + bool addr_taken = address_taken_.count(eid); + if (vd->HasGlobalStorage() || vd->IsStaticLocal()) { + kind = mx::ir::ObjectKind::GLOBAL; + } else if (vd->TSCSpec() != pasta::ThreadStorageClassSpecifier::kUnspecified) { + kind = mx::ir::ObjectKind::THREAD_LOCAL; + } else { + kind = addr_taken ? mx::ir::ObjectKind::LOCAL + : mx::ir::ObjectKind::LOCAL_VALUE; + } + } + + return MakeObject(kind, &decl); +} + +// --------------------------------------------------------------------------- +// Instruction emission +// --------------------------------------------------------------------------- + +uint32_t IRGenerator::EmitInstruction(InstructionIR inst) { + inst.parent_block_index = current_block_index_; + uint32_t idx = static_cast(func_.instructions.size()); + func_.instructions.push_back(std::move(inst)); + return idx; +} + +uint32_t IRGenerator::EmitTopLevel(InstructionIR inst) { + uint32_t idx = EmitInstruction(std::move(inst)); + func_.blocks[current_block_index_].instruction_indices.push_back(idx); + // Root: parent instruction is none, parent block is the current block. + func_.instructions[idx].parent_instruction_index = UINT32_MAX; + func_.instructions[idx].is_root = true; + SetOperandParents(idx); + return idx; +} + +void IRGenerator::SetOperandParents(uint32_t inst_idx) { + auto &inst = func_.instructions[inst_idx]; + for (auto op_idx : inst.operand_indices) { + auto &op = func_.instructions[op_idx]; + // Don't reparent instructions that are roots in a block. + if (op.is_root) continue; + op.parent_instruction_index = inst_idx; + SetOperandParents(op_idx); + } +} + +// --------------------------------------------------------------------------- +// Expression scope for calls +// --------------------------------------------------------------------------- + +bool IRGenerator::CurrentBlockTerminated() const { + auto &blk = func_.blocks[current_block_index_]; + if (blk.instruction_indices.empty()) return false; + return mx::ir::IsTerminator( + func_.instructions[blk.instruction_indices.back()].opcode); +} + +bool IRGenerator::ContainsCall(const pasta::Expr &e) { + if (pasta::CallExpr::From(e)) return true; + for (auto child : e.Children()) { + if (auto child_expr = pasta::Expr::From(child)) { + if (ContainsCall(*child_expr)) return true; + } + } + return false; +} + +uint32_t IRGenerator::EnsureExpressionScope(mx::RawEntityId source_eid) { + if (expression_scope_index_ != UINT32_MAX) { + return expression_scope_index_; + } + expression_scope_index_ = PushStructure( + mx::ir::StructureKind::EXPRESSION_SCOPE, source_eid); + InstructionIR enter; + enter.opcode = mx::ir::OpCode::ENTER_SCOPE; + enter.source_entity_id = source_eid; + enter.structure_index = expression_scope_index_; + EmitTopLevel(std::move(enter)); + return expression_scope_index_; +} + +void IRGenerator::PopExpressionScope() { + if (expression_scope_index_ == UINT32_MAX) return; + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.structure_index = expression_scope_index_; + EmitTopLevel(std::move(exit_inst)); + PopStructure(); + expression_scope_index_ = UINT32_MAX; +} + +// --------------------------------------------------------------------------- +// Statement emission (builds the CFG) +// --------------------------------------------------------------------------- + +void IRGenerator::EmitBody(const pasta::Stmt &body) { + if (auto cs = pasta::CompoundStmt::From(body)) { + // Push a SCOPE structure for compound statements that are NOT the + // function body. The function body is identified by matching the + // body_scope's source entity ID — not by checking the current + // structure kind, which could be FUNCTION_SCOPE even for nested + // CompoundStmts that are direct children of the function body. + bool is_function_body = (func_.body_scope_index != UINT32_MAX && + func_.structures[func_.body_scope_index].source_entity_id == + EntityIdOf(body)); + if (!is_function_body) { + PushStructure(mx::ir::StructureKind::SCOPE, EntityIdOf(body)); + + // Emit ENTER_SCOPE instruction. + InstructionIR enter; + enter.opcode = mx::ir::OpCode::ENTER_SCOPE; + enter.source_entity_id = EntityIdOf(body); + enter.structure_index = current_structure_index_; + EmitTopLevel(std::move(enter)); + } + + for (const auto &child : cs->Children()) { + // Skip dead code after a terminator (goto/return/break/continue), + // but always process labels and case/default — they start new + // reachable blocks. + if (CurrentBlockTerminated() && + !pasta::LabelStmt::From(child) && + !pasta::CaseStmt::From(child) && + !pasta::DefaultStmt::From(child)) continue; + EmitStmt(child); + } + + if (!is_function_body) { + // Only emit EXIT_SCOPE if the block isn't already terminated + // (e.g., all paths returned/broke). The scope exit is already + // handled by the terminating paths (return/goto emit their own + // EXIT_SCOPE before the terminator). + if (!CurrentBlockTerminated()) { + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = EntityIdOf(body); + exit_inst.structure_index = current_structure_index_; + EmitTopLevel(std::move(exit_inst)); + } + + PopStructure(); + } + } else { + EmitStmt(body); + } +} + +void IRGenerator::EmitStmt(const pasta::Stmt &s) { + // Inline assembly -- emit as UNKNOWN with operands for inputs/outputs. + if (pasta::GCCAsmStmt::From(s) || pasta::MSAsmStmt::From(s)) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::UNKNOWN; + inst.source_entity_id = EntityIdOf(s); + // Emit children (input/output operands) so data flow is tracked. + for (const auto &child : s.Children()) { + if (auto expr = pasta::Expr::From(child)) { + inst.operand_indices.push_back(EmitRValue(*expr)); + } + } + EmitTopLevel(std::move(inst)); + return; + } + + if (pasta::IfStmt::From(s)) { EmitIfStmt(s); return; } + if (pasta::WhileStmt::From(s)) { EmitWhileStmt(s); return; } + if (pasta::DoStmt::From(s)) { EmitDoStmt(s); return; } + if (pasta::ForStmt::From(s)) { EmitForStmt(s); return; } + if (pasta::SwitchStmt::From(s)) { EmitSwitchStmt(s); return; } + if (pasta::ReturnStmt::From(s)) { EmitReturnStmt(s); return; } + if (pasta::DeclStmt::From(s)) { EmitDeclStmt(s); return; } + if (pasta::BreakStmt::From(s)) { EmitBreakStmt(s); return; } + if (pasta::ContinueStmt::From(s)) { EmitContinueStmt(s); return; } + if (pasta::GotoStmt::From(s)) { EmitGotoStmt(s); return; } + if (pasta::LabelStmt::From(s)) { EmitLabelStmt(s); return; } + + // Case/default encountered during body emission (fallthrough). + // If the current block's last instruction is an explicit FALLTHROUGH, + // patch its branch target. Otherwise emit a branch. + if (pasta::CaseStmt::From(s) || pasta::DefaultStmt::From(s)) { + auto it = case_blocks_.find(EntityIdOf(s)); + if (it != case_blocks_.end()) { + uint32_t target_block = it->second; + + // Check if the last instruction is an explicit FALLTHROUGH to patch. + auto &blk = func_.blocks[current_block_index_]; + bool patched = false; + if (!blk.instruction_indices.empty()) { + auto &last = func_.instructions[blk.instruction_indices.back()]; + if (last.opcode == mx::ir::OpCode::FALLTHROUGH && + last.branch_targets.empty()) { + BranchTargetIR bt; + bt.block_index = target_block; + last.branch_targets = {bt}; + AddEdge(current_block_index_, target_block); + patched = true; + } + } + if (!patched) { + EmitBranch(target_block, EntityIdOf(s)); + } + SwitchToBlock(target_block); + } + + if (auto cs = pasta::CaseStmt::From(s)) { + EmitBody(cs->SubStatement()); + } else if (auto ds = pasta::DefaultStmt::From(s)) { + EmitBody(ds->SubStatement()); + } + return; + } + + // AttributedStmt (wraps [[fallthrough]], [[likely]], etc.) + if (auto as = pasta::AttributedStmt::From(s)) { + bool is_fallthrough = false; + for (const auto &attr : as->Attributes()) { + if (pasta::FallThroughAttr::From(attr)) { + is_fallthrough = true; + break; + } + } + if (is_fallthrough) { + // Emit a FALLTHROUGH terminator. The branch target will be filled in + // when the next case/default is encountered (see case/default handler). + InstructionIR inst; + inst.opcode = mx::ir::OpCode::FALLTHROUGH; + inst.source_entity_id = EntityIdOf(s); + // Branch target left empty -- will be patched by the case/default handler. + EmitTopLevel(std::move(inst)); + } + EmitStmt(as->SubStatement()); + return; + } + + // NullStmt (empty statement, e.g. lone ';') + if (pasta::NullStmt::From(s)) { + return; + } + + // Compound statement (nested block) -- push/pop a SCOPE. + if (auto cs = pasta::CompoundStmt::From(s)) { + // Delegate to EmitBody which handles dead-code skipping and + // EXIT_SCOPE guarding for terminated blocks. + EmitBody(s); + return; + } + + // Expression statement. + if (auto expr = pasta::Expr::From(s)) { + uint32_t val_idx = EmitRValue(*expr); + func_.blocks[current_block_index_].instruction_indices.push_back(val_idx); + func_.instructions[val_idx].parent_instruction_index = UINT32_MAX; + func_.instructions[val_idx].is_root = true; + SetOperandParents(val_idx); + // Pop expression scope at the full-expression boundary (the `;`). + PopExpressionScope(); + + // If the expression is a call to a noreturn function, emit UNREACHABLE + // and switch to a dead block. + if (auto ce = pasta::CallExpr::From(*expr)) { + bool is_noreturn = false; + if (auto callee = ce->DirectCallee()) { + is_noreturn = callee->IsNoReturn(); + } + if (is_noreturn) { + InstructionIR unreach; + unreach.opcode = mx::ir::OpCode::UNREACHABLE; + unreach.source_entity_id = EntityIdOf(s); + EmitTopLevel(std::move(unreach)); + SwitchToDeadBlock(); + } + } + return; + } + + // Unhandled statement kind. + DCHECK(false) << "Unhandled statement kind in IR generation"; +} + +void IRGenerator::EmitIfStmt(const pasta::Stmt &s) { + auto ifs = pasta::IfStmt::From(s); + if (!ifs) return; + + PushStructure(mx::ir::StructureKind::IF, EntityIdOf(s)); + + uint32_t cond_idx = EmitRValue(ifs->Condition()); + PopExpressionScope(); + uint32_t then_block = NewBlock(mx::ir::BlockKind::IF_THEN); + uint32_t else_block = NewBlock(mx::ir::BlockKind::IF_ELSE); + + EmitCondBranch(cond_idx, then_block, else_block, EntityIdOf(s)); + + // Lazily create the merge block when a branch falls through. + uint32_t merge_block = UINT32_MAX; + auto get_merge = [&]() -> uint32_t { + if (merge_block == UINT32_MAX) { + merge_block = NewBlock(mx::ir::BlockKind::IF_MERGE); + } + return merge_block; + }; + + PushStructure(mx::ir::StructureKind::IF_THEN, EntityIdOf(ifs->Then())); + SwitchToBlock(then_block); + AssociateBlockWithStructure(then_block); + EmitBody(ifs->Then()); + if (!CurrentBlockTerminated()) EmitBranch(get_merge()); + PopStructure(); // IF_THEN + + PushStructure(mx::ir::StructureKind::IF_ELSE); + SwitchToBlock(else_block); + AssociateBlockWithStructure(else_block); + if (auto else_body = ifs->Else()) { + EmitBody(*else_body); + } + if (!CurrentBlockTerminated()) EmitBranch(get_merge()); + PopStructure(); // IF_ELSE + + if (merge_block != UINT32_MAX) { + AssociateBlockWithStructure(merge_block); + SwitchToBlock(merge_block); + } else { + // Both branches terminated — no merge needed. + SwitchToDeadBlock(); + } + + PopStructure(); // IF +} + +void IRGenerator::EmitWhileStmt(const pasta::Stmt &s) { + auto ws = pasta::WhileStmt::From(s); + if (!ws) return; + + PushStructure(mx::ir::StructureKind::WHILE, EntityIdOf(s)); + + uint32_t preheader = NewBlock(mx::ir::BlockKind::LOOP_PREHEADER); + uint32_t cond_block = NewBlock(mx::ir::BlockKind::LOOP_CONDITION); + uint32_t body_block = NewBlock(mx::ir::BlockKind::LOOP_BODY); + uint32_t exit_block = NewBlock(mx::ir::BlockKind::LOOP_EXIT); + + EmitBranch(preheader); + SwitchToBlock(preheader); + AssociateBlockWithStructure(preheader); + EmitBranch(cond_block); + + PushStructure(mx::ir::StructureKind::WHILE_CONDITION, EntityIdOf(ws->Condition())); + SwitchToBlock(cond_block); + AssociateBlockWithStructure(cond_block); + uint32_t cond_idx = EmitRValue(ws->Condition()); + PopExpressionScope(); + EmitCondBranch(cond_idx, body_block, exit_block, EntityIdOf(s)); + PopStructure(); // WHILE_CONDITION + + loop_stack_.push_back({exit_block, cond_block, current_structure_index_, false}); + PushStructure(mx::ir::StructureKind::WHILE_BODY, EntityIdOf(ws->Body())); + SwitchToBlock(body_block); + AssociateBlockWithStructure(body_block); + EmitBody(ws->Body()); + EmitBranch(cond_block); + PopStructure(); // WHILE_BODY + loop_stack_.pop_back(); + + AssociateBlockWithStructure(exit_block); + SwitchToBlock(exit_block); + + PopStructure(); // WHILE +} + +void IRGenerator::EmitDoStmt(const pasta::Stmt &s) { + auto ds = pasta::DoStmt::From(s); + if (!ds) return; + + PushStructure(mx::ir::StructureKind::DO_WHILE, EntityIdOf(s)); + + uint32_t preheader = NewBlock(mx::ir::BlockKind::LOOP_PREHEADER); + uint32_t body_block = NewBlock(mx::ir::BlockKind::LOOP_BODY); + uint32_t cond_block = NewBlock(mx::ir::BlockKind::LOOP_CONDITION); + uint32_t exit_block = NewBlock(mx::ir::BlockKind::LOOP_EXIT); + + EmitBranch(preheader); + SwitchToBlock(preheader); + AssociateBlockWithStructure(preheader); + EmitBranch(body_block); + + loop_stack_.push_back({exit_block, cond_block, current_structure_index_, false}); + PushStructure(mx::ir::StructureKind::DO_WHILE_BODY, EntityIdOf(ds->Body())); + SwitchToBlock(body_block); + AssociateBlockWithStructure(body_block); + EmitBody(ds->Body()); + EmitBranch(cond_block); + PopStructure(); // DO_WHILE_BODY + loop_stack_.pop_back(); + + PushStructure(mx::ir::StructureKind::DO_WHILE_CONDITION, EntityIdOf(ds->Condition())); + SwitchToBlock(cond_block); + AssociateBlockWithStructure(cond_block); + uint32_t cond_idx = EmitRValue(ds->Condition()); + PopExpressionScope(); + EmitCondBranch(cond_idx, body_block, exit_block, EntityIdOf(s)); + PopStructure(); // DO_WHILE_CONDITION + + AssociateBlockWithStructure(exit_block); + SwitchToBlock(exit_block); + + PopStructure(); // DO_WHILE +} + +void IRGenerator::EmitForStmt(const pasta::Stmt &s) { + auto fs = pasta::ForStmt::From(s); + if (!fs) return; + + // If the for-init declares variables, wrap the entire for loop in an + // implicit SCOPE so those variables have correct lifetimes. + auto init = fs->Initializer(); + bool has_init_decl = init && pasta::DeclStmt::From(*init); + if (has_init_decl) { + PushStructure(mx::ir::StructureKind::SCOPE, EntityIdOf(s)); + InstructionIR enter; + enter.opcode = mx::ir::OpCode::ENTER_SCOPE; + enter.source_entity_id = EntityIdOf(s); + enter.structure_index = current_structure_index_; + EmitTopLevel(std::move(enter)); + } + + PushStructure(mx::ir::StructureKind::FOR, EntityIdOf(s)); + + uint32_t preheader = NewBlock(mx::ir::BlockKind::LOOP_PREHEADER); + uint32_t cond_block = NewBlock(mx::ir::BlockKind::LOOP_CONDITION); + uint32_t body_block = NewBlock(mx::ir::BlockKind::LOOP_BODY); + uint32_t inc_block = NewBlock(mx::ir::BlockKind::LOOP_INCREMENT); + uint32_t exit_block = NewBlock(mx::ir::BlockKind::LOOP_EXIT); + + EmitBranch(preheader); + SwitchToBlock(preheader); + AssociateBlockWithStructure(preheader); + + // For-init lives in the preheader. + if (init) { + PushStructure(mx::ir::StructureKind::FOR_INIT, EntityIdOf(*init)); + EmitStmt(*init); + PopStructure(); // FOR_INIT + } + + EmitBranch(cond_block); + + PushStructure(mx::ir::StructureKind::FOR_CONDITION); + SwitchToBlock(cond_block); + AssociateBlockWithStructure(cond_block); + if (auto cond = fs->Condition()) { + uint32_t cond_idx = EmitRValue(*cond); + PopExpressionScope(); + EmitCondBranch(cond_idx, body_block, exit_block, EntityIdOf(s)); + } else { + EmitBranch(body_block); + } + PopStructure(); // FOR_CONDITION + + loop_stack_.push_back({exit_block, inc_block, current_structure_index_, false}); + PushStructure(mx::ir::StructureKind::FOR_BODY, EntityIdOf(fs->Body())); + SwitchToBlock(body_block); + AssociateBlockWithStructure(body_block); + EmitBody(fs->Body()); + EmitBranch(inc_block); + PopStructure(); // FOR_BODY + loop_stack_.pop_back(); + + PushStructure(mx::ir::StructureKind::FOR_INCREMENT); + SwitchToBlock(inc_block); + AssociateBlockWithStructure(inc_block); + if (auto inc = fs->Increment()) { + uint32_t inc_idx = EmitRValue(*inc); + PopExpressionScope(); + func_.blocks[current_block_index_].instruction_indices.push_back(inc_idx); + func_.instructions[inc_idx].parent_instruction_index = UINT32_MAX; + func_.instructions[inc_idx].is_root = true; + SetOperandParents(inc_idx); + } + EmitBranch(cond_block); + PopStructure(); // FOR_INCREMENT + + AssociateBlockWithStructure(exit_block); + SwitchToBlock(exit_block); + + PopStructure(); // FOR + + if (has_init_decl) { + // current_structure_index_ is now the implicit SCOPE since FOR was popped. + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = EntityIdOf(s); + exit_inst.structure_index = current_structure_index_; + EmitTopLevel(std::move(exit_inst)); + PopStructure(); // implicit SCOPE + } +} + +void IRGenerator::EmitSwitchStmt(const pasta::Stmt &s) { + auto sw = pasta::SwitchStmt::From(s); + if (!sw) return; + + PushStructure(mx::ir::StructureKind::SWITCH, EntityIdOf(s)); + + uint32_t cond_idx = EmitRValue(sw->Condition()); + PopExpressionScope(); + uint32_t exit_block = NewBlock(mx::ir::BlockKind::SWITCH_EXIT); + + // Collect case/default statements and create a block for each. + struct CaseInfo { + int64_t low{0}; + int64_t high{0}; + bool is_default{false}; + uint32_t block_index; + mx::RawEntityId source_entity_id{mx::kInvalidEntityId}; + }; + std::vector cases; + + auto body = sw->Body(); + std::function collect_cases; + collect_cases = [&](const pasta::Stmt &stmt) { + if (auto cs = pasta::CaseStmt::From(stmt)) { + int64_t low = 0, high = 0; + auto *raw_lhs = reinterpret_cast( + cs->LHS().RawStmt()); + if (raw_lhs) { + clang::Expr::EvalResult result; + if (raw_lhs->EvaluateAsInt(result, ctx_)) { + low = result.Val.getInt().getSExtValue(); + high = low; + } + } + // GNU range case: case low ... high: + if (cs->CaseStatementIsGNURange()) { + if (auto rhs = cs->RHS()) { + auto *raw_rhs = reinterpret_cast( + rhs->RawStmt()); + if (raw_rhs) { + clang::Expr::EvalResult result; + if (raw_rhs->EvaluateAsInt(result, ctx_)) { + high = result.Val.getInt().getSExtValue(); + } + } + } + } + uint32_t block = NewBlock(mx::ir::BlockKind::SWITCH_CASE); + cases.push_back({low, high, false, block, EntityIdOf(stmt)}); + case_blocks_[EntityIdOf(stmt)] = block; + // Recurse into SubStatement to find nested cases (case 1: case 2: ...). + auto sub = cs->SubStatement(); + if (pasta::CaseStmt::From(sub) || pasta::DefaultStmt::From(sub)) { + collect_cases(sub); + } + return; + } + if (auto ds = pasta::DefaultStmt::From(stmt)) { + uint32_t block = NewBlock(mx::ir::BlockKind::SWITCH_DEFAULT); + cases.push_back({0, 0, true, block, EntityIdOf(stmt)}); + case_blocks_[EntityIdOf(stmt)] = block; + auto sub = ds->SubStatement(); + if (pasta::CaseStmt::From(sub) || pasta::DefaultStmt::From(sub)) { + collect_cases(sub); + } + return; + } + // Recurse into children, but stop at nested switch statements — + // their cases belong to the inner switch, not this one. + for (const auto &child : stmt.Children()) { + if (pasta::SwitchStmt::From(child)) continue; + collect_cases(child); + } + }; + collect_cases(body); + + // Build switch terminator. + // Branch targets: case blocks first, then default block last. + // switch_cases: one SwitchCase per non-default case. + InstructionIR term; + term.opcode = mx::ir::OpCode::SWITCH; + term.source_entity_id = EntityIdOf(s); + term.operand_indices = {cond_idx}; + + // Store the case type from the selector expression. + auto cond_type = sw->Condition().Type(); + if (cond_type) term.type_entity_id = TypeEntityIdOf(*cond_type); + + // Build switch cases with full provenance. + for (const auto &ci : cases) { + InstructionIR::SwitchCaseIR sc; + sc.low = ci.low; + sc.high = ci.high; + sc.block_index = ci.block_index; + sc.source_entity_id = ci.source_entity_id; + sc.is_default = ci.is_default; + term.switch_cases.push_back(sc); + AddEdge(current_block_index_, ci.block_index); + } + + uint32_t term_idx = EmitTopLevel(std::move(term)); + + // Push switch context so break statements work. + // continue_block = 0 is unused (continue skips switch contexts). + loop_stack_.push_back({exit_block, 0, current_structure_index_, true}); + + // Emit case bodies. + // Emit case bodies. Before switching to each new case block, check if + // the current block has been terminated. If not, it's implicit fallthrough. + size_t ci = 0; + auto maybe_emit_implicit_fallthrough = [&](uint32_t next_block) { + auto &blk = func_.blocks[current_block_index_]; + // If the block already has a terminator, skip. + if (!blk.instruction_indices.empty()) { + auto &last = func_.instructions[blk.instruction_indices.back()]; + if (mx::ir::IsTerminator(last.opcode)) return; + } + // (Empty UNREACHABLE blocks now have IMPLICIT_UNREACHABLE terminators, + // so the terminator check above catches them.) + // Current block has no terminator -- implicit fallthrough. + InstructionIR inst; + inst.opcode = mx::ir::OpCode::IMPLICIT_FALLTHROUGH; + BranchTargetIR target; + target.block_index = next_block; + inst.branch_targets = {target}; + EmitTopLevel(std::move(inst)); + AddEdge(current_block_index_, next_block); + }; + + std::function emit_case_bodies; + emit_case_bodies = [&](const pasta::Stmt &stmt) { + if (auto cs = pasta::CaseStmt::From(stmt)) { + if (ci < cases.size()) { + maybe_emit_implicit_fallthrough(cases[ci].block_index); + PushStructure(mx::ir::StructureKind::SWITCH_CASE, + cases[ci].source_entity_id); + // Store case value data in the structure. + auto &sc_struct = func_.structures[current_structure_index_]; + sc_struct.case_low = cases[ci].low; + sc_struct.case_high = cases[ci].high; + sc_struct.is_default = false; + // Record structure index back into the switch instruction. + func_.instructions[term_idx].switch_cases[ci].structure_index = + current_structure_index_; + SwitchToBlock(cases[ci].block_index); + AssociateBlockWithStructure(cases[ci].block_index); + // Record case block structure for Duff's device (external goto into case). + label_structure_[cases[ci].block_index] = current_structure_index_; + ci++; + // If SubStatement is another case/default, handle it via recursion + // (empty case fallthrough: case 1: case 2: case 3: body). + auto sub = cs->SubStatement(); + if (pasta::CaseStmt::From(sub) || pasta::DefaultStmt::From(sub)) { + emit_case_bodies(sub); + } else { + EmitBody(sub); + } + PopStructure(); // SWITCH_CASE + } + return; + } + if (auto ds = pasta::DefaultStmt::From(stmt)) { + if (ci < cases.size()) { + maybe_emit_implicit_fallthrough(cases[ci].block_index); + PushStructure(mx::ir::StructureKind::SWITCH_CASE, + cases[ci].source_entity_id); + auto &sc_struct = func_.structures[current_structure_index_]; + sc_struct.is_default = true; + func_.instructions[term_idx].switch_cases[ci].structure_index = + current_structure_index_; + SwitchToBlock(cases[ci].block_index); + AssociateBlockWithStructure(cases[ci].block_index); + label_structure_[cases[ci].block_index] = current_structure_index_; + ci++; + auto sub = ds->SubStatement(); + if (pasta::CaseStmt::From(sub) || pasta::DefaultStmt::From(sub)) { + emit_case_bodies(sub); + } else { + EmitBody(sub); + } + PopStructure(); // SWITCH_CASE (default) + } + return; + } + // For CompoundStmt or other container, process children. + // Non-case/default statements (like break, assignments between cases) + // are emitted directly. + if (pasta::CompoundStmt::From(stmt)) { + for (const auto &child : stmt.Children()) { + // Skip dead code after a terminator, but always process case/default. + if (CurrentBlockTerminated() && + !pasta::CaseStmt::From(child) && + !pasta::DefaultStmt::From(child)) continue; + // Don't descend into nested switch statements — their cases + // belong to the inner switch, not this one. + if (pasta::SwitchStmt::From(child)) { + EmitStmt(child); + } else { + emit_case_bodies(child); + } + } + } else { + // Regular statement between cases (e.g., break, goto, assignment). + EmitStmt(stmt); + } + }; + emit_case_bodies(body); + + // Verify all switch cases got their structure index set. + for (size_t sci = 0; sci < func_.instructions[term_idx].switch_cases.size(); + ++sci) { + auto &sc = func_.instructions[term_idx].switch_cases[sci]; + DCHECK(sc.structure_index != UINT32_MAX) + << "Switch case " << sci << " (of " + << func_.instructions[term_idx].switch_cases.size() + << ") has no structure_index; ci=" << ci + << " low=" << sc.low << " is_default=" << sc.is_default + << " func_eid=" << func_.func_decl_entity_id; + } + + // After all cases, if the last case didn't terminate, branch to exit. + if (!CurrentBlockTerminated()) { + maybe_emit_implicit_fallthrough(exit_block); + EmitBranch(exit_block); + } + + loop_stack_.pop_back(); + AssociateBlockWithStructure(exit_block); + SwitchToBlock(exit_block); + + PopStructure(); // SWITCH +} + +void IRGenerator::EmitReturnStmt(const pasta::Stmt &s) { + auto rs = pasta::ReturnStmt::From(s); + if (!rs) return; + + // Emit the return value first (before scope exits). + InstructionIR inst; + inst.opcode = mx::ir::OpCode::RET; + inst.source_entity_id = EntityIdOf(s); + + auto rv = rs->ReturnValue(); + if (rv) { + uint32_t val_idx = EmitRValue(*rv); + PopExpressionScope(); + + // RET carries the value as operand for backward compat + // (RetInst::return_value() reads it). + inst.operand_indices = {val_idx}; + + // Emit RETURN_PTR to get pointer to caller's return storage. + InstructionIR ret_ptr; + ret_ptr.opcode = SizedPtrOp(mx::ir::OpCode::RETURN_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + ret_ptr.source_entity_id = EntityIdOf(s); + if (auto t = rv->Type()) ret_ptr.type_entity_id = TypeEntityIdOf(*t); + uint32_t ret_ptr_idx = EmitInstruction(std::move(ret_ptr)); + + // Store the return value into RETURN_PTR. + unsigned sz = 8; + if (auto t = rv->Type()) { + if (auto s = TypeSizeBytes(*t)) sz = *s; + } + InstructionIR store; + store.opcode = mx::ir::OpCode::MEMORY; + store.source_entity_id = EntityIdOf(s); + if (!IsScalarSize(sz) || rv->IsLValue()) { + // Large or lvalue: MEMCPY. + uint32_t size_idx = EmitSizeConst(sz); + uint32_t src_idx = rv->IsLValue() ? EmitLValue(*rv) : val_idx; + store.operand_indices = {ret_ptr_idx, src_idx, size_idx}; + store.mem_op = static_cast(mx::ir::MemOp::MEMCPY); + } else { + store.operand_indices = {ret_ptr_idx, val_idx}; + bool ret_is_float = false; + if (auto t = rv->Type()) ret_is_float = t->IsFloatingType(); + store.mem_op = static_cast( + DetermineMemOp(true, false, sz, ret_is_float)); + } + EmitTopLevel(std::move(store)); + } + + // Exit all scopes up to and including the function scope. + EmitScopeExits(func_.body_scope_index); + { + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = func_.structures[func_.body_scope_index].source_entity_id; + exit_inst.structure_index = func_.body_scope_index; + EmitTopLevel(std::move(exit_inst)); + } + + EmitTopLevel(std::move(inst)); +} + +void IRGenerator::EmitDeclStmt(const pasta::Stmt &s) { + auto ds = pasta::DeclStmt::From(s); + if (!ds) return; + + // Allocas were already emitted in the frame block by EmitEntryBlockAllocas. + // Here we only emit the initialization store for non-static locals. + // Static locals are initialized by their GLOBAL_INITIALIZER functions. + for (const auto &decl : ds->Declarations()) { + auto vd = pasta::VarDecl::From(decl); + if (!vd) continue; + if (pasta::ParmVarDecl::From(decl)) continue; + + // Static/global-storage variables: initialization is handled by + // GLOBAL_INITIALIZER. Don't emit local init code. + if (vd->HasGlobalStorage()) continue; + + uint32_t obj_idx = GetOrMakeObject(decl); + AssociateObjectWithScope(obj_idx); + + // VLA: emit ALLOCA/DYNAMIC with runtime size at declaration point. + if (vd->Type().IsVariablyModifiedType()) { + // Get the size expression from the VariableArrayType. + auto vla_type = pasta::VariableArrayType::From(vd->Type()); + if (!vla_type) vla_type = pasta::VariableArrayType::From( + vd->Type().CanonicalType()); + + uint32_t size_idx = UINT32_MAX; + if (vla_type) { + // Runtime size = element_count * element_size. + auto size_expr = vla_type->SizeExpression(); + uint32_t count_idx = EmitRValue(size_expr); + // Get element size from the element type. + auto elem_type = vla_type->ElementType(); + uint32_t elem_sz = 1; + if (auto sz = TypeSizeBytes(elem_type)) elem_sz = *sz; + uint32_t elem_idx = EmitSizeConst(elem_sz); + InstructionIR mul; + mul.opcode = SizedIntOp(IntOp::MUL, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + mul.source_entity_id = EntityIdOf(decl); + mul.operand_indices = {count_idx, elem_idx}; + size_idx = EmitInstruction(std::move(mul)); + } + + InstructionIR alloca_inst; + alloca_inst.opcode = mx::ir::OpCode::ALLOCA; + alloca_inst.alloca_kind = static_cast(mx::ir::AllocaKind::DYNAMIC); + alloca_inst.source_entity_id = EntityIdOf(decl); + alloca_inst.object_index = obj_idx; + alloca_inst.type_entity_id = TypeEntityIdOf(vd->Type()); + if (size_idx != UINT32_MAX) { + alloca_inst.operand_indices = {size_idx}; + } + uint32_t alloca_idx = EmitTopLevel(std::move(alloca_inst)); + object_to_alloca_[obj_idx] = alloca_idx; + continue; + } + + if (auto init = vd->Initializer()) { + uint32_t addr_idx = object_to_alloca_[obj_idx]; + EmitInitializer(addr_idx, *init, EntityIdOf(decl)); + } + } +} + +void IRGenerator::EmitBreakStmt(const pasta::Stmt &s) { + for (auto it = loop_stack_.rbegin(); it != loop_stack_.rend(); ++it) { + EmitScopeExits(it->structure_index); + EmitBranchWithOpCode(mx::ir::OpCode::BREAK, it->break_block, + EntityIdOf(s)); + SwitchToDeadBlock(); + return; + } + DCHECK(false) << "break statement outside of loop/switch"; +} + +void IRGenerator::EmitContinueStmt(const pasta::Stmt &s) { + for (auto it = loop_stack_.rbegin(); it != loop_stack_.rend(); ++it) { + if (!it->is_switch) { + EmitScopeExits(it->structure_index); + EmitBranchWithOpCode(mx::ir::OpCode::CONTINUE, it->continue_block, + EntityIdOf(s)); + SwitchToDeadBlock(); + return; + } + } + DCHECK(false) << "continue statement outside of loop"; +} + +void IRGenerator::EmitGotoStmt(const pasta::Stmt &s) { + auto gs = pasta::GotoStmt::From(s); + if (!gs) return; + + auto label = gs->Label(); + std::string label_name = label.Name(); + + auto it = label_blocks_.find(label_name); + uint32_t target; + if (it != label_blocks_.end()) { + target = it->second; + } else { + target = NewBlock(mx::ir::BlockKind::LABEL); + label_blocks_[label_name] = target; + } + + // Don't emit scope exits here — compensation blocks handle it. + // Record the goto for post-processing. + uint32_t goto_idx = EmitBranchWithOpCode(mx::ir::OpCode::GOTO, target, + EntityIdOf(s)); + if (goto_idx != UINT32_MAX) { + pending_gotos_.push_back({goto_idx, current_block_index_, target, + current_structure_index_}); + } + SwitchToDeadBlock(); +} + +void IRGenerator::EmitLabelStmt(const pasta::Stmt &s) { + auto ls = pasta::LabelStmt::From(s); + if (!ls) return; + + std::string label_name(ls->Name()); + + auto it = label_blocks_.find(label_name); + uint32_t label_block; + if (it != label_blocks_.end()) { + label_block = it->second; + } else { + label_block = NewBlock(mx::ir::BlockKind::LABEL); + label_blocks_[label_name] = label_block; + } + + // Record which structure this label is in (for goto compensation). + label_structure_[label_block] = current_structure_index_; + + // Reaching a label sequentially is an implicit goto. + EmitBranchWithOpCode(mx::ir::OpCode::IMPLICIT_GOTO, label_block, + EntityIdOf(s)); + SwitchToBlock(label_block); + AssociateBlockWithStructure(label_block); + + EmitStmt(ls->SubStatement()); +} + +// --------------------------------------------------------------------------- +// Initializer emission (decomposes aggregates into element stores) +// --------------------------------------------------------------------------- + +void IRGenerator::EmitInitializer(uint32_t dest_addr_idx, + const pasta::Expr &init, + mx::RawEntityId source_eid) { + // If the initializer is an InitListExpr, decompose it into element stores. + if (auto ile = pasta::InitListExpr::From(init)) { + auto inits = ile->Initializers(); + auto maybe_type = init.Type(); + if (!maybe_type) goto scalar_fallback; + + auto type = *maybe_type; + + // Zero-initialize the whole object before element-wise stores. + // The compiler emits a memset for aggregate initialization. + // ENTER_SCOPE only marks memory as allocated-but-uninitialized; + // this MEMSET is what actually makes the memory defined. + auto total_size = TypeSizeBytes(type); + if (total_size && *total_size > 0) { + InstructionIR zero; + zero.opcode = mx::ir::OpCode::CONST; + zero.const_op = static_cast(mx::ir::ConstOp::UINT8); + zero.source_entity_id = source_eid; + zero.int_value = 0; + zero.uint_value = 0; + zero.width = 8; + uint32_t zero_idx = EmitInstruction(std::move(zero)); + + uint32_t sz_idx = EmitSizeConst(*total_size, source_eid); + + InstructionIR memset_inst; + memset_inst.opcode = mx::ir::OpCode::MEMORY; + memset_inst.mem_op = static_cast(mx::ir::MemOp::MEMSET); + memset_inst.source_entity_id = source_eid; + memset_inst.operand_indices = {dest_addr_idx, zero_idx, sz_idx}; + EmitTopLevel(std::move(memset_inst)); + } + + // Strip qualifiers/sugar to get the underlying type. + auto canon = type.CanonicalType(); + + // Array initialization: PTR_ADD for each element. + if (auto arr_type = pasta::ConstantArrayType::From(canon)) { + auto elem_type = arr_type->ElementType(); + auto elem_size = TypeSizeBytes(elem_type); + if (!elem_size || *elem_size == 0) goto scalar_fallback; + + for (uint32_t i = 0; i < inits.size(); ++i) { + uint32_t elem_addr; + if (i == 0) { + elem_addr = dest_addr_idx; + } else { + // PTR_ADD base, i. Index is ptrdiff_t. + InstructionIR ci; + ci.opcode = mx::ir::OpCode::CONST; + ci.const_op = static_cast(IntConstOp(ptrdiff_type_width_, true)); + ci.source_entity_id = source_eid; + ci.int_value = static_cast(i); + ci.uint_value = static_cast(i); + ci.width = ptrdiff_type_width_; + ci.type_entity_id = ptrdiff_type_eid_; + uint32_t idx_val = EmitInstruction(std::move(ci)); + + InstructionIR pa; + pa.opcode = SizedPtrOp(mx::ir::OpCode::PTR_ADD_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + pa.source_entity_id = source_eid; + pa.operand_indices = {dest_addr_idx, idx_val}; + pa.type_entity_id = TypeEntityIdOf(elem_type); + pa.size_bytes = *elem_size; + elem_addr = EmitInstruction(std::move(pa)); + } + // Recurse for nested aggregates. + EmitInitializer(elem_addr, inits[i], source_eid); + } + + return; + } + + // Struct/union initialization: GEP_FIELD for each field. + if (auto rec_type = pasta::RecordType::From(canon)) { + auto rec_decl = rec_type->Declaration(); + auto fields = rec_decl.Fields(); + + uint32_t init_idx = 0; + for (const auto &field : fields) { + if (init_idx >= inits.size()) break; + + // Bit-fields: use BIT_WRITE to set individual bit ranges. + if (field.IsBitField()) { + auto offset_bits = field.OffsetInBits(); + auto bw = field.BitWidth(); + if (offset_bits && bw) { + // Get bit width from the BitWidth expression. + auto *raw_bw = reinterpret_cast(bw->RawStmt()); + clang::Expr::EvalResult eval_result; + unsigned bit_width = 0; + if (raw_bw && raw_bw->EvaluateAsInt(eval_result, ctx_)) { + bit_width = static_cast( + eval_result.Val.getInt().getZExtValue()); + } + if (bit_width > 0) { + // MEMORY(BIT_WRITE): op[0]=addr, op[1]=value. + // bit_offset and bit_width stored in int pool (not as operands). + uint32_t val_idx = EmitRValue(inits[init_idx]); + + InstructionIR bw_inst; + bw_inst.opcode = mx::ir::OpCode::MEMORY; + bw_inst.mem_op = static_cast( + ctx_.getTargetInfo().isBigEndian() + ? mx::ir::MemOp::BIT_WRITE_BE + : mx::ir::MemOp::BIT_WRITE_LE); + bw_inst.source_entity_id = source_eid; + bw_inst.bit_offset = static_cast(*offset_bits); + bw_inst.bit_width = bit_width; + bw_inst.operand_indices = {dest_addr_idx, val_idx}; + EmitTopLevel(std::move(bw_inst)); + } + } + ++init_idx; + continue; + } + + auto offset_bits = field.OffsetInBits(); + if (!offset_bits) continue; + uint32_t byte_offset = static_cast(*offset_bits / 8); + + InstructionIR gep; + gep.opcode = SizedPtrOp(mx::ir::OpCode::GEP_FIELD_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + gep.source_entity_id = source_eid; + gep.operand_indices = {dest_addr_idx}; + gep.target_entity_id = EntityIdOf(field); + gep.size_bytes = byte_offset; + gep.type_entity_id = TypeEntityIdOf(field.Type()); + uint32_t field_addr = EmitInstruction(std::move(gep)); + + EmitInitializer(field_addr, inits[init_idx], source_eid); + ++init_idx; + } + return; + } + + // Single-element init list for scalars: { expr }. + if (inits.size() == 1) { + EmitInitializer(dest_addr_idx, inits[0], source_eid); + return; + } + } + +scalar_fallback: + // Emit the value and store/copy it into the destination. + { + unsigned sz = 8; + if (auto t = init.Type()) { + if (auto s = TypeSizeBytes(*t)) sz = *s; + } + // For string literal initializers, Clang widens the type to match the + // destination (e.g., "hello" has type char[32] for `char x[32] = "hello"`). + // Use the actual string byte length (including null terminator) to avoid + // reading past the literal's storage. + // String literals always use MEMCPY — EmitRValue returns a pointer + // (the string literal ALLOCA), not a scalar value. + bool is_string_literal = pasta::StringLiteral::From(init).has_value(); + if (is_string_literal) { + auto sl = pasta::StringLiteral::From(init); + unsigned str_sz = sl->ByteLength() + sl->CharacterByteWidth(); + if (str_sz > 0 && str_sz < sz) sz = str_sz; + } + + // Use MEMCPY for string literals, non-scalar sizes, and aggregate types. + bool is_aggregate = false; + if (auto t = init.Type()) { + is_aggregate = t->IsRecordType() || t->IsArrayType(); + } + bool use_memcpy = is_string_literal || is_aggregate || !IsScalarSize(sz); + + // For MEMCPY, get the source address. For scalar STORE, get the value. + uint32_t val_idx = use_memcpy ? EmitLValue(init) : EmitRValue(init); + InstructionIR store; + store.opcode = mx::ir::OpCode::MEMORY; + store.source_entity_id = source_eid; + + if (use_memcpy) { + // Non-scalar size (e.g., string literal char[6]): MEMCPY. + // val_idx is a pointer for non-scalar types. + uint32_t size_idx = EmitSizeConst(sz); + store.operand_indices = {dest_addr_idx, val_idx, size_idx}; + store.mem_op = static_cast(mx::ir::MemOp::MEMCPY); + } else { + store.operand_indices = {dest_addr_idx, val_idx}; + bool is_float = false; + if (auto t = init.Type()) is_float = t->IsFloatingType(); + store.mem_op = static_cast( + DetermineMemOp(true, false, sz, is_float)); + } + EmitTopLevel(std::move(store)); + } +} + +// --------------------------------------------------------------------------- +// Expression emission (nested instruction trees) +// --------------------------------------------------------------------------- + +uint32_t IRGenerator::EmitRValue(const pasta::Expr &e) { + auto eid = EntityIdOf(e); + + // Helper: emit instruction with result type from expression e. + auto expr_type = e.Type(); + auto emit_typed = [&](InstructionIR inst) -> uint32_t { + if (expr_type && inst.type_entity_id == kInvalidEntityId) { + inst.type_entity_id = TypeEntityIdOf(*expr_type); + } + return EmitInstruction(std::move(inst)); + }; + + // Integer literal -- use Clang's evaluated value. + if (auto il = pasta::IntegerLiteral::From(e)) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.source_entity_id = eid; + auto *raw = reinterpret_cast(il->RawStmt()); + if (raw) { + auto val = raw->getValue(); + inst.int_value = val.getSExtValue(); + inst.uint_value = val.getZExtValue(); + inst.width = static_cast(val.getBitWidth()); + bool is_signed = raw->getType()->isSignedIntegerOrEnumerationType(); + inst.const_op = static_cast(IntConstOp(inst.width, is_signed)); + { + auto ty = e.Type(); + if (ty) inst.type_entity_id = TypeEntityIdOf(*ty); + } + } + return emit_typed(std::move(inst)); + } + + // Floating literal -- use Clang's evaluated value. + if (auto fl = pasta::FloatingLiteral::From(e)) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.source_entity_id = eid; + auto *raw = reinterpret_cast(fl->RawStmt()); + if (raw) { + bool losesInfo = false; + llvm::APFloat val = raw->getValue(); + val.convert(llvm::APFloat::IEEEdouble(), + llvm::APFloat::rmNearestTiesToEven, &losesInfo); + inst.float_value = val.convertToDouble(); + inst.width = static_cast( + ctx_.getTypeSize(raw->getType())); + inst.const_op = static_cast(FloatConstOp(inst.width)); + } + return emit_typed(std::move(inst)); + } + + // Character literal -- use Clang's value. + if (auto cl = pasta::CharacterLiteral::From(e)) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.source_entity_id = eid; + auto *raw = reinterpret_cast(cl->RawStmt()); + if (raw) { + unsigned val = raw->getValue(); + // Determine char width from Clang's CharacterKind. + switch (raw->getKind()) { + case clang::CharacterLiteralKind::Wide: + inst.width = static_cast(ctx_.getTargetInfo().getWCharWidth()); + inst.const_op = static_cast( + inst.width <= 16 ? mx::ir::ConstOp::WCHAR16 : mx::ir::ConstOp::WCHAR32); + break; + case clang::CharacterLiteralKind::UTF16: + inst.width = 16; + inst.const_op = static_cast(mx::ir::ConstOp::WCHAR16); + break; + case clang::CharacterLiteralKind::UTF32: + inst.width = 32; + inst.const_op = static_cast(mx::ir::ConstOp::WCHAR32); + break; + default: + inst.width = 8; + inst.const_op = static_cast(mx::ir::ConstOp::UINT8); + break; + } + // Set both signed and unsigned representations using APInt + // for correct sign/zero extension from the character width. + llvm::APInt ap(inst.width, static_cast(val)); + inst.int_value = ap.getSExtValue(); + inst.uint_value = ap.getZExtValue(); + } else { + inst.width = 8; + inst.const_op = static_cast(mx::ir::ConstOp::UINT8); + } + return emit_typed(std::move(inst)); + } + + // String literal → STRING_PTR. + // Produces a pointer to the string's data. The interpreter is responsible + // for giving the string literal a concrete address and populating it from + // StringLiteral::bytes() (via source_entity_id). + if (pasta::StringLiteral::From(e)) { + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::STRING_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + inst.source_entity_id = eid; + if (auto t = e.Type()) inst.type_entity_id = TypeEntityIdOf(*t); + return emit_typed(std::move(inst)); + } + + // Paren expr -- unwrap. + if (auto pe = pasta::ParenExpr::From(e)) { + return EmitRValue(pe->SubExpression()); + } + + // ExprWithCleanups, FullExpr -- unwrap. + if (auto ewc = pasta::ExprWithCleanups::From(e)) { + return EmitRValue(ewc->SubExpression()); + } + + // Lvalue expressions -- load from their address. + if (pasta::DeclRefExpr::From(e) || + pasta::MemberExpr::From(e) || + pasta::ArraySubscriptExpr::From(e)) { + return EmitLoadFromLValue(e); + } + + // Implicit cast. + if (auto ice = pasta::ImplicitCastExpr::From(e)) { + auto ck = ice->CastKind(); + auto sub = ice->SubExpression(); + auto maybe_type = e.Type(); + + if (ck == pasta::CastKind::kLValueToRValue) { + // Bit-field read: emit BIT_READ instead of normal LOAD. + if (auto me = pasta::MemberExpr::From(sub)) { + auto member = me->MemberDeclaration(); + if (auto fd = pasta::FieldDecl::From(member)) { + if (fd->IsBitField()) { + uint32_t base_idx; + if (me->IsArrow()) { + base_idx = EmitRValue(me->Base()); + } else { + base_idx = EmitLValue(me->Base()); + } + + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + if (maybe_type) { + inst.type_entity_id = TypeEntityIdOf(*maybe_type); + } + inst.operand_indices = {base_idx}; + inst.target_entity_id = EntityIdOf(member); + + if (auto bits = fd->OffsetInBits()) { + inst.bit_offset = static_cast(*bits); + } + if (auto bw = fd->BitWidth()) { + auto *raw_bw = reinterpret_cast( + bw->RawStmt()); + if (raw_bw) { + clang::Expr::EvalResult result; + if (raw_bw->EvaluateAsInt(result, ctx_)) { + inst.bit_width = static_cast( + result.Val.getInt().getZExtValue()); + } + } + } + + bool big_endian = ctx_.getTargetInfo().isBigEndian(); + inst.mem_op = static_cast( + big_endian ? mx::ir::MemOp::BIT_READ_BE + : mx::ir::MemOp::BIT_READ_LE); + return emit_typed(std::move(inst)); + } + } + } + + uint32_t addr_idx = EmitLValue(sub); + + // For large objects, LValueToRValue returns the address — + // the "value" is the pointer to the object. + if (maybe_type) { + if (auto sz = TypeSizeBytes(*maybe_type)) { + if (!IsScalarSize(*sz)) { + return addr_idx; + } + } + } + + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + if (maybe_type) { + inst.type_entity_id = TypeEntityIdOf(*maybe_type); + unsigned sz = 8; + if (auto s = TypeSizeBytes(*maybe_type)) sz = *s; + bool is_atomic = maybe_type->IsAtomicType(); + bool is_float = maybe_type->IsFloatingType(); + inst.mem_op = static_cast( + DetermineMemOp(false, is_atomic, sz, is_float)); + } else { + inst.mem_op = static_cast( + DetermineMemOp(false, false, 8)); + } + inst.operand_indices = {addr_idx}; + return emit_typed(std::move(inst)); + } + if (ck == pasta::CastKind::kArrayToPointerDecay) { + // Array decays to pointer: the address of the array IS the pointer. + return EmitLValue(sub); + } + if (ck == pasta::CastKind::kNoOperation) { + return EmitRValue(sub); + } + if (ck == pasta::CastKind::kFunctionToPointerDecay) { + return EmitLValue(sub); + } + if (ck == pasta::CastKind::kNullToPointer) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(mx::ir::ConstOp::NULL_PTR); + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); + } + if (ck == pasta::CastKind::kIntegralToBoolean) { + uint32_t sub_idx = EmitRValue(sub); + unsigned sz = 8; + uint8_t zero_width = 64; + bool zero_signed = true; + if (auto st = sub.Type()) { + if (auto s = TypeSizeBytes(*st)) { + sz = *s; + zero_width = static_cast(*s * 8); + } + zero_signed = st->IsSignedIntegerType(); + } + InstructionIR zero; + zero.opcode = mx::ir::OpCode::CONST; + zero.const_op = static_cast(IntConstOp(zero_width, zero_signed)); + zero.int_value = 0; zero.width = zero_width; + uint32_t zero_idx = EmitInstruction(std::move(zero)); + InstructionIR inst; + inst.opcode = SizedIntOp(IntOp::CMP_NE, sz); + inst.source_entity_id = eid; + inst.operand_indices = {sub_idx, zero_idx}; + return emit_typed(std::move(inst)); + } + + // Map cast kinds to unified CAST opcode with CastOp sub-opcode. + { + // Determine source/dest type info for CastOp selection. + auto sub_type = sub.Type(); + unsigned src_bits = 64, dst_bits = 64; + bool src_signed = true, dst_signed = true; + bool src_float = false, dst_float = false; + if (sub_type) { + auto *raw_sub_type = reinterpret_cast(sub.RawStmt()); + if (raw_sub_type) { + src_bits = static_cast(ctx_.getTypeSize(raw_sub_type->getType())); + src_signed = raw_sub_type->getType()->isSignedIntegerOrEnumerationType(); + src_float = raw_sub_type->getType()->isFloatingType(); + } + } + if (maybe_type) { + auto *raw_e = reinterpret_cast(e.RawStmt()); + if (raw_e) { + dst_bits = static_cast(ctx_.getTypeSize(raw_e->getType())); + dst_signed = raw_e->getType()->isSignedIntegerOrEnumerationType(); + dst_float = raw_e->getType()->isFloatingType(); + } + } + + auto cast_sub = DetermineCastOp(ck, src_bits, dst_bits, + src_signed, dst_signed, src_float, dst_float); + uint32_t sub_idx = EmitRValue(sub); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CAST; + inst.cast_op = static_cast(cast_sub); + inst.source_entity_id = eid; + if (maybe_type) inst.type_entity_id = TypeEntityIdOf(*maybe_type); + inst.operand_indices = {sub_idx}; + return emit_typed(std::move(inst)); + } + } + + // Explicit cast -- use same CastKind dispatch as implicit casts. + if (auto ece = pasta::ExplicitCastExpr::From(e)) { + auto ck = ece->CastKind(); + if (ck == pasta::CastKind::kNoOperation) { + return EmitRValue(ece->SubExpression()); + } + if (ck == pasta::CastKind::kLValueToRValue) { + return EmitLoadFromLValue(ece->SubExpression()); + } + { + auto sub_expr = ece->SubExpression(); + unsigned src_bits = 64, dst_bits = 64; + bool src_signed = true, dst_signed = true; + bool src_float = false, dst_float = false; + auto *raw_sub = reinterpret_cast(sub_expr.RawStmt()); + if (raw_sub) { + src_bits = static_cast(ctx_.getTypeSize(raw_sub->getType())); + src_signed = raw_sub->getType()->isSignedIntegerOrEnumerationType(); + src_float = raw_sub->getType()->isFloatingType(); + } + auto *raw_e = reinterpret_cast(e.RawStmt()); + if (raw_e) { + dst_bits = static_cast(ctx_.getTypeSize(raw_e->getType())); + dst_signed = raw_e->getType()->isSignedIntegerOrEnumerationType(); + dst_float = raw_e->getType()->isFloatingType(); + } + auto cast_sub = DetermineCastOp(ck, src_bits, dst_bits, + src_signed, dst_signed, src_float, dst_float); + uint32_t sub_idx = EmitRValue(sub_expr); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CAST; + inst.cast_op = static_cast(cast_sub); + inst.source_entity_id = eid; + if (auto t = e.Type()) inst.type_entity_id = TypeEntityIdOf(*t); + inst.operand_indices = {sub_idx}; + return emit_typed(std::move(inst)); + } + } + + // Other CastExpr -- pass through. + if (auto ce = pasta::CastExpr::From(e)) { + return EmitRValue(ce->SubExpression()); + } + + // Unary operator. + if (auto uo = pasta::UnaryOperator::From(e)) { + { + auto oc = uo->Opcode(); + auto sub = uo->SubExpression(); + + if (oc == pasta::UnaryOperatorKind::kAddressOf) return EmitLValue(sub); + if (oc == pasta::UnaryOperatorKind::kDeref) { + uint32_t ptr_idx = EmitRValue(sub); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + if (auto t__ = e.Type()) { + inst.type_entity_id = TypeEntityIdOf(*t__); + unsigned sz = 8; + if (auto s = TypeSizeBytes(*t__)) sz = *s; + bool deref_is_float = t__->IsFloatingType(); + inst.mem_op = static_cast( + DetermineMemOp(false, false, sz, deref_is_float)); + } else { + inst.mem_op = static_cast( + DetermineMemOp(false, false, 8)); + } + inst.operand_indices = {ptr_idx}; + return emit_typed(std::move(inst)); + } + if (oc == pasta::UnaryOperatorKind::kPreIncrement || + oc == pasta::UnaryOperatorKind::kPreDecrement || + oc == pasta::UnaryOperatorKind::kPostIncrement || + oc == pasta::UnaryOperatorKind::kPostDecrement) { + uint32_t addr_idx = EmitLValue(sub); + bool is_inc = (oc == pasta::UnaryOperatorKind::kPreIncrement || + oc == pasta::UnaryOperatorKind::kPostIncrement); + bool is_pre = (oc == pasta::UnaryOperatorKind::kPreIncrement || + oc == pasta::UnaryOperatorKind::kPreDecrement); + + // Determine underlying op and element size for pointers. + auto sub_type = sub.Type(); + bool is_ptr = sub_type && sub_type->IsAnyPointerType(); + // For integer inc/dec: sized ADD/SUB. For pointer: sized PTR_ADD. + bool inc_is_ptr_op = false; + IntOp inc_int_group = is_inc ? IntOp::ADD : IntOp::SUB; + uint32_t elem_sz = 0; + // Delta: +1 for integers (ADD/SUB handles direction). + // For pointers: +1 (increment) or -1 (decrement) with PTR_ADD. + int64_t delta = 1; + if (is_ptr) { + inc_is_ptr_op = true; + if (!is_inc) delta = -1; + if (auto pt = sub_type->PointeeType()) { + if (auto sz = TypeSizeBytes(*pt)) elem_sz = *sz; + } + } + + // Emit the delta CONST. For pointers use ptrdiff_t, else the operand type. + uint8_t delta_width = 32; + mx::RawEntityId delta_type_eid = mx::kInvalidEntityId; + if (is_ptr) { + delta_width = ptrdiff_type_width_; + delta_type_eid = ptrdiff_type_eid_; + } else if (sub_type) { + if (auto sz = TypeSizeBytes(*sub_type)) { + delta_width = static_cast(*sz * 8); + } + delta_type_eid = TypeEntityIdOf(*sub_type); + } + bool inc_is_float = !is_ptr && sub_type && sub_type->IsFloatingType(); + InstructionIR delta_inst; + delta_inst.opcode = mx::ir::OpCode::CONST; + delta_inst.source_entity_id = eid; + delta_inst.type_entity_id = delta_type_eid; + if (inc_is_float) { + delta_inst.const_op = static_cast( + FloatConstOp(delta_width)); + delta_inst.float_value = static_cast(delta); + delta_inst.width = delta_width; + } else { + delta_inst.const_op = static_cast(IntConstOp(delta_width, true)); + delta_inst.int_value = delta; + delta_inst.uint_value = static_cast(delta); + delta_inst.width = delta_width; + } + uint32_t delta_idx = EmitInstruction(std::move(delta_inst)); + + InstructionIR inst; + inst.opcode = mx::ir::OpCode::READ_MODIFY_WRITE; + inst.source_entity_id = eid; + inst.operand_indices = {addr_idx, delta_idx}; + if (inc_is_ptr_op) { + inst.compound_op = SizedPtrOp(mx::ir::OpCode::PTR_ADD_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + } else { + unsigned inc_sz = 8; + if (sub_type) { + if (auto s = TypeSizeBytes(*sub_type)) inc_sz = *s; + } + bool is_float = sub_type && sub_type->IsFloatingType(); + if (is_float) { + bool is_f64 = inc_sz > 4; + inst.compound_op = is_inc + ? (is_f64 ? mx::ir::OpCode::FADD_64 : mx::ir::OpCode::FADD_32) + : (is_f64 ? mx::ir::OpCode::FSUB_64 : mx::ir::OpCode::FSUB_32); + } else { + inst.compound_op = SizedIntOp(inc_int_group, inc_sz); + } + } + inst.size_bytes = elem_sz; + inst.is_big_endian = ctx_.getTargetInfo().isBigEndian(); + // flags bit0 = returns_new_value: pre returns new, post returns old. + inst.flags = is_pre ? 1 : 0; + return emit_typed(std::move(inst)); + } + if (oc == pasta::UnaryOperatorKind::kMinus) { + uint32_t sub_idx = EmitRValue(sub); + InstructionIR inst; + inst.source_entity_id = eid; + inst.operand_indices = {sub_idx}; + if (sub.Type() && sub.Type()->IsFloatingType()) { + bool is_f64 = !TypeSizeBytes(*sub.Type()) || + *TypeSizeBytes(*sub.Type()) > 4; + inst.opcode = is_f64 ? mx::ir::OpCode::FNEG_64 + : mx::ir::OpCode::FNEG_32; + } else { + unsigned sz = 8; + if (sub.Type()) { + if (auto s = TypeSizeBytes(*sub.Type())) sz = *s; + } + inst.opcode = SizedIntOp(IntOp::NEG, sz); + } + return emit_typed(std::move(inst)); + } + if (oc == pasta::UnaryOperatorKind::kPlus) return EmitRValue(sub); + if (oc == pasta::UnaryOperatorKind::kLNot) { + uint32_t sub_idx = EmitRValue(sub); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::LOGICAL_NOT; + inst.source_entity_id = eid; + inst.operand_indices = {sub_idx}; + return emit_typed(std::move(inst)); + } + if (oc == pasta::UnaryOperatorKind::kNot) { + uint32_t sub_idx = EmitRValue(sub); + InstructionIR inst; + unsigned sz = 8; + if (sub.Type()) { + if (auto s = TypeSizeBytes(*sub.Type())) sz = *s; + } + inst.opcode = SizedIntOp(IntOp::BIT_NOT, sz); + inst.source_entity_id = eid; + inst.operand_indices = {sub_idx}; + return emit_typed(std::move(inst)); + } + return EmitRValue(sub); + } + } + + // Binary operator. + if (auto bo = pasta::BinaryOperator::From(e)) { + { + auto oc = bo->Opcode(); + + // Assignment: always MEMCPY when RHS is an lvalue (has an address). + // For computed scalars (arithmetic results), use STORE. + if (oc == pasta::BinaryOperatorKind::kAssign) { + // Bit-field assignment: use BIT_WRITE instead of GEP_FIELD + STORE. + if (auto me = pasta::MemberExpr::From(bo->LHS())) { + auto member = me->MemberDeclaration(); + if (auto fd = pasta::FieldDecl::From(member)) { + if (fd->IsBitField()) { + uint32_t base_idx; + if (me->IsArrow()) { + base_idx = EmitRValue(me->Base()); + } else { + base_idx = EmitLValue(me->Base()); + } + uint32_t val_idx = EmitRValue(bo->RHS()); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + inst.operand_indices = {base_idx, val_idx}; + inst.target_entity_id = EntityIdOf(member); + if (auto bits = fd->OffsetInBits()) { + inst.bit_offset = static_cast(*bits); + } + if (auto bw = fd->BitWidth()) { + auto *raw_bw = reinterpret_cast( + bw->RawStmt()); + if (raw_bw) { + clang::Expr::EvalResult result; + if (raw_bw->EvaluateAsInt(result, ctx_)) { + inst.bit_width = static_cast( + result.Val.getInt().getZExtValue()); + } + } + } + bool big_endian = ctx_.getTargetInfo().isBigEndian(); + inst.mem_op = static_cast( + big_endian ? mx::ir::MemOp::BIT_WRITE_BE + : mx::ir::MemOp::BIT_WRITE_LE); + return emit_typed(std::move(inst)); + } + } + } + + uint32_t addr_idx = EmitLValue(bo->LHS()); + auto rhs = bo->RHS(); + unsigned sz = 8; + if (auto t = rhs.Type()) { + if (auto s = TypeSizeBytes(*t)) sz = *s; + } + + // If RHS is an lvalue or the type is large, use MEMCPY. + bool rhs_is_lvalue = rhs.IsLValue(); + bool is_large = (!IsScalarSize(sz)); + if (rhs_is_lvalue || is_large) { + // Get the address of the RHS. + uint32_t src_idx = rhs_is_lvalue ? EmitLValue(rhs) : EmitRValue(rhs); + uint32_t size_idx = EmitSizeConst(sz); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + inst.operand_indices = {addr_idx, src_idx, size_idx}; + inst.mem_op = static_cast(mx::ir::MemOp::MEMCPY); + return emit_typed(std::move(inst)); + } + + // RHS is a computed scalar value — use STORE. + uint32_t val_idx = EmitRValue(rhs); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + inst.operand_indices = {addr_idx, val_idx}; + auto lhs_type = bo->LHS().Type(); + bool is_atomic = lhs_type && lhs_type->IsAtomicType(); + bool is_float = lhs_type && lhs_type->IsFloatingType(); + inst.mem_op = static_cast( + DetermineMemOp(true, is_atomic, sz, is_float)); + return emit_typed(std::move(inst)); + } + + // Compound assignment -> READ_MODIFY_WRITE. + if (pasta::CompoundAssignOperator::From(e)) { + uint32_t addr_idx = EmitLValue(bo->LHS()); + uint32_t val_idx = EmitRValue(bo->RHS()); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::READ_MODIFY_WRITE; + inst.source_entity_id = eid; + inst.operand_indices = {addr_idx, val_idx}; + + // Check LHS type properties for dispatch. + auto lhs_type = bo->LHS().Type(); + bool lhs_is_ptr = lhs_type && lhs_type->IsAnyPointerType(); + bool lhs_is_atomic = lhs_type && lhs_type->IsAtomicType(); + bool lhs_is_float = lhs_type && lhs_type->IsFloatingType(); + + // Width for sized compound ops. + unsigned rmw_sz = 8; + if (lhs_type) { + if (auto s = TypeSizeBytes(*lhs_type)) rmw_sz = *s; + } + bool is_f64 = rmw_sz > 4; + unsigned ptr_bytes = static_cast( + ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8; + + switch (oc) { + case pasta::BinaryOperatorKind::kAddAssign: + if (lhs_is_ptr) { + inst.compound_op = SizedPtrOp(mx::ir::OpCode::PTR_ADD_32, ptr_bytes); + if (auto pt = lhs_type->PointeeType()) { + if (auto sz = TypeSizeBytes(*pt)) inst.size_bytes = *sz; + } + } else if (lhs_is_float) { + inst.compound_op = is_f64 ? mx::ir::OpCode::FADD_64 : mx::ir::OpCode::FADD_32; + } else { + inst.compound_op = lhs_is_atomic ? SizedAtomicOp(AtomicOp::ATOMIC_ADD, rmw_sz) + : SizedIntOp(IntOp::ADD, rmw_sz); + } + break; + case pasta::BinaryOperatorKind::kSubAssign: + if (lhs_is_ptr) { + InstructionIR neg; + { + unsigned sz = 8; + if (auto rhs_t = bo->RHS().Type()) { + if (auto s = TypeSizeBytes(*rhs_t)) sz = *s; + } + neg.opcode = SizedIntOp(IntOp::NEG, sz); + } + neg.source_entity_id = eid; + neg.operand_indices = {val_idx}; + val_idx = EmitInstruction(std::move(neg)); + inst.operand_indices = {addr_idx, val_idx}; + inst.compound_op = SizedPtrOp(mx::ir::OpCode::PTR_ADD_32, ptr_bytes); + if (auto pt = lhs_type->PointeeType()) { + if (auto sz = TypeSizeBytes(*pt)) inst.size_bytes = *sz; + } + } else if (lhs_is_float) { + inst.compound_op = is_f64 ? mx::ir::OpCode::FSUB_64 : mx::ir::OpCode::FSUB_32; + } else { + inst.compound_op = lhs_is_atomic ? SizedAtomicOp(AtomicOp::ATOMIC_SUB, rmw_sz) + : SizedIntOp(IntOp::SUB, rmw_sz); + } + break; + case pasta::BinaryOperatorKind::kMulAssign: + inst.compound_op = lhs_is_float ? (is_f64 ? mx::ir::OpCode::FMUL_64 : mx::ir::OpCode::FMUL_32) + : SizedIntOp(IntOp::MUL, rmw_sz); + break; + case pasta::BinaryOperatorKind::kDivAssign: + if (lhs_is_float) { + inst.compound_op = is_f64 ? mx::ir::OpCode::FDIV_64 : mx::ir::OpCode::FDIV_32; + } else { + inst.compound_op = SizedIntOp( + (lhs_type && lhs_type->IsUnsignedIntegerType()) ? IntOp::UDIV : IntOp::DIV, rmw_sz); + } + break; + case pasta::BinaryOperatorKind::kRemAssign: + if (lhs_is_float) { + inst.compound_op = is_f64 ? mx::ir::OpCode::FREM_64 : mx::ir::OpCode::FREM_32; + } else { + inst.compound_op = SizedIntOp( + (lhs_type && lhs_type->IsUnsignedIntegerType()) ? IntOp::UREM : IntOp::REM, rmw_sz); + } + break; + case pasta::BinaryOperatorKind::kAndAssign: + inst.compound_op = lhs_is_atomic ? SizedAtomicOp(AtomicOp::ATOMIC_AND, rmw_sz) + : SizedIntOp(IntOp::BIT_AND, rmw_sz); + break; + case pasta::BinaryOperatorKind::kOrAssign: + inst.compound_op = lhs_is_atomic ? SizedAtomicOp(AtomicOp::ATOMIC_OR, rmw_sz) + : SizedIntOp(IntOp::BIT_OR, rmw_sz); + break; + case pasta::BinaryOperatorKind::kXorAssign: + inst.compound_op = lhs_is_atomic ? SizedAtomicOp(AtomicOp::ATOMIC_XOR, rmw_sz) + : SizedIntOp(IntOp::BIT_XOR, rmw_sz); + break; + case pasta::BinaryOperatorKind::kShlAssign: inst.compound_op = SizedIntOp(IntOp::SHL, rmw_sz); break; + case pasta::BinaryOperatorKind::kShrAssign: + inst.compound_op = SizedIntOp( + (lhs_type && lhs_type->IsUnsignedIntegerType()) ? IntOp::USHR : IntOp::SHR, rmw_sz); + break; + default: inst.compound_op = SizedIntOp(IntOp::ADD, rmw_sz); break; + } + // Compound assign always returns the new value. + inst.flags = 1; + inst.is_big_endian = ctx_.getTargetInfo().isBigEndian(); + return emit_typed(std::move(inst)); + } + + // Comma operator: evaluate both sides, return the last value. + if (oc == pasta::BinaryOperatorKind::kComma) { + uint32_t lhs_idx = EmitRValue(bo->LHS()); + uint32_t rhs_idx = EmitRValue(bo->RHS()); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::LAST_VALUE; + inst.source_entity_id = eid; + inst.operand_indices = {lhs_idx, rhs_idx}; + return emit_typed(std::move(inst)); + } + + // Logical AND/OR -- kept as instructions, NOT control flow splits. + // RHS is conditionally executed. + if (oc == pasta::BinaryOperatorKind::kLAnd || + oc == pasta::BinaryOperatorKind::kLOr) { + uint32_t lhs_idx = EmitRValue(bo->LHS()); + uint32_t rhs_idx = EmitRValue(bo->RHS()); + MarkConditionallyExecuted(rhs_idx); + InstructionIR inst; + inst.opcode = (oc == pasta::BinaryOperatorKind::kLAnd) + ? mx::ir::OpCode::LOGICAL_AND + : mx::ir::OpCode::LOGICAL_OR; + inst.source_entity_id = eid; + inst.operand_indices = {lhs_idx, rhs_idx}; + return emit_typed(std::move(inst)); + } + + // Comparison. Use FCMP for floats, UCMP for unsigned/pointer, CMP for signed. + mx::ir::OpCode cmp_op; + bool is_cmp = true; + { + bool is_float = false; + bool is_f64 = false; + bool is_unsigned = false; + if (auto lhs_type = bo->LHS().Type()) { + auto canon = lhs_type->CanonicalType(); + is_float = canon.IsFloatingType(); + if (is_float) { + is_f64 = !TypeSizeBytes(canon) || *TypeSizeBytes(canon) > 4; + } + is_unsigned = canon.IsUnsignedIntegerType() || + canon.IsAnyPointerType(); + } + // Pick the right opcode family: FCMP for float, UCMP for unsigned, CMP for signed. + // Float comparisons are width-specific (32/64). + // Integer comparisons use IntOp + SizedIntOp. + IntOp cmp_group = IntOp::CMP_EQ; // placeholder for non-float + bool cmp_is_float = false; +#define FCMP(base) (is_f64 ? mx::ir::OpCode::base ## _64 : mx::ir::OpCode::base ## _32) + switch (oc) { + case pasta::BinaryOperatorKind::kEQ: + if (is_float) { cmp_op = FCMP(FCMP_EQ); cmp_is_float = true; } + else { cmp_group = IntOp::CMP_EQ; } + break; + case pasta::BinaryOperatorKind::kNE: + if (is_float) { cmp_op = FCMP(FCMP_NE); cmp_is_float = true; } + else { cmp_group = IntOp::CMP_NE; } + break; + case pasta::BinaryOperatorKind::kLT: + if (is_float) { cmp_op = FCMP(FCMP_LT); cmp_is_float = true; } + else { cmp_group = is_unsigned ? IntOp::UCMP_LT : IntOp::CMP_LT; } + break; + case pasta::BinaryOperatorKind::kGT: + if (is_float) { cmp_op = FCMP(FCMP_GT); cmp_is_float = true; } + else { cmp_group = is_unsigned ? IntOp::UCMP_GT : IntOp::CMP_GT; } + break; + case pasta::BinaryOperatorKind::kLE: + if (is_float) { cmp_op = FCMP(FCMP_LE); cmp_is_float = true; } + else { cmp_group = is_unsigned ? IntOp::UCMP_LE : IntOp::CMP_LE; } + break; + case pasta::BinaryOperatorKind::kGE: + if (is_float) { cmp_op = FCMP(FCMP_GE); cmp_is_float = true; } + else { cmp_group = is_unsigned ? IntOp::UCMP_GE : IntOp::CMP_GE; } + break; +#undef FCMP + default: is_cmp = false; break; + } + // Apply width suffix for integer comparisons. + if (!cmp_is_float && is_cmp) { + unsigned sz = 8; // default 64-bit + if (auto lhs_type = bo->LHS().Type()) { + auto canon = lhs_type->CanonicalType(); + if (auto s = TypeSizeBytes(canon)) sz = *s; + } + cmp_op = SizedIntOp(cmp_group, sz); + } + } + if (is_cmp) { + uint32_t lhs_idx = EmitRValue(bo->LHS()); + uint32_t rhs_idx = EmitRValue(bo->RHS()); + InstructionIR inst; + inst.opcode = cmp_op; + inst.source_entity_id = eid; + inst.operand_indices = {lhs_idx, rhs_idx}; + return emit_typed(std::move(inst)); + } + + // Arithmetic / logic. + IntOp arith_group = IntOp::ADD; + mx::ir::OpCode arith_op{}; + bool is_float_op = false; + switch (oc) { + case pasta::BinaryOperatorKind::kAdd: arith_group = IntOp::ADD; break; + case pasta::BinaryOperatorKind::kSub: arith_group = IntOp::SUB; break; + case pasta::BinaryOperatorKind::kMul: arith_group = IntOp::MUL; break; + case pasta::BinaryOperatorKind::kDiv: arith_group = IntOp::DIV; break; + case pasta::BinaryOperatorKind::kRem: arith_group = IntOp::REM; break; + case pasta::BinaryOperatorKind::kAnd: arith_group = IntOp::BIT_AND; break; + case pasta::BinaryOperatorKind::kOr: arith_group = IntOp::BIT_OR; break; + case pasta::BinaryOperatorKind::kXor: arith_group = IntOp::BIT_XOR; break; + case pasta::BinaryOperatorKind::kShl: arith_group = IntOp::SHL; break; + case pasta::BinaryOperatorKind::kShr: arith_group = IntOp::SHR; break; + default: break; + } + + // Use float opcodes for float operands, unsigned for unsigned. + { + auto op_type = e.Type(); + bool is_float = op_type && op_type->IsFloatingType(); + bool is_unsigned = op_type && op_type->IsUnsignedIntegerType(); + if (is_float) { + is_float_op = true; + bool is_f64 = !op_type || !TypeSizeBytes(*op_type) || + *TypeSizeBytes(*op_type) > 4; + if (arith_group == IntOp::ADD) + arith_op = is_f64 ? mx::ir::OpCode::FADD_64 : mx::ir::OpCode::FADD_32; + else if (arith_group == IntOp::SUB) + arith_op = is_f64 ? mx::ir::OpCode::FSUB_64 : mx::ir::OpCode::FSUB_32; + else if (arith_group == IntOp::MUL) + arith_op = is_f64 ? mx::ir::OpCode::FMUL_64 : mx::ir::OpCode::FMUL_32; + else if (arith_group == IntOp::DIV) + arith_op = is_f64 ? mx::ir::OpCode::FDIV_64 : mx::ir::OpCode::FDIV_32; + else if (arith_group == IntOp::REM) + arith_op = is_f64 ? mx::ir::OpCode::FREM_64 : mx::ir::OpCode::FREM_32; + } else if (is_unsigned) { + if (arith_group == IntOp::DIV) arith_group = IntOp::UDIV; + else if (arith_group == IntOp::REM) arith_group = IntOp::UREM; + else if (arith_group == IntOp::SHR) arith_group = IntOp::USHR; + } + } + + // Check for pointer arithmetic. + auto lhs_type = bo->LHS().Type(); + auto rhs_type = bo->RHS().Type(); + bool lhs_ptr = lhs_type && pasta::PointerType::From(*lhs_type); + bool rhs_ptr = rhs_type && pasta::PointerType::From(*rhs_type); + unsigned ptr_bytes = static_cast( + ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8; + + if (arith_group == IntOp::ADD && (lhs_ptr || rhs_ptr)) { + auto base_expr = lhs_ptr ? bo->LHS() : bo->RHS(); + auto idx_expr = lhs_ptr ? bo->RHS() : bo->LHS(); + auto &ptr_type = lhs_ptr ? lhs_type : rhs_type; + uint32_t base_idx = EmitRValue(base_expr); + uint32_t idx_idx = EmitRValue(idx_expr); + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::PTR_ADD_32, ptr_bytes); + inst.source_entity_id = eid; + inst.operand_indices = {base_idx, idx_idx}; + if (auto pt = pasta::PointerType::From(*ptr_type)) { + auto pointee = pt->PointeeType(); + inst.type_entity_id = TypeEntityIdOf(pointee); + if (auto sz = TypeSizeBytes(pointee)) inst.size_bytes = *sz; + } + return emit_typed(std::move(inst)); + } + + if (arith_group == IntOp::SUB && lhs_ptr && rhs_ptr) { + // ptr - ptr -> PTR_DIFF (result in elements, not bytes) + uint32_t lhs_idx = EmitRValue(bo->LHS()); + uint32_t rhs_idx = EmitRValue(bo->RHS()); + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::PTR_DIFF_32, ptr_bytes); + inst.source_entity_id = eid; + inst.operand_indices = {lhs_idx, rhs_idx}; + // Element size needed to convert byte difference to element count. + if (auto pt = pasta::PointerType::From(*lhs_type)) { + auto pointee = pt->PointeeType(); + if (auto sz = TypeSizeBytes(pointee)) inst.size_bytes = *sz; + } + return emit_typed(std::move(inst)); + } + + if (arith_group == IntOp::SUB && lhs_ptr) { + uint32_t base_idx = EmitRValue(bo->LHS()); + uint32_t idx_idx = EmitRValue(bo->RHS()); + InstructionIR neg; + { + unsigned sz = 8; + if (auto rhs_t = bo->RHS().Type()) { + if (auto s = TypeSizeBytes(*rhs_t)) sz = *s; + } + neg.opcode = SizedIntOp(IntOp::NEG, sz); + } + neg.operand_indices = {idx_idx}; + uint32_t neg_idx = EmitInstruction(std::move(neg)); + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::PTR_ADD_32, ptr_bytes); + inst.source_entity_id = eid; + inst.operand_indices = {base_idx, neg_idx}; + if (auto pt = pasta::PointerType::From(*lhs_type)) { + auto pointee = pt->PointeeType(); + inst.type_entity_id = TypeEntityIdOf(pointee); + if (auto sz = TypeSizeBytes(pointee)) inst.size_bytes = *sz; + } + return emit_typed(std::move(inst)); + } + + // Apply width suffix for integer/unsigned arithmetic. + if (!is_float_op) { + auto op_type = e.Type(); + unsigned sz = 8; + if (op_type) { + if (auto s = TypeSizeBytes(*op_type)) sz = *s; + } + arith_op = SizedIntOp(arith_group, sz); + } + + uint32_t lhs_idx = EmitRValue(bo->LHS()); + uint32_t rhs_idx = EmitRValue(bo->RHS()); + InstructionIR inst; + inst.opcode = arith_op; + inst.source_entity_id = eid; + inst.operand_indices = {lhs_idx, rhs_idx}; + return emit_typed(std::move(inst)); + } + } + + + // Call expression (including member calls). + if (auto ce = pasta::CallExpr::From(e)) { + auto direct_callee = ce->DirectCallee(); + + // Handle va_start/va_end/va_copy builtins. + if (direct_callee) { + auto callee_name = direct_callee->Name(); + auto args = ce->Arguments(); + + if (callee_name == "__builtin_va_start" || callee_name == "va_start") { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::VA_START; + inst.source_entity_id = eid; + if (!args.empty()) inst.operand_indices.push_back(EmitRValue(args[0])); + return emit_typed(std::move(inst)); + } + if (callee_name == "__builtin_va_end" || callee_name == "va_end") { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::VA_END; + inst.source_entity_id = eid; + if (!args.empty()) inst.operand_indices.push_back(EmitRValue(args[0])); + return emit_typed(std::move(inst)); + } + if (callee_name == "__builtin_va_copy" || callee_name == "va_copy") { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::VA_COPY; + inst.source_entity_id = eid; + if (args.size() >= 2) { + inst.operand_indices.push_back(EmitRValue(args[0])); + inst.operand_indices.push_back(EmitRValue(args[1])); + } + return emit_typed(std::move(inst)); + } + + // Recognize memory/string operations and lower to MEMORY. + { + using MO = mx::ir::MemOp; + struct MemBuiltin { + const char *name; + MO op; + unsigned min_args; + }; + static const MemBuiltin mem_builtins[] = { + {"memset", MO::MEMSET, 3}, + {"__builtin_memset", MO::MEMSET, 3}, + {"__builtin_memset_chk", MO::MEMSET, 3}, + {"__builtin___memset_chk", MO::MEMSET, 3}, + {"memcpy", MO::MEMCPY, 3}, + {"__builtin_memcpy", MO::MEMCPY, 3}, + {"__builtin_memcpy_chk", MO::MEMCPY, 3}, + {"__builtin___memcpy_chk", MO::MEMCPY, 3}, + {"memmove", MO::MEMMOVE, 3}, + {"__builtin_memmove", MO::MEMMOVE, 3}, + {"__builtin_memmove_chk", MO::MEMMOVE, 3}, + {"__builtin___memmove_chk", MO::MEMMOVE, 3}, + {"memcmp", MO::MEMCMP, 3}, + {"__builtin_memcmp", MO::MEMCMP, 3}, + {"memchr", MO::MEMCHR, 3}, + {"__builtin_memchr", MO::MEMCHR, 3}, + {"bzero", MO::BZERO, 2}, + {"__builtin_bzero", MO::BZERO, 2}, + {"strlen", MO::STRLEN, 1}, + {"__builtin_strlen", MO::STRLEN, 1}, + {"strnlen", MO::STRNLEN, 2}, + {"__builtin_strnlen", MO::STRNLEN, 2}, + {"strcmp", MO::STRCMP, 2}, + {"__builtin_strcmp", MO::STRCMP, 2}, + {"strncmp", MO::STRNCMP, 3}, + {"__builtin_strncmp", MO::STRNCMP, 3}, + {"strchr", MO::STRCHR, 2}, + {"__builtin_strchr", MO::STRCHR, 2}, + {"strrchr", MO::STRRCHR, 2}, + {"__builtin_strrchr", MO::STRRCHR, 2}, + {"strstr", MO::STRSTR, 2}, + {"__builtin_strstr", MO::STRSTR, 2}, + {"strcpy", MO::STRCPY, 2}, + {"__builtin_strcpy", MO::STRCPY, 2}, + {"__builtin___strcpy_chk", MO::STRCPY, 2}, + {"strncpy", MO::STRNCPY, 3}, + {"__builtin_strncpy", MO::STRNCPY, 3}, + {"__builtin___strncpy_chk", MO::STRNCPY, 3}, + {"strcat", MO::STRCAT, 2}, + {"__builtin_strcat", MO::STRCAT, 2}, + {"__builtin___strcat_chk", MO::STRCAT, 2}, + {"strncat", MO::STRNCAT, 3}, + {"__builtin_strncat", MO::STRNCAT, 3}, + {"__builtin___strncat_chk", MO::STRNCAT, 3}, + {"stpcpy", MO::STPCPY, 2}, + {"__builtin_stpcpy", MO::STPCPY, 2}, + {"stpncpy", MO::STPNCPY, 3}, + {"__builtin_stpncpy", MO::STPNCPY, 3}, + // String-to-number (fixed size). + {"atoi", MO::STRTOI32, 1}, // int is always 32-bit + {"atoll", MO::STRTOI64, 1}, + {"atof", MO::STRTOF64, 1}, + {"strtoll", MO::STRTOI64, 3}, + {"strtoull", MO::STRTOU64, 3}, + {"strtod", MO::STRTOF64, 2}, + {"strtof", MO::STRTOF32, 2}, + // _chk variants map to the base operation (extra dest_size arg ignored). + {"__memcpy_chk", MO::MEMCPY, 3}, + {"__memset_chk", MO::MEMSET, 3}, + {"__memmove_chk", MO::MEMMOVE, 3}, + {"__strcpy_chk", MO::STRCPY, 2}, + {"__strncpy_chk", MO::STRNCPY, 3}, + {"__strcat_chk", MO::STRCAT, 2}, + {"__strncat_chk", MO::STRNCAT, 3}, + }; + for (const auto &mb : mem_builtins) { + if (callee_name == mb.name && args.size() >= mb.min_args) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.mem_op = static_cast(mb.op); + inst.source_entity_id = eid; + for (unsigned i = 0; i < mb.min_args; ++i) { + inst.operand_indices.push_back(EmitRValue(args[i])); + } + return emit_typed(std::move(inst)); + } + } + } + + // Size-dependent string-to-number: atol/strtol/strtoul depend on + // sizeof(long), which varies by platform. + if (callee_name == "atol" || callee_name == "strtol" || + callee_name == "strtoul") { + using MO = mx::ir::MemOp; + bool is_long64 = (ctx_.getTargetInfo().getLongWidth() == 64); + MO op; + unsigned min_args; + if (callee_name == "atol") { + op = is_long64 ? MO::STRTOI64 : MO::STRTOI32; + min_args = 1; + } else if (callee_name == "strtol") { + op = is_long64 ? MO::STRTOI64 : MO::STRTOI32; + min_args = 3; + } else { + op = is_long64 ? MO::STRTOU64 : MO::STRTOU32; + min_args = 3; + } + if (args.size() >= min_args) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.mem_op = static_cast(op); + inst.source_entity_id = eid; + for (unsigned i = 0; i < min_args; ++i) { + inst.operand_indices.push_back(EmitRValue(args[i])); + } + return emit_typed(std::move(inst)); + } + } + + // __builtin_unreachable() → handled as noreturn at expression statement + // level (emits UNREACHABLE terminator after the call expression scope). + // Just return UNDEFINED as the expression value. + if (callee_name == "__builtin_unreachable") { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::UNDEFINED; + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); + } + + // __builtin_expect(x, v) / __builtin_expect_with_probability → just x. + if (callee_name == "__builtin_expect" || + callee_name == "__builtin_expect_with_probability") { + if (!args.empty()) return EmitRValue(args[0]); + } + + // __builtin_assume(x) — optimization hint, no runtime effect. + // Emit the operand for side effects, discard. + if (callee_name == "__builtin_assume") { + if (!args.empty()) return EmitRValue(args[0]); + } + + // Overflow-checked arithmetic builtins → + // STORE &result, UNDEFINED + // overflow = RMW(&result, ADD_OVERFLOW, a, b) + if (callee_name == "__builtin_add_overflow" || + callee_name == "__builtin_sub_overflow" || + callee_name == "__builtin_mul_overflow") { + if (args.size() >= 3) { + // Determine width from the result pointer's pointee type. + unsigned overflow_width = 4; + if (auto arg_type = args[2].Type()) { + if (auto pt = arg_type->PointeeType()) { + if (auto sz = TypeSizeBytes(*pt)) overflow_width = *sz; + } + } + mx::ir::OpCode overflow_op = SizedOverflowOp(OverflowOp::ADD_OVERFLOW, overflow_width); + if (callee_name == "__builtin_sub_overflow") + overflow_op = SizedOverflowOp(OverflowOp::SUB_OVERFLOW, overflow_width); + else if (callee_name == "__builtin_mul_overflow") + overflow_op = SizedOverflowOp(OverflowOp::MUL_OVERFLOW, overflow_width); + + uint32_t a_idx = EmitRValue(args[0]); + uint32_t b_idx = EmitRValue(args[1]); + uint32_t dest_idx = EmitRValue(args[2]); + + // Store UNDEFINED to dest to mark it as initialized-but-unknown. + InstructionIR undef; + undef.opcode = mx::ir::OpCode::UNDEFINED; + undef.source_entity_id = eid; + uint32_t undef_idx = EmitInstruction(std::move(undef)); + + InstructionIR store; + store.opcode = mx::ir::OpCode::MEMORY; + store.source_entity_id = eid; + store.operand_indices = {dest_idx, undef_idx}; + store.mem_op = static_cast( + DetermineMemOp(true, false, 8)); + EmitTopLevel(std::move(store)); + + // RMW(&result, overflow_op, a, b) → returns bool (overflow flag). + InstructionIR rmw; + rmw.opcode = mx::ir::OpCode::READ_MODIFY_WRITE; + rmw.source_entity_id = eid; + rmw.compound_op = overflow_op; + rmw.flags = 1; // returns new value (the overflow flag) + rmw.is_big_endian = ctx_.getTargetInfo().isBigEndian(); + rmw.operand_indices = {dest_idx, a_idx, b_idx}; + return emit_typed(std::move(rmw)); + } + } + + // Bitwise/intrinsic builtins → BITWISE with sub-opcode. + { + using BO = mx::ir::BitwiseOp; + struct BitwiseBuiltin { + const char *name; + BO op; + bool undef_for_zero; // CLZ/CTZ are undefined for input == 0 + }; + static const BitwiseBuiltin bitwise_builtins[] = { + {"__builtin_bswap16", BO::BSWAP_16, false}, + {"__builtin_bswap32", BO::BSWAP_32, false}, + {"__builtin_bswap64", BO::BSWAP_64, false}, + {"__builtin_popcount", BO::POPCOUNT, false}, + {"__builtin_popcountl", BO::POPCOUNT, false}, + {"__builtin_popcountll", BO::POPCOUNT, false}, + {"__builtin_clz", BO::CLZ, true}, + {"__builtin_clzl", BO::CLZ, true}, + {"__builtin_clzll", BO::CLZ, true}, + {"__builtin_ctz", BO::CTZ, true}, + {"__builtin_ctzl", BO::CTZ, true}, + {"__builtin_ctzll", BO::CTZ, true}, + {"__builtin_ffs", BO::FFS, false}, + {"__builtin_ffsl", BO::FFS, false}, + {"__builtin_ffsll", BO::FFS, false}, + {"__builtin_parity", BO::PARITY, false}, + {"__builtin_parityl", BO::PARITY, false}, + {"__builtin_parityll", BO::PARITY, false}, + }; + // __builtin_abs → sized ABS opcode (not a BitwiseOp). + if (callee_name == "__builtin_abs" && !args.empty()) { + uint32_t val_idx = EmitRValue(args[0]); + unsigned sz = 8; + if (auto at = args[0].Type()) { + if (auto s = TypeSizeBytes(*at)) sz = *s; + } + InstructionIR inst; + inst.opcode = SizedAbsOp(sz); + inst.source_entity_id = eid; + inst.operand_indices.push_back(val_idx); + return emit_typed(std::move(inst)); + } + for (const auto &bb : bitwise_builtins) { + if (callee_name == bb.name && !args.empty()) { + uint32_t val_idx = EmitRValue(args[0]); + unsigned bw_sz = 8; + if (auto at = args[0].Type()) { + if (auto s = TypeSizeBytes(*at)) bw_sz = *s; + } + InstructionIR bw; + bw.opcode = SizedBitwiseOp(bw_sz); + bw.source_entity_id = eid; + bw.bitwise_op = static_cast(bb.op); + bw.operand_indices.push_back(val_idx); + uint32_t bw_idx = EmitInstruction(std::move(bw)); + + if (bb.undef_for_zero) { + // result = SELECT(val == 0, UNDEFINED, bw_result) + auto at = args[0].Type(); + assert(at && "builtin argument must have a type"); + uint8_t arg_width = 32; + if (at) { + if (auto s = TypeSizeBytes(*at)) arg_width = static_cast(*s * 8); + } + InstructionIR zero; + zero.opcode = mx::ir::OpCode::CONST; + zero.const_op = static_cast(IntConstOp(arg_width, true)); + zero.source_entity_id = eid; + zero.int_value = 0; + zero.uint_value = 0; + zero.width = arg_width; + uint32_t zero_idx = EmitInstruction(std::move(zero)); + + InstructionIR cmp; + cmp.opcode = SizedIntOp(IntOp::CMP_EQ, arg_width / 8); + cmp.source_entity_id = eid; + cmp.operand_indices = {val_idx, zero_idx}; + uint32_t cmp_idx = EmitInstruction(std::move(cmp)); + + InstructionIR undef; + undef.opcode = mx::ir::OpCode::UNDEFINED; + undef.source_entity_id = eid; + uint32_t undef_idx = EmitInstruction(std::move(undef)); + + InstructionIR sel; + sel.opcode = mx::ir::OpCode::SELECT; + sel.source_entity_id = eid; + sel.operand_indices = {cmp_idx, undef_idx, bw_idx}; + return emit_typed(std::move(sel)); + } + + // For defined-for-all-inputs builtins, just return the BITWISE. + // Re-wrap as top-level since we already called EmitInstruction. + auto &bw_ref = func_.instructions[bw_idx]; + if (auto t = e.Type()) bw_ref.type_entity_id = TypeEntityIdOf(*t); + return bw_idx; + } + } + } + + // Float builtins → FLOAT with sub-opcode. + { + using FO = mx::ir::FloatOp; + + // Given the _32 variant of a FloatOp (even index), return the _32 or + // _64 variant based on the byte width of the operand/result type. + auto SizedFloatSubOp = [](FO base_32, unsigned width_bytes) -> FO { + // _32 is even, _64 is odd. + return (width_bytes <= 4) + ? base_32 + : static_cast(static_cast(base_32) + 1); + }; + + struct FloatBuiltin { + const char *name; + FO op_32; // The _32 variant; _64 = op_32 + 1. + unsigned num_args; + }; + static const FloatBuiltin float_builtins[] = { + {"__builtin_isnan", FO::ISNAN_32, 1}, + {"__builtin_isinf", FO::ISINF_32, 1}, + {"__builtin_isfinite", FO::ISFINITE_32, 1}, + {"__builtin_fabs", FO::FABS_32, 1}, + {"__builtin_fabsf", FO::FABS_32, 1}, + {"__builtin_fabsl", FO::FABS_32, 1}, + {"fabs", FO::FABS_32, 1}, + {"fabsf", FO::FABS_32, 1}, + {"fabsl", FO::FABS_32, 1}, + {"__builtin_copysign", FO::COPYSIGN_32, 2}, + {"__builtin_copysignf", FO::COPYSIGN_32, 2}, + {"__builtin_copysignl", FO::COPYSIGN_32, 2}, + {"copysign", FO::COPYSIGN_32, 2}, + {"copysignf", FO::COPYSIGN_32, 2}, + {"__builtin_fmin", FO::FMIN_32, 2}, + {"__builtin_fminf", FO::FMIN_32, 2}, + {"fmin", FO::FMIN_32, 2}, + {"fminf", FO::FMIN_32, 2}, + {"__builtin_fmax", FO::FMAX_32, 2}, + {"__builtin_fmaxf", FO::FMAX_32, 2}, + {"fmax", FO::FMAX_32, 2}, + {"fmaxf", FO::FMAX_32, 2}, + {"__builtin_ceil", FO::CEIL_32, 1}, + {"__builtin_ceilf", FO::CEIL_32, 1}, + {"ceil", FO::CEIL_32, 1}, + {"ceilf", FO::CEIL_32, 1}, + {"__builtin_floor", FO::FLOOR_32, 1}, + {"__builtin_floorf", FO::FLOOR_32, 1}, + {"floor", FO::FLOOR_32, 1}, + {"floorf", FO::FLOOR_32, 1}, + {"__builtin_round", FO::ROUND_32, 1}, + {"__builtin_roundf", FO::ROUND_32, 1}, + {"round", FO::ROUND_32, 1}, + {"roundf", FO::ROUND_32, 1}, + {"__builtin_trunc", FO::TRUNC_32, 1}, + {"__builtin_truncf", FO::TRUNC_32, 1}, + {"trunc", FO::TRUNC_32, 1}, + {"truncf", FO::TRUNC_32, 1}, + {"__builtin_sqrt", FO::SQRT_32, 1}, + {"__builtin_sqrtf", FO::SQRT_32, 1}, + {"sqrt", FO::SQRT_32, 1}, + {"sqrtf", FO::SQRT_32, 1}, + // Trigonometric. + {"sin", FO::SIN_32, 1}, {"sinf", FO::SIN_32, 1}, + {"__builtin_sin", FO::SIN_32, 1}, {"__builtin_sinf", FO::SIN_32, 1}, + {"cos", FO::COS_32, 1}, {"cosf", FO::COS_32, 1}, + {"__builtin_cos", FO::COS_32, 1}, {"__builtin_cosf", FO::COS_32, 1}, + {"tan", FO::TAN_32, 1}, {"tanf", FO::TAN_32, 1}, + {"__builtin_tan", FO::TAN_32, 1}, {"__builtin_tanf", FO::TAN_32, 1}, + {"asin", FO::ASIN_32, 1}, {"asinf", FO::ASIN_32, 1}, + {"__builtin_asin", FO::ASIN_32, 1}, {"__builtin_asinf", FO::ASIN_32, 1}, + {"acos", FO::ACOS_32, 1}, {"acosf", FO::ACOS_32, 1}, + {"__builtin_acos", FO::ACOS_32, 1}, {"__builtin_acosf", FO::ACOS_32, 1}, + {"atan", FO::ATAN_32, 1}, {"atanf", FO::ATAN_32, 1}, + {"__builtin_atan", FO::ATAN_32, 1}, {"__builtin_atanf", FO::ATAN_32, 1}, + {"atan2", FO::ATAN2_32, 2}, {"atan2f", FO::ATAN2_32, 2}, + {"__builtin_atan2", FO::ATAN2_32, 2}, {"__builtin_atan2f", FO::ATAN2_32, 2}, + // Exponential/logarithmic. + {"exp", FO::EXP_32, 1}, {"expf", FO::EXP_32, 1}, + {"__builtin_exp", FO::EXP_32, 1}, {"__builtin_expf", FO::EXP_32, 1}, + {"exp2", FO::EXP2_32, 1}, {"exp2f", FO::EXP2_32, 1}, + {"__builtin_exp2", FO::EXP2_32, 1}, {"__builtin_exp2f", FO::EXP2_32, 1}, + {"log", FO::LOG_32, 1}, {"logf", FO::LOG_32, 1}, + {"__builtin_log", FO::LOG_32, 1}, {"__builtin_logf", FO::LOG_32, 1}, + {"log2", FO::LOG2_32, 1}, {"log2f", FO::LOG2_32, 1}, + {"__builtin_log2", FO::LOG2_32, 1}, {"__builtin_log2f", FO::LOG2_32, 1}, + {"log10", FO::LOG10_32, 1}, {"log10f", FO::LOG10_32, 1}, + {"__builtin_log10", FO::LOG10_32, 1}, {"__builtin_log10f", FO::LOG10_32, 1}, + // Power/modular. + {"pow", FO::POW_32, 2}, {"powf", FO::POW_32, 2}, + {"__builtin_pow", FO::POW_32, 2}, {"__builtin_powf", FO::POW_32, 2}, + {"fmod", FO::FMOD_32, 2}, {"fmodf", FO::FMOD_32, 2}, + {"__builtin_fmod", FO::FMOD_32, 2}, {"__builtin_fmodf", FO::FMOD_32, 2}, + {"remainder", FO::REMAINDER_32, 2}, {"remainderf", FO::REMAINDER_32, 2}, + {"__builtin_remainder", FO::REMAINDER_32, 2}, + {"fma", FO::FMA_32, 3}, {"fmaf", FO::FMA_32, 3}, + {"__builtin_fma", FO::FMA_32, 3}, {"__builtin_fmaf", FO::FMA_32, 3}, + // Hyperbolic. + {"sinh", FO::SINH_32, 1}, {"sinhf", FO::SINH_32, 1}, + {"__builtin_sinh", FO::SINH_32, 1}, + {"cosh", FO::COSH_32, 1}, {"coshf", FO::COSH_32, 1}, + {"__builtin_cosh", FO::COSH_32, 1}, + {"tanh", FO::TANH_32, 1}, {"tanhf", FO::TANH_32, 1}, + {"__builtin_tanh", FO::TANH_32, 1}, + // Other. + {"hypot", FO::HYPOT_32, 2}, {"hypotf", FO::HYPOT_32, 2}, + {"__builtin_hypot", FO::HYPOT_32, 2}, + {"erf", FO::ERF_32, 1}, {"erff", FO::ERF_32, 1}, + {"__builtin_erf", FO::ERF_32, 1}, + {"erfc", FO::ERFC_32, 1}, {"erfcf", FO::ERFC_32, 1}, + {"__builtin_erfc", FO::ERFC_32, 1}, + {"tgamma", FO::TGAMMA_32, 1}, {"tgammaf", FO::TGAMMA_32, 1}, + {"__builtin_tgamma", FO::TGAMMA_32, 1}, + {"lgamma", FO::LGAMMA_32, 1}, {"lgammaf", FO::LGAMMA_32, 1}, + {"__builtin_lgamma", FO::LGAMMA_32, 1}, + {"fdim", FO::FDIM_32, 2}, {"fdimf", FO::FDIM_32, 2}, + {"__builtin_fdim", FO::FDIM_32, 2}, + {"__builtin_signbit", FO::SIGNBIT_32, 1}, + {"signbit", FO::SIGNBIT_32, 1}, + }; + for (const auto &fb : float_builtins) { + if (callee_name == fb.name && args.size() >= fb.num_args) { + // Determine float width from the result type of the call. + unsigned float_sz = 8; // Default to double (64-bit). + if (expr_type) { + if (auto s = TypeSizeBytes(*expr_type)) float_sz = *s; + } + InstructionIR inst; + inst.opcode = mx::ir::OpCode::FLOAT; + inst.float_op = static_cast( + SizedFloatSubOp(fb.op_32, float_sz)); + inst.source_entity_id = eid; + for (unsigned i = 0; i < fb.num_args; ++i) { + inst.operand_indices.push_back(EmitRValue(args[i])); + } + return emit_typed(std::move(inst)); + } + } + + // Zero-argument float constants. + if (callee_name == "__builtin_inf" || callee_name == "__builtin_inff" || + callee_name == "__builtin_infl") { + unsigned float_sz = 8; + if (expr_type) { + if (auto s = TypeSizeBytes(*expr_type)) float_sz = *s; + } + InstructionIR inst; + inst.opcode = mx::ir::OpCode::FLOAT; + inst.float_op = static_cast( + SizedFloatSubOp(FO::INF_32, float_sz)); + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); + } + if (callee_name == "__builtin_nan" || callee_name == "__builtin_nanf" || + callee_name == "__builtin_nanl") { + unsigned float_sz = 8; + if (expr_type) { + if (auto s = TypeSizeBytes(*expr_type)) float_sz = *s; + } + InstructionIR inst; + inst.opcode = mx::ir::OpCode::FLOAT; + inst.float_op = static_cast( + SizedFloatSubOp(FO::NAN_32, float_sz)); + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); + } + if (callee_name == "__builtin_huge_val" || + callee_name == "__builtin_huge_valf" || + callee_name == "__builtin_huge_vall") { + unsigned float_sz = 8; + if (expr_type) { + if (auto s = TypeSizeBytes(*expr_type)) float_sz = *s; + } + InstructionIR inst; + inst.opcode = mx::ir::OpCode::FLOAT; + inst.float_op = static_cast( + SizedFloatSubOp(FO::HUGE_32, float_sz)); + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); + } + } + + // Dynamic alloca → ALLOCA/DYNAMIC with scope-tracked object. + if (callee_name == "__builtin_alloca" || callee_name == "alloca") { + if (!args.empty()) { + // Create an ALLOCA object so the scope can track this allocation. + // On scope exit, the interpreter frees objects of kind ALLOCA. + ObjectIR obj; + obj.kind = mx::ir::ObjectKind::ALLOCA; + obj.source_decl_id = eid; + uint32_t obj_idx = next_obj_index_++; + func_.objects.push_back(std::move(obj)); + AssociateObjectWithScope(obj_idx); + + InstructionIR inst; + inst.opcode = mx::ir::OpCode::ALLOCA; + inst.alloca_kind = static_cast(mx::ir::AllocaKind::DYNAMIC); + inst.source_entity_id = eid; + inst.object_index = obj_idx; + inst.operand_indices.push_back(EmitRValue(args[0])); + return emit_typed(std::move(inst)); + } + } + + // Frame/return address intrinsics. + if (callee_name == "__builtin_frame_address") { + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::FRAME_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + inst.source_entity_id = eid; + if (!args.empty()) { + inst.operand_indices.push_back(EmitRValue(args[0])); + } else { + // Default level 0. + InstructionIR zero; + zero.opcode = mx::ir::OpCode::CONST; + zero.const_op = static_cast(mx::ir::ConstOp::INT32); + zero.source_entity_id = eid; + zero.int_value = 0; + zero.uint_value = 0; + zero.width = 32; + inst.operand_indices.push_back(EmitInstruction(std::move(zero))); + } + return emit_typed(std::move(inst)); + } + if (callee_name == "__builtin_return_address") { + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::RETURN_ADDRESS_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + inst.source_entity_id = eid; + if (!args.empty()) { + inst.operand_indices.push_back(EmitRValue(args[0])); + } else { + InstructionIR zero; + zero.opcode = mx::ir::OpCode::CONST; + zero.const_op = static_cast(mx::ir::ConstOp::INT32); + zero.source_entity_id = eid; + zero.int_value = 0; + zero.uint_value = 0; + zero.width = 32; + inst.operand_indices.push_back(EmitInstruction(std::move(zero))); + } + return emit_typed(std::move(inst)); + } + + // Atomic load/store/cmpxchg builtins. + if (callee_name == "__atomic_load_n" || callee_name == "__c11_atomic_load") { + if (!args.empty()) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + inst.operand_indices.push_back(EmitRValue(args[0])); + { + unsigned sz = 8; + if (auto t = e.Type()) { + if (auto s = TypeSizeBytes(*t)) sz = *s; + } + inst.mem_op = static_cast( + DetermineMemOp(false, true, sz)); + } + return emit_typed(std::move(inst)); + } + } + if (callee_name == "__atomic_store_n" || callee_name == "__c11_atomic_store") { + if (args.size() >= 2) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + inst.operand_indices.push_back(EmitRValue(args[0])); + inst.operand_indices.push_back(EmitRValue(args[1])); + { + unsigned sz = 8; + if (auto t = args[1].Type()) { + if (auto s = TypeSizeBytes(*t)) sz = *s; + } + inst.mem_op = static_cast( + DetermineMemOp(true, true, sz)); + } + return emit_typed(std::move(inst)); + } + } + if (callee_name == "__atomic_compare_exchange_n" || + callee_name == "__c11_atomic_compare_exchange_strong" || + callee_name == "__c11_atomic_compare_exchange_weak" || + callee_name == "__sync_bool_compare_and_swap" || + callee_name == "__sync_val_compare_and_swap") { + if (args.size() >= 3) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.source_entity_id = eid; + inst.operand_indices.push_back(EmitRValue(args[0])); + inst.operand_indices.push_back(EmitRValue(args[1])); + inst.operand_indices.push_back(EmitRValue(args[2])); + { + unsigned sz = 8; + if (auto t = args[2].Type()) { + if (auto s = TypeSizeBytes(*t)) sz = *s; + } + bool big = ctx_.getTargetInfo().isBigEndian(); + unsigned size_idx; + switch (sz) { + case 1: size_idx = 0; break; + case 2: size_idx = 1; break; + case 4: size_idx = 2; break; + case 8: default: size_idx = 3; break; + } + unsigned base = big ? static_cast(mx::ir::MemOp::CMPXCHG_BE_8) + : static_cast(mx::ir::MemOp::CMPXCHG_LE_8); + inst.mem_op = static_cast(base + size_idx); + } + return emit_typed(std::move(inst)); + } + } + + // Atomic fetch-and-modify → RMW with atomic underlying opcodes. + { + struct AtomicRMWBuiltin { + const char *name; + AtomicOp underlying; + bool returns_new; // true = returns new value, false = returns old + }; + static const AtomicRMWBuiltin atomic_rmw_builtins[] = { + {"__atomic_fetch_add", AtomicOp::ATOMIC_ADD, false}, + {"__atomic_add_fetch", AtomicOp::ATOMIC_ADD, true}, + {"__sync_fetch_and_add", AtomicOp::ATOMIC_ADD, false}, + {"__atomic_fetch_sub", AtomicOp::ATOMIC_SUB, false}, + {"__atomic_sub_fetch", AtomicOp::ATOMIC_SUB, true}, + {"__sync_fetch_and_sub", AtomicOp::ATOMIC_SUB, false}, + {"__atomic_fetch_and", AtomicOp::ATOMIC_AND, false}, + {"__atomic_and_fetch", AtomicOp::ATOMIC_AND, true}, + {"__sync_fetch_and_and", AtomicOp::ATOMIC_AND, false}, + {"__atomic_fetch_or", AtomicOp::ATOMIC_OR, false}, + {"__atomic_or_fetch", AtomicOp::ATOMIC_OR, true}, + {"__sync_fetch_and_or", AtomicOp::ATOMIC_OR, false}, + {"__atomic_fetch_xor", AtomicOp::ATOMIC_XOR, false}, + {"__atomic_xor_fetch", AtomicOp::ATOMIC_XOR, true}, + {"__sync_fetch_and_xor", AtomicOp::ATOMIC_XOR, false}, + {"__atomic_fetch_nand", AtomicOp::ATOMIC_NAND, false}, + {"__atomic_nand_fetch", AtomicOp::ATOMIC_NAND, true}, + {"__sync_fetch_and_nand", AtomicOp::ATOMIC_NAND, false}, + {"__atomic_exchange_n", AtomicOp::ATOMIC_EXCHANGE, false}, + {"__sync_lock_test_and_set", AtomicOp::ATOMIC_EXCHANGE, false}, + }; + for (const auto &ab : atomic_rmw_builtins) { + if (callee_name == ab.name && args.size() >= 2) { + // Determine width from the pointee type (args[0] is a pointer). + unsigned atomic_width = 4; + if (auto arg_type = args[0].Type()) { + if (auto pt = arg_type->PointeeType()) { + if (auto sz = TypeSizeBytes(*pt)) atomic_width = *sz; + } + } + InstructionIR rmw; + rmw.opcode = mx::ir::OpCode::READ_MODIFY_WRITE; + rmw.source_entity_id = eid; + rmw.compound_op = SizedAtomicOp(ab.underlying, atomic_width); + rmw.flags = ab.returns_new ? 1u : 0u; + rmw.operand_indices.push_back(EmitRValue(args[0])); + rmw.operand_indices.push_back(EmitRValue(args[1])); + rmw.is_big_endian = ctx_.getTargetInfo().isBigEndian(); + rmw.size_bytes = atomic_width; + return emit_typed(std::move(rmw)); + } + } + } + + // Type query builtins → CONST. + if (callee_name == "__builtin_constant_p") { + // In our IR everything is "not a constant" from the optimizer's view. + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(mx::ir::ConstOp::INT32); + inst.source_entity_id = eid; + inst.int_value = 0; + inst.uint_value = 0; + inst.width = 32; + return emit_typed(std::move(inst)); + } + if (callee_name == "__builtin_types_compatible_p" || + callee_name == "__builtin_classify_type" || + callee_name == "__builtin_object_size") { + auto *raw = reinterpret_cast(e.RawStmt()); + if (raw) { + clang::Expr::EvalResult eval_result; + if (raw->EvaluateAsInt(eval_result, ctx_)) { + auto ap_val = eval_result.Val.getInt(); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(IntConstOp( + static_cast(std::min(ap_val.getBitWidth(), 64u)), + true)); + inst.source_entity_id = eid; + inst.int_value = ap_val.getSExtValue(); + inst.uint_value = ap_val.getZExtValue(); + inst.width = static_cast( + std::min(ap_val.getBitWidth(), 64u)); + return emit_typed(std::move(inst)); + } + } + // Fallback for __builtin_object_size: return -1 (unknown). + if (callee_name == "__builtin_object_size") { + // Use the call expression's return type. + uint8_t w = 64; + if (auto t = e.Type()) { + if (auto s = TypeSizeBytes(*t)) w = static_cast(*s * 8); + } + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(IntConstOp(w, false)); + inst.source_entity_id = eid; + inst.int_value = -1; + inst.uint_value = (w <= 32) ? 0xFFFFFFFFull : ~0ull; + inst.width = w; + return emit_typed(std::move(inst)); + } + } + } + + // Ensure we have an EXPRESSION_SCOPE for the argument allocas. + EnsureExpressionScope(eid); + + InstructionIR inst; + inst.source_entity_id = eid; + inst.opcode = mx::ir::OpCode::CALL; + + auto args = ce->Arguments(); + + if (direct_callee) { + auto canon = direct_callee->CanonicalDeclaration(); + inst.target_entity_id = EntityIdOf(canon); + } else { + inst.target_entity_id = kInvalidEntityId; + // For indirect calls, first operand is the callee pointer. + inst.operand_indices.push_back(EmitRValue(ce->Callee())); + } + + // Create ARG allocas for each argument. + for (uint32_t i = 0; i < args.size(); ++i) { + auto arg_expr = args[i]; + uint32_t val_idx = EmitRValue(arg_expr); + + // Create ALLOCA/ARG for this argument. + ObjectIR obj; + obj.kind = mx::ir::ObjectKind::PARAMETER; + obj.source_decl_id = EntityIdOf(arg_expr); + if (auto t = arg_expr.Type()) { + obj.type_entity_id = TypeEntityIdOf(*t); + if (auto sz = TypeSizeBytes(*t)) obj.size_bytes = *sz; + if (auto al = TypeAlignBytes(*t)) obj.align_bytes = *al; + } + uint32_t obj_idx = next_obj_index_++; + func_.objects.push_back(std::move(obj)); + AssociateObjectWithScope(obj_idx); + + InstructionIR alloca_inst; + alloca_inst.opcode = mx::ir::OpCode::ALLOCA; + alloca_inst.alloca_kind = static_cast(mx::ir::AllocaKind::ARG); + alloca_inst.source_entity_id = EntityIdOf(arg_expr); + alloca_inst.object_index = obj_idx; + if (auto t = arg_expr.Type()) { + alloca_inst.type_entity_id = TypeEntityIdOf(*t); + } + uint32_t alloca_idx = EmitInstruction(std::move(alloca_inst)); + + // Copy value into the ARG alloca. + unsigned sz = 8; + if (auto t = arg_expr.Type()) { + if (auto s = TypeSizeBytes(*t)) sz = *s; + } + + InstructionIR store; + store.opcode = mx::ir::OpCode::MEMORY; + store.source_entity_id = EntityIdOf(arg_expr); + if (!IsScalarSize(sz)) { + // Large argument: MEMCPY. + uint32_t size_idx = EmitSizeConst(sz); + store.operand_indices = {alloca_idx, val_idx, size_idx}; + store.mem_op = static_cast(mx::ir::MemOp::MEMCPY); + } else if (arg_expr.IsLValue()) { + // Lvalue arg: MEMCPY from source address. + uint32_t src_idx = EmitLValue(arg_expr); + uint32_t size_idx = EmitSizeConst(sz); + store.operand_indices = {alloca_idx, src_idx, size_idx}; + store.mem_op = static_cast(mx::ir::MemOp::MEMCPY); + } else { + // Scalar rvalue: STORE. + store.operand_indices = {alloca_idx, val_idx}; + bool arg_is_float = false; + if (auto t = arg_expr.Type()) arg_is_float = t->IsFloatingType(); + store.mem_op = static_cast( + DetermineMemOp(true, false, sz, arg_is_float)); + } + EmitTopLevel(std::move(store)); + + // CALL operand is the ARG alloca (pointer to argument storage). + inst.operand_indices.push_back(alloca_idx); + } + + // Create ALLOCA/RETURN for the return value (if non-void). + auto ret_type = ce->Type(); + bool has_return = ret_type && !ret_type->IsVoidType(); + uint32_t return_alloca_idx = UINT32_MAX; + if (has_return) { + ObjectIR ret_obj; + ret_obj.kind = mx::ir::ObjectKind::RETURN_SLOT; + if (ret_type) { + ret_obj.type_entity_id = TypeEntityIdOf(*ret_type); + if (auto sz = TypeSizeBytes(*ret_type)) ret_obj.size_bytes = *sz; + if (auto al = TypeAlignBytes(*ret_type)) ret_obj.align_bytes = *al; + } + uint32_t ret_obj_idx = next_obj_index_++; + func_.objects.push_back(std::move(ret_obj)); + AssociateObjectWithScope(ret_obj_idx); + + InstructionIR ret_alloca; + ret_alloca.opcode = mx::ir::OpCode::ALLOCA; + ret_alloca.alloca_kind = static_cast(mx::ir::AllocaKind::RETURN); + ret_alloca.source_entity_id = eid; + ret_alloca.object_index = ret_obj_idx; + if (ret_type) ret_alloca.type_entity_id = TypeEntityIdOf(*ret_type); + return_alloca_idx = EmitInstruction(std::move(ret_alloca)); + } + + inst.return_alloca_index = return_alloca_idx; + return emit_typed(std::move(inst)); + } + + // Conditional operator (ternary) -- kept as SELECT, not control flow. + // Both true and false branches are conditionally executed. + if (auto co = pasta::ConditionalOperator::From(e)) { + uint32_t cond_idx = EmitRValue(co->Condition()); + uint32_t true_idx = EmitRValue(co->TrueExpression()); + uint32_t false_idx = EmitRValue(co->FalseExpression()); + MarkConditionallyExecuted(true_idx); + MarkConditionallyExecuted(false_idx); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::SELECT; + inst.source_entity_id = eid; + inst.operand_indices = {cond_idx, true_idx, false_idx}; + return emit_typed(std::move(inst)); + } + + // sizeof / alignof / other type traits -- emit as CONST. + if (auto tte = pasta::UnaryExprOrTypeTraitExpr::From(e)) { + auto arg_type = tte->TypeOfArgument(); + std::optional val; + if (tte->KeywordKind() == pasta::UnaryExprOrTypeTrait::kSizeOf) { + val = TypeSizeBytes(arg_type); + } else if (tte->KeywordKind() == pasta::UnaryExprOrTypeTrait::kAlignOf || + tte->KeywordKind() == pasta::UnaryExprOrTypeTrait::kPreferredAlignOf) { + val = TypeAlignBytes(arg_type); + } else { + val = TypeSizeBytes(arg_type); // fallback + } + if (val) { + // Use the expression's own type for the constant width (e.g., size_t). + uint8_t w = SizeTypeWidth(); + if (auto t = e.Type()) { + if (auto s = TypeSizeBytes(*t)) w = static_cast(*s * 8); + } + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(IntConstOp(w, false)); + inst.source_entity_id = eid; + inst.int_value = static_cast(*val); + inst.uint_value = static_cast(*val); + inst.width = w; + return emit_typed(std::move(inst)); + } + } + + // InitListExpr -- allocate a COMPOUND_LITERAL temp, fill via EmitInitializer, + // return ALLOCA. This makes aggregate init consistent with compound literals. + if (auto ile = pasta::InitListExpr::From(e)) { + ObjectIR obj; + obj.kind = mx::ir::ObjectKind::COMPOUND_LITERAL; + obj.source_decl_id = eid; + if (auto t = e.Type()) { + obj.type_entity_id = TypeEntityIdOf(*t); + if (auto sz = TypeSizeBytes(*t)) obj.size_bytes = *sz; + if (auto al = TypeAlignBytes(*t)) obj.align_bytes = *al; + } + uint32_t obj_idx = next_obj_index_++; + func_.objects.push_back(std::move(obj)); + AssociateObjectWithScope(obj_idx); + + // ALLOCA for the temp object. + InstructionIR alloca_inst; + alloca_inst.opcode = mx::ir::OpCode::ALLOCA; + alloca_inst.source_entity_id = eid; + alloca_inst.object_index = obj_idx; + if (auto t = e.Type()) alloca_inst.type_entity_id = TypeEntityIdOf(*t); + uint32_t alloca_idx = EmitInstruction(std::move(alloca_inst)); + object_to_alloca_[obj_idx] = alloca_idx; + + // Fill the temp via EmitInitializer. + EmitInitializer(alloca_idx, *ile, eid); + + return alloca_idx; + } + + // CompoundLiteralExpr -- allocate temp, fill via EmitInitializer. + if (auto cle = pasta::CompoundLiteralExpr::From(e)) { + ObjectIR obj; + obj.kind = mx::ir::ObjectKind::COMPOUND_LITERAL; + obj.source_decl_id = eid; + if (auto t = e.Type()) { + obj.type_entity_id = TypeEntityIdOf(*t); + if (auto sz = TypeSizeBytes(*t)) obj.size_bytes = *sz; + if (auto al = TypeAlignBytes(*t)) obj.align_bytes = *al; + } + uint32_t obj_idx = next_obj_index_++; + func_.objects.push_back(std::move(obj)); + AssociateObjectWithScope(obj_idx); + + InstructionIR alloca_inst; + alloca_inst.opcode = mx::ir::OpCode::ALLOCA; + alloca_inst.source_entity_id = eid; + alloca_inst.object_index = obj_idx; + if (auto t = e.Type()) alloca_inst.type_entity_id = TypeEntityIdOf(*t); + uint32_t alloca_idx = EmitInstruction(std::move(alloca_inst)); + object_to_alloca_[obj_idx] = alloca_idx; + + EmitInitializer(alloca_idx, cle->Initializer(), eid); + + return alloca_idx; + } + + // StmtExpr -- GNU ({ ... }) expression. Emit all statements in a scope, + // return the value of the last expression. + if (auto se = pasta::StmtExpr::From(e)) { + auto sub = se->SubStatement(); + if (auto cs = pasta::CompoundStmt::From(sub)) { + // Push a scope for the block expression's locals. + PushStructure(mx::ir::StructureKind::SCOPE, EntityIdOf(sub)); + { + InstructionIR enter; + enter.opcode = mx::ir::OpCode::ENTER_SCOPE; + enter.source_entity_id = EntityIdOf(sub); + enter.structure_index = current_structure_index_; + EmitTopLevel(std::move(enter)); + } + + // Emit all children. The last expression child is the value. + auto children = cs->Children(); + std::vector child_vec(children.begin(), children.end()); + uint32_t last_idx = UINT32_MAX; + + for (size_t i = 0; i < child_vec.size(); ++i) { + bool is_last = (i == child_vec.size() - 1); + auto child_expr = pasta::Expr::From(child_vec[i]); + if (is_last && child_expr) { + // Last child is an expression — its value is the block result. + last_idx = EmitRValue(*child_expr); + } else { + // Non-last children: emit as statements (side effects only). + EmitStmt(child_vec[i]); + } + } + + { + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = EntityIdOf(sub); + exit_inst.structure_index = current_structure_index_; + EmitTopLevel(std::move(exit_inst)); + } + PopStructure(); + + if (last_idx != UINT32_MAX) return last_idx; + } + // No expression result — return undefined. + InstructionIR inst; + inst.opcode = mx::ir::OpCode::UNDEFINED; + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); + } + + // VAArgExpr -- va_arg(ap, type). + if (auto va = pasta::VAArgExpr::From(e)) { + uint32_t sub_idx = EmitRValue(va->SubExpression()); + InstructionIR inst; + inst.opcode = mx::ir::OpCode::MEMORY; + inst.mem_op = static_cast(mx::ir::MemOp::CONSUME_VA_PARAM); + inst.source_entity_id = eid; + if (auto t = e.Type()) inst.type_entity_id = TypeEntityIdOf(*t); + inst.operand_indices = {sub_idx}; + return emit_typed(std::move(inst)); + } + + + // PredefinedExpr (__func__, __FUNCTION__, __PRETTY_FUNCTION__) -- unwrap to the StringLiteral. + if (auto pe = pasta::PredefinedExpr::From(e)) { + if (auto fn = pe->FunctionName()) { + return EmitRValue(*fn); + } + } + + // CXXNullPtrLiteralExpr -- nullptr. + if (pasta::CXXNullPtrLiteralExpr::From(e)) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(mx::ir::ConstOp::NULL_PTR); + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); + } + + // CXXBoolLiteralExpr -- true/false. + if (auto bl = pasta::CXXBoolLiteralExpr::From(e)) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(mx::ir::ConstOp::BOOL); + inst.source_entity_id = eid; + inst.int_value = bl->Value() ? 1 : 0; + inst.uint_value = bl->Value() ? 1 : 0; + inst.width = 1; + if (auto t = e.Type()) inst.type_entity_id = TypeEntityIdOf(*t); + return emit_typed(std::move(inst)); + } + + // DesignatedInitExpr -- unwrap to the actual initializer value. + if (auto die = pasta::DesignatedInitExpr::From(e)) { + return EmitRValue(die->Initializer()); + } + + // ImplicitValueInitExpr -- zero-initialization of a value. + if (pasta::ImplicitValueInitExpr::From(e)) { + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.source_entity_id = eid; + inst.int_value = 0; + inst.uint_value = 0; + // Use the expression's type to pick the right constant width. + uint8_t width = 64; + if (auto t = e.Type()) { + if (auto sz = TypeSizeBytes(*t)) { + width = static_cast(*sz * 8); + } + } + inst.width = width; + inst.const_op = static_cast(IntConstOp(width, true)); + return emit_typed(std::move(inst)); + } + + // ChooseExpr (__builtin_choose_expr) -- emit the chosen sub-expression. + if (auto ce = pasta::ChooseExpr::From(e)) { + return EmitRValue(ce->ChosenSubExpression()); + } + + // GenericSelectionExpr (_Generic) -- emit the result expression. + if (auto gse = pasta::GenericSelectionExpr::From(e)) { + if (auto re = gse->ResultExpression()) { + return EmitRValue(*re); + } + } + + // OffsetOfExpr (__builtin_offsetof) -- try to evaluate as constant. + if (auto ofe = pasta::OffsetOfExpr::From(e)) { + auto *raw = reinterpret_cast(ofe->RawStmt()); + if (raw) { + clang::Expr::EvalResult eval_result; + if (raw->EvaluateAsInt(eval_result, ctx_)) { + auto ap_val = eval_result.Val.getInt(); + // Use the expression's own type for the constant width (size_t). + uint8_t w = SizeTypeWidth(); + if (auto t = e.Type()) { + if (auto s = TypeSizeBytes(*t)) w = static_cast(*s * 8); + } + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(IntConstOp(w, false)); + inst.source_entity_id = eid; + inst.int_value = ap_val.getSExtValue(); + inst.uint_value = ap_val.getZExtValue(); + inst.width = w; + return emit_typed(std::move(inst)); + } + } + } + + // Emit UNKNOWN for anything we haven't explicitly handled. + InstructionIR inst; + inst.opcode = mx::ir::OpCode::UNKNOWN; + inst.source_entity_id = eid; + return emit_typed(std::move(inst)); +} + +uint32_t IRGenerator::EmitLValue(const pasta::Expr &e) { + auto eid = EntityIdOf(e); + + // Paren -- unwrap. + if (auto pe = pasta::ParenExpr::From(e)) { + return EmitLValue(pe->SubExpression()); + } + + // DeclRefExpr -> addressOf / globalAddr / funcAddr. + if (auto dre = pasta::DeclRefExpr::From(e)) { + auto decl = dre->Declaration(); + + // Function reference → FUNC_PTR. + if (auto fd = pasta::FunctionDecl::From(decl)) { + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::FUNC_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + inst.source_entity_id = eid; + inst.target_entity_id = EntityIdOf(fd->CanonicalDeclaration()); + return EmitInstruction(std::move(inst)); + } + + // Global/static/thread-local variable → GLOBAL_PTR or THREAD_LOCAL_PTR. + if (auto vd = pasta::VarDecl::From(decl)) { + if (vd->HasGlobalStorage()) { + InstructionIR inst; + inst.source_entity_id = eid; + inst.target_entity_id = EntityIdOf(decl); + // Distinguish thread-local from regular global. + if (vd->TLSKind() != pasta::VarDeclTLSKind::kNone) { + inst.opcode = SizedPtrOp(mx::ir::OpCode::THREAD_LOCAL_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + } else { + inst.opcode = SizedPtrOp(mx::ir::OpCode::GLOBAL_PTR_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + } + return EmitInstruction(std::move(inst)); + } + } + + // Local/parameter → reference the ALLOCA directly. + uint32_t obj_idx = GetOrMakeObject(decl); + return object_to_alloca_[obj_idx]; + } + + // MemberExpr. + if (auto me = pasta::MemberExpr::From(e)) { + uint32_t base_idx; + if (me->IsArrow()) { + base_idx = EmitRValue(me->Base()); + } else { + base_idx = EmitLValue(me->Base()); + } + + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::GEP_FIELD_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + inst.source_entity_id = eid; + inst.operand_indices = {base_idx}; + + auto member = me->MemberDeclaration(); + inst.target_entity_id = EntityIdOf(member); + // Field name accessible via target_entity_id -> FieldDecl::Name() + if (auto fd = pasta::FieldDecl::From(member)) { + auto bits = fd->OffsetInBits(); + if (bits) inst.size_bytes = static_cast(*bits / 8); + } + return EmitInstruction(std::move(inst)); + } + + // ArraySubscriptExpr -- pointer + index. + if (auto ase = pasta::ArraySubscriptExpr::From(e)) { + uint32_t base_idx = EmitRValue(ase->Base()); + uint32_t idx_idx = EmitRValue(ase->Index()); + InstructionIR inst; + inst.opcode = SizedPtrOp(mx::ir::OpCode::PTR_ADD_32, + static_cast(ctx_.getTargetInfo().getPointerWidth(clang::LangAS::Default)) / 8); + inst.source_entity_id = eid; + inst.operand_indices = {base_idx, idx_idx}; + // Element type from the base pointer/array type. + auto base_type = ase->Base().Type(); + if (base_type) { + if (auto pt = pasta::PointerType::From(*base_type)) { + auto pointee = pt->PointeeType(); + inst.type_entity_id = TypeEntityIdOf(pointee); + if (auto sz = TypeSizeBytes(pointee)) inst.size_bytes = *sz; + } else if (auto at = base_type->PointeeOrArrayElementType()) { + inst.type_entity_id = TypeEntityIdOf(*at); + if (auto sz = TypeSizeBytes(*at)) inst.size_bytes = *sz; + } + } + return EmitInstruction(std::move(inst)); + } + + // UnaryOperator(Deref) -> the pointer IS the address. + if (auto uo = pasta::UnaryOperator::From(e)) { + { + if (uo->Opcode() == pasta::UnaryOperatorKind::kDeref) { + return EmitRValue(uo->SubExpression()); + } + } + } + + // ImplicitCastExpr passthrough. + if (auto ice = pasta::ImplicitCastExpr::From(e)) { + { + auto ck = ice->CastKind(); + if (ck == pasta::CastKind::kLValueToRValue || + ck == pasta::CastKind::kArrayToPointerDecay || + ck == pasta::CastKind::kNoOperation) { + return EmitLValue(ice->SubExpression()); + } + } + return EmitLValue(ice->SubExpression()); + } + + // Fallback: treat as rvalue. + return EmitRValue(e); +} + +// --------------------------------------------------------------------------- +// Entity ID helpers +// --------------------------------------------------------------------------- + +RawEntityId IRGenerator::EntityIdOf(const pasta::Stmt &s) { + return em_.EntityId(s); +} + +RawEntityId IRGenerator::EntityIdOf(const pasta::Decl &d) { + return em_.EntityId(d); +} + +RawEntityId IRGenerator::TypeEntityIdOf(const pasta::Type &t) { + return em_.EntityId(t); +} + +// --------------------------------------------------------------------------- +// Type helpers +// --------------------------------------------------------------------------- + +std::optional IRGenerator::TypeSizeBytes(const pasta::Type &t) { + { + auto bits = t.SizeInBits(); + if (bits && *bits > 0) return static_cast((*bits + 7) / 8); + } + return std::nullopt; +} + +std::optional IRGenerator::TypeAlignBytes(const pasta::Type &t) { + { + // pasta::Type::Alignment() already returns bytes. + auto a = t.Alignment(); + if (a && *a > 0) return static_cast(*a); + } + return std::nullopt; +} + +uint8_t IRGenerator::SizeTypeWidth() const { + return size_type_width_; +} + +// Emit a CONST instruction holding a size_t value. +uint32_t IRGenerator::EmitSizeConst(uint64_t val, + mx::RawEntityId source_eid) { + uint8_t w = size_type_width_; + InstructionIR inst; + inst.opcode = mx::ir::OpCode::CONST; + inst.const_op = static_cast(IntConstOp(w, false)); + inst.int_value = static_cast(val); + inst.uint_value = val; + inst.width = w; + inst.source_entity_id = source_eid; + inst.type_entity_id = size_type_eid_; + return EmitInstruction(std::move(inst)); +} + +mx::ir::MemOp IRGenerator::DetermineMemOp( + bool is_store, bool is_atomic, unsigned size_bytes, bool is_float) { + // Float load/store: separate sub-opcodes for 32-bit and 64-bit. + if (is_float && !is_atomic && (size_bytes == 4 || size_bytes == 8)) { + bool big_endian = ctx_.getTargetInfo().isBigEndian(); + if (!is_store) { + if (size_bytes == 4) return big_endian ? mx::ir::MemOp::LOAD_F32_BE : mx::ir::MemOp::LOAD_F32_LE; + return big_endian ? mx::ir::MemOp::LOAD_F64_BE : mx::ir::MemOp::LOAD_F64_LE; + } else { + if (size_bytes == 4) return big_endian ? mx::ir::MemOp::STORE_F32_BE : mx::ir::MemOp::STORE_F32_LE; + return big_endian ? mx::ir::MemOp::STORE_F64_BE : mx::ir::MemOp::STORE_F64_LE; + } + } + assert(IsScalarSize(size_bytes) && + "DetermineMemOp called with non-scalar size; use MEMCPY instead"); + unsigned size_idx; + switch (size_bytes) { + case 1: size_idx = 0; break; + case 2: size_idx = 1; break; + case 4: size_idx = 2; break; + case 8: size_idx = 3; break; + default: __builtin_unreachable(); + } + bool big_endian = ctx_.getTargetInfo().isBigEndian(); + unsigned base = 0; + if (is_store && !is_atomic) base = 8; + else if (!is_store && is_atomic) base = 16; + else if (is_store && is_atomic) base = 24; + if (big_endian) base += 4; + return static_cast(base + size_idx); +} + +// --------------------------------------------------------------------------- +// Goto compensation blocks +// --------------------------------------------------------------------------- + +void IRGenerator::InsertGotoCompensationBlocks() { + if (pending_gotos_.empty()) return; + + // Helper: get the scope chain from a structure index up to (and including) + // FUNCTION_SCOPE. Returns scopes in order from innermost to outermost. + auto get_scope_chain = [&](uint32_t si) -> std::vector { + std::vector chain; + while (si != UINT32_MAX) { + if (mx::ir::IsScope(func_.structures[si].kind)) { + chain.push_back(si); + } + si = func_.structures[si].parent_structure_index; + } + return chain; // innermost first + }; + + for (auto &pg : pending_gotos_) { + // Find the target label's structure. + auto label_it = label_structure_.find(pg.target_block_idx); + if (label_it == label_structure_.end()) { + // Forward reference to label we never saw — leave as-is. + continue; + } + uint32_t target_struct = label_it->second; + uint32_t source_struct = pg.source_structure_idx; + + // Get scope chains for source and target. + auto source_chain = get_scope_chain(source_struct); + auto target_chain = get_scope_chain(target_struct); + + // Find common ancestor scope by converting one chain to a set. + std::unordered_set source_set(source_chain.begin(), + source_chain.end()); + uint32_t common_ancestor = UINT32_MAX; + // Walk target chain (innermost→outermost) to find first match. + for (auto ts : target_chain) { + if (source_set.count(ts)) { + common_ancestor = ts; + break; + } + } + + // Scopes to exit: source scopes above common ancestor. + std::vector scopes_to_exit; + for (auto ss : source_chain) { + if (ss == common_ancestor) break; + scopes_to_exit.push_back(ss); + } + + // Scopes to enter: target scopes below common ancestor (reversed: + // we need outermost→innermost order for ENTER_SCOPE). + std::vector scopes_to_enter; + for (auto ts : target_chain) { + if (ts == common_ancestor) break; + scopes_to_enter.push_back(ts); + } + std::reverse(scopes_to_enter.begin(), scopes_to_enter.end()); + + // If no transitions needed, skip. + if (scopes_to_exit.empty() && scopes_to_enter.empty()) continue; + + // Compensation block needed. + + // Create a compensation block. + uint32_t comp_block = NewBlock(mx::ir::BlockKind::COMPENSATION); + + // Redirect the source instruction → comp_block instead of → target. + auto &goto_inst = func_.instructions[pg.goto_inst_idx]; + + // Update successor: source_block → comp_block (was → target). + auto &src_block = func_.blocks[pg.source_block_idx]; + for (auto &succ : src_block.successor_indices) { + if (succ == pg.target_block_idx) { + succ = comp_block; + break; + } + } + + // Redirect the branch target in the instruction itself. + // For SWITCH instructions, update the matching switch_cases entry. + // For gotos/branches, update branch_targets[0]. + if (goto_inst.opcode == mx::ir::OpCode::SWITCH) { + for (auto &sc : goto_inst.switch_cases) { + if (sc.block_index == pg.target_block_idx) { + sc.block_index = comp_block; + break; + } + } + } else if (!goto_inst.branch_targets.empty()) { + for (auto &bt : goto_inst.branch_targets) { + if (bt.block_index == pg.target_block_idx) { + bt.block_index = comp_block; + break; + } + } + } + + // Remove old predecessor: target no longer has source as predecessor. + auto &target_preds = func_.blocks[pg.target_block_idx].predecessor_indices; + for (auto it = target_preds.begin(); it != target_preds.end(); ++it) { + if (*it == pg.source_block_idx) { + target_preds.erase(it); + break; + } + } + + // Add new predecessor: comp_block has source as predecessor. + func_.blocks[comp_block].predecessor_indices.push_back(pg.source_block_idx); + + // Emit scope transitions in the compensation block. + uint32_t saved_block = current_block_index_; + SwitchToBlock(comp_block); + + // EXIT_SCOPE for each source scope above common ancestor. + for (auto si : scopes_to_exit) { + InstructionIR exit_inst; + exit_inst.opcode = mx::ir::OpCode::EXIT_SCOPE; + exit_inst.source_entity_id = func_.structures[si].source_entity_id; + exit_inst.structure_index = si; + EmitTopLevel(std::move(exit_inst)); + } + + // ENTER_SCOPE for each target scope below common ancestor. + for (auto si : scopes_to_enter) { + InstructionIR enter_inst; + enter_inst.opcode = mx::ir::OpCode::ENTER_SCOPE; + enter_inst.source_entity_id = func_.structures[si].source_entity_id; + enter_inst.structure_index = si; + EmitTopLevel(std::move(enter_inst)); + } + + // Branch from compensation block to the original target. + EmitBranch(pg.target_block_idx); + + SwitchToBlock(saved_block); + } + + pending_gotos_.clear(); +} + +// --------------------------------------------------------------------------- +// Dominator computation (Cooper-Harvey-Kennedy) +// --------------------------------------------------------------------------- + +void IRGenerator::ComputeDominators() { + auto &blocks = func_.blocks; + if (blocks.empty()) return; + + uint32_t entry = func_.entry_block_index; + uint32_t num_blocks = static_cast(blocks.size()); + + std::vector> succs(num_blocks); + std::vector> preds(num_blocks); + for (uint32_t i = 0; i < num_blocks; ++i) { + succs[i] = blocks[i].successor_indices; + preds[i] = blocks[i].predecessor_indices; + } + + // RPO. + std::vector rpo; + { + std::vector visited(num_blocks, false); + std::function dfs = [&](uint32_t n) { + if (visited[n]) return; + visited[n] = true; + for (auto s : succs[n]) dfs(s); + rpo.push_back(n); + }; + dfs(entry); + std::reverse(rpo.begin(), rpo.end()); + } + + std::unordered_map rpo_num; + for (uint32_t i = 0; i < rpo.size(); ++i) rpo_num[rpo[i]] = i; + + // Immediate dominators. + std::vector idom(num_blocks, UINT32_MAX); + idom[entry] = entry; + + auto intersect = [&](uint32_t b1, uint32_t b2) -> uint32_t { + while (b1 != b2) { + while (rpo_num.count(b1) && rpo_num.count(b2) && rpo_num[b1] > rpo_num[b2]) b1 = idom[b1]; + while (rpo_num.count(b1) && rpo_num.count(b2) && rpo_num[b2] > rpo_num[b1]) b2 = idom[b2]; + } + return b1; + }; + + bool changed = true; + while (changed) { + changed = false; + for (auto b : rpo) { + if (b == entry) continue; + uint32_t new_idom = UINT32_MAX; + for (auto p : preds[b]) { + if (idom[p] == UINT32_MAX) continue; + new_idom = (new_idom == UINT32_MAX) ? p : intersect(new_idom, p); + } + if (new_idom != UINT32_MAX && idom[b] != new_idom) { + idom[b] = new_idom; + changed = true; + } + } + } + + for (uint32_t i = 0; i < num_blocks; ++i) { + if (idom[i] != UINT32_MAX && idom[i] != i) + blocks[i].immediate_dominator = idom[i]; + + uint32_t cur = i; + while (cur != UINT32_MAX && cur != idom[cur]) { + blocks[i].dominator_indices.push_back(cur); + cur = idom[cur]; + } + if (cur != UINT32_MAX) blocks[i].dominator_indices.push_back(cur); + } + + // Post-dominators (reverse CFG). + std::vector exits; + for (uint32_t i = 0; i < num_blocks; ++i) + if (succs[i].empty()) exits.push_back(i); + if (exits.empty()) exits.push_back(num_blocks - 1); + + uint32_t virt_exit = num_blocks; + std::vector> rev_succs(num_blocks + 1); + std::vector> rev_preds(num_blocks + 1); + for (uint32_t i = 0; i < num_blocks; ++i) { + rev_succs[i] = preds[i]; + rev_preds[i] = succs[i]; + } + for (auto ex : exits) { + rev_succs[virt_exit].push_back(ex); + rev_preds[ex].push_back(virt_exit); + } + + std::vector rev_rpo; + { + std::vector visited(num_blocks + 1, false); + std::function dfs = [&](uint32_t n) { + if (visited[n]) return; + visited[n] = true; + for (auto s : rev_succs[n]) dfs(s); + rev_rpo.push_back(n); + }; + dfs(virt_exit); + std::reverse(rev_rpo.begin(), rev_rpo.end()); + } + + std::unordered_map rev_rpo_num; + for (uint32_t i = 0; i < rev_rpo.size(); ++i) rev_rpo_num[rev_rpo[i]] = i; + + std::vector ipdom(num_blocks + 1, UINT32_MAX); + ipdom[virt_exit] = virt_exit; + + auto rev_intersect = [&](uint32_t b1, uint32_t b2) -> uint32_t { + while (b1 != b2) { + while (rev_rpo_num.count(b1) && rev_rpo_num.count(b2) && rev_rpo_num[b1] > rev_rpo_num[b2]) b1 = ipdom[b1]; + while (rev_rpo_num.count(b1) && rev_rpo_num.count(b2) && rev_rpo_num[b2] > rev_rpo_num[b1]) b2 = ipdom[b2]; + } + return b1; + }; + + changed = true; + while (changed) { + changed = false; + for (auto b : rev_rpo) { + if (b == virt_exit) continue; + uint32_t new_ipdom = UINT32_MAX; + for (auto p : rev_preds[b]) { + if (ipdom[p] == UINT32_MAX) continue; + new_ipdom = (new_ipdom == UINT32_MAX) ? p : rev_intersect(new_ipdom, p); + } + if (new_ipdom != UINT32_MAX && ipdom[b] != new_ipdom) { + ipdom[b] = new_ipdom; + changed = true; + } + } + } + + for (uint32_t i = 0; i < num_blocks; ++i) { + if (ipdom[i] != UINT32_MAX && ipdom[i] != virt_exit && ipdom[i] != i) + blocks[i].immediate_post_dominator = ipdom[i]; + + uint32_t cur = i; + while (cur != UINT32_MAX && cur != virt_exit && cur != ipdom[cur]) { + blocks[i].post_dominator_indices.push_back(cur); + cur = ipdom[cur]; + } + if (cur != UINT32_MAX && cur != virt_exit) + blocks[i].post_dominator_indices.push_back(cur); + } +} + +void IRGenerator::ComputeRPO() { + auto &blocks = func_.blocks; + if (blocks.empty()) return; + + uint32_t num_blocks = static_cast(blocks.size()); + std::vector visited(num_blocks, false); + func_.rpo_block_order.clear(); + + std::function dfs = [&](uint32_t n) { + if (visited[n]) return; + visited[n] = true; + for (auto s : blocks[n].successor_indices) dfs(s); + func_.rpo_block_order.push_back(n); + }; + dfs(func_.entry_block_index); + std::reverse(func_.rpo_block_order.begin(), func_.rpo_block_order.end()); +} + +void IRGenerator::VerifyBlocks() { + auto &blocks = func_.blocks; + auto &instructions = func_.instructions; + + // Entry block must exist. + DCHECK(func_.entry_block_index < blocks.size()) + << "Entry block index out of range"; + + for (uint32_t bi = 0; bi < blocks.size(); ++bi) { + auto &block = blocks[bi]; + + // All blocks should have been patched before ComputeDominators. + DCHECK(!block.instruction_indices.empty()) + << "Block " << bi << " has no instructions"; + + // Every instruction in the block must be marked as a root. + for (auto idx : block.instruction_indices) { + DCHECK(idx < instructions.size()) + << "Block " << bi << " instruction index " << idx << " out of range"; + DCHECK(instructions[idx].is_root) + << "Block " << bi << " instruction " << idx + << " (opcode=" << static_cast(instructions[idx].opcode) + << ") is in instruction_indices but is_root is false"; + DCHECK(instructions[idx].parent_instruction_index == UINT32_MAX) + << "Block " << bi << " root instruction " << idx + << " has parent_instruction_index=" + << instructions[idx].parent_instruction_index + << " (should be UINT32_MAX)"; + } + + // The last top-level instruction must be a terminator. + // No non-terminator instructions may appear after the terminator. + { + auto last_idx = block.instruction_indices.back(); + auto last_op = instructions[last_idx].opcode; + DCHECK(mx::ir::IsTerminator(last_op)) + << "Block " << bi << " last instruction is not a terminator (opcode=" + << static_cast(last_op) << ")"; + + bool seen_terminator = false; + for (auto idx : block.instruction_indices) { + DCHECK(!seen_terminator) + << "Block " << bi << " has instruction " << idx + << " (opcode=" << static_cast(instructions[idx].opcode) + << ") after terminator"; + if (mx::ir::IsTerminator(instructions[idx].opcode)) { + seen_terminator = true; + } + } + } + + // Successor/predecessor edges must be symmetric. + for (auto succ_idx : block.successor_indices) { + DCHECK(succ_idx < blocks.size()) + << "Block " << bi << " successor " << succ_idx << " out of range"; + auto &succ = blocks[succ_idx]; + bool found = false; + for (auto pred_idx : succ.predecessor_indices) { + if (pred_idx == bi) { found = true; break; } + } + DCHECK(found) + << "Block " << bi << " -> " << succ_idx + << " successor edge has no matching predecessor"; + } + + for (auto pred_idx : block.predecessor_indices) { + DCHECK(pred_idx < blocks.size()) + << "Block " << bi << " predecessor " << pred_idx << " out of range"; + auto &pred = blocks[pred_idx]; + bool found = false; + for (auto succ_idx : pred.successor_indices) { + if (succ_idx == bi) { found = true; break; } + } + DCHECK(found) + << "Block " << bi << " <- " << pred_idx + << " predecessor edge has no matching successor"; + } + } +} + +} // namespace ir +} // namespace indexer diff --git a/bin/Index/IRGen.h b/bin/Index/IRGen.h new file mode 100644 index 000000000..b0c4736a4 --- /dev/null +++ b/bin/Index/IRGen.h @@ -0,0 +1,356 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace clang { +class ASTContext; +} // namespace clang + +namespace pasta { +class AST; +class Decl; +class Expr; +class FunctionDecl; +class Stmt; +class Type; +class VarDecl; +} // namespace pasta + +namespace indexer { + +class EntityMapper; + +namespace ir { + +// --------------------------------------------------------------------------- +// In-memory IR data structures (populated during generation, then serialized) +// --------------------------------------------------------------------------- + +struct BranchTargetIR { + uint32_t block_index{0}; +}; + +struct InstructionIR { + mx::ir::OpCode opcode{mx::ir::OpCode::UNREACHABLE}; + mx::RawEntityId source_entity_id{mx::kInvalidEntityId}; + + // Operand instruction indices (into FunctionIR::instructions). + std::vector operand_indices; + + // Parent instruction index (UINT32_MAX for top-level roots). + // Roots have their parent block determined by which BlockIR contains them. + uint32_t parent_instruction_index{UINT32_MAX}; + + // Block this instruction was emitted into (set by EmitInstruction). + uint32_t parent_block_index{UINT32_MAX}; + + // True if this instruction was emitted via EmitTopLevel (is a block root). + // SetOperandParents will not reparent root instructions. + bool is_root{false}; + + // OpCode-specific fields. + uint32_t object_index{0}; + mx::RawEntityId type_entity_id{mx::kInvalidEntityId}; + mx::RawEntityId target_entity_id{mx::kInvalidEntityId}; + int64_t int_value{0}; // sign-extended + uint64_t uint_value{0}; // zero-extended + double float_value{0.0}; + uint8_t width{0}; + uint32_t size_bytes{0}; + uint8_t flags{0}; + mx::ir::OpCode compound_op{mx::ir::OpCode::ADD_64}; + uint8_t alloca_kind{0}; // AllocaKind sub-opcode for ALLOCA instructions + uint8_t const_op{0}; // ConstOp sub-opcode for CONST instructions + uint8_t cast_op{0}; // CastOp sub-opcode for CAST instructions + uint8_t bitwise_op{0}; // BitwiseOp sub-opcode for BITWISE instructions + uint8_t mem_op{0}; // MemOp sub-opcode for MEMORY instructions + uint8_t float_op{0}; // FloatOp sub-opcode for FLOAT instructions + bool is_big_endian{false}; // target endianness (for READ_MODIFY_WRITE) + uint32_t bit_offset{0}; // BIT_READ/BIT_WRITE: bit offset into the object + uint32_t bit_width{0}; // BIT_READ/BIT_WRITE: number of bits + + // Structure index for ENTER_SCOPE/EXIT_SCOPE (into FunctionIR::structures). + uint32_t structure_index{UINT32_MAX}; + + // Return alloca instruction index for CALL (UINT32_MAX if void). + uint32_t return_alloca_index{UINT32_MAX}; + + // Terminator data. + std::vector branch_targets; + + // Switch cases: one per case/default in a switch statement. + // Each maps to an IRStructure entity (kind SWITCH_CASE) in the serialized output. + struct SwitchCaseIR { + int64_t low{0}; + int64_t high{0}; + uint32_t block_index{0}; + uint32_t structure_index{UINT32_MAX}; // Index into func.structures + mx::RawEntityId source_entity_id{mx::kInvalidEntityId}; // CaseStmt/DefaultStmt + bool is_default{false}; + }; + std::vector switch_cases; +}; + +struct BlockIR { + mx::ir::BlockKind kind{mx::ir::BlockKind::GENERIC}; + uint32_t parent_structure_index{UINT32_MAX}; + + // Top-level instruction indices (roots of expression trees). + std::vector instruction_indices; + + // Block indices. + std::vector successor_indices; + std::vector predecessor_indices; + + // Dominator tree. + std::vector dominator_indices; + std::vector post_dominator_indices; + uint32_t immediate_dominator{UINT32_MAX}; + uint32_t immediate_post_dominator{UINT32_MAX}; +}; + +struct ObjectIR { + mx::RawEntityId source_decl_id{mx::kInvalidEntityId}; + mx::RawEntityId type_entity_id{mx::kInvalidEntityId}; + uint32_t size_bytes{0}; + uint32_t align_bytes{1}; + mx::ir::ObjectKind kind{mx::ir::ObjectKind::LOCAL}; +}; + +struct StructureIR { + mx::ir::StructureKind kind{mx::ir::StructureKind::SCOPE}; + mx::RawEntityId source_entity_id{mx::kInvalidEntityId}; + uint32_t parent_structure_index{UINT32_MAX}; // index into FunctionIR::structures + + // Children: interleaved structure and block indices (in source order). + // Each entry is either a structure index (with is_structure=true) or block index. + struct ChildRef { + uint32_t index; + bool is_structure; + }; + std::vector children; + + // Object indices for scope kinds (ALLOCAs declared in this scope). + std::vector object_indices; + + // Switch case data (for SWITCH_CASE kind). + int64_t case_low{0}; + int64_t case_high{0}; + bool is_default{false}; +}; + +struct FunctionIR { + mx::RawEntityId func_decl_entity_id{mx::kInvalidEntityId}; + mx::ir::FunctionKind kind{mx::ir::FunctionKind::NORMAL}; + + std::vector instructions; + std::vector blocks; + std::vector objects; + std::vector structures; + + uint32_t entry_block_index{0}; + uint32_t body_scope_index{UINT32_MAX}; // FUNCTION_SCOPE structure + std::vector rpo_block_order; +}; + +// --------------------------------------------------------------------------- +// IRGenerator: builds IR from a pasta::FunctionDecl by walking the PASTA AST +// directly. Builds a statement-level CFG (no Clang CFG dependency). +// Expressions are kept as nested instruction trees within blocks. +// --------------------------------------------------------------------------- + +class IRGenerator { + public: + IRGenerator(const pasta::AST &ast, const EntityMapper &em); + + std::optional Generate(const pasta::FunctionDecl &func); + std::optional GenerateGlobalInit(const pasta::VarDecl &var); + + private: + const pasta::AST &ast_; + const EntityMapper &em_; + clang::ASTContext &ctx_; + + // Cached entity IDs for built-in types (size_t, ptrdiff_t). + mx::RawEntityId size_type_eid_{mx::kInvalidEntityId}; + uint8_t size_type_width_{64}; + mx::RawEntityId ptrdiff_type_eid_{mx::kInvalidEntityId}; + uint8_t ptrdiff_type_width_{64}; + + FunctionIR func_; + uint32_t current_block_index_{0}; + uint32_t next_obj_index_{0}; + std::unordered_map entity_to_object_; + std::unordered_map object_to_alloca_; // obj_idx → alloca inst idx + std::unordered_set address_taken_; + + // Break/continue targets: maps source entity ID of the enclosing + // loop/switch to its exit (break) and continue-target blocks. + struct LoopContext { + uint32_t break_block; // where break goes + uint32_t continue_block; // where continue goes (loops only) + uint32_t structure_index; // structure index of the loop/switch + bool is_switch; // true = switch (break goes here, continue goes to enclosing loop) + }; + std::vector loop_stack_; + + // Structure stack for nesting. + uint32_t current_structure_index_{UINT32_MAX}; + std::vector structure_stack_; + + // Goto label targets: maps label name to block index. + // Forward gotos create the block on first reference. + std::unordered_map label_blocks_; + + // Maps case/default statement entity IDs to their block indices, + // so fallthrough can branch to the right block. + std::unordered_map case_blocks_; + + // Goto compensation: records pending gotos that need scope transitions. + struct PendingGoto { + uint32_t goto_inst_idx; // index of the GOTO instruction + uint32_t source_block_idx; // block containing the goto + uint32_t target_block_idx; // label block + uint32_t source_structure_idx; // structure at goto site + }; + std::vector pending_gotos_; + + // Maps label block index to the structure index active when label was emitted. + std::unordered_map label_structure_; + + // Expression scope for call argument/return allocas. + // UINT32_MAX means no active expression scope. + uint32_t expression_scope_index_{UINT32_MAX}; + + // --- Structure management --- + uint32_t PushStructure(mx::ir::StructureKind kind, + mx::RawEntityId source_eid = mx::kInvalidEntityId); + void PopStructure(); + void AssociateBlockWithStructure(uint32_t block_idx); + void AssociateObjectWithScope(uint32_t obj_idx); + + // Emit EXIT_SCOPE for all enclosing scopes up to (but not including) + // the scope at stop_structure_index. Used by break/continue/return/goto. + void EmitScopeExits(uint32_t stop_structure_index); + + // --- Block management --- + uint32_t NewBlock(mx::ir::BlockKind kind = mx::ir::BlockKind::GENERIC); + void SwitchToBlock(uint32_t block_idx); + void AddEdge(uint32_t from, uint32_t to); + + // --- Branch helpers (reduce boilerplate) --- + // EmitBranch emits an IMPLICIT_GOTO (structural edge). + uint32_t EmitBranch(uint32_t target_block, + mx::RawEntityId source_eid = mx::kInvalidEntityId); + uint32_t EmitBranchWithOpCode(mx::ir::OpCode opcode, uint32_t target_block, + mx::RawEntityId source_eid = mx::kInvalidEntityId); + uint32_t EmitCondBranch(uint32_t cond_idx, uint32_t true_block, + uint32_t false_block, + mx::RawEntityId source_eid = mx::kInvalidEntityId); + + // --- Load from lvalue helper --- + uint32_t EmitLoadFromLValue(const pasta::Expr &e); + + // --- Object management --- + uint32_t MakeObject(mx::ir::ObjectKind kind, + const pasta::Decl *decl = nullptr); + uint32_t GetOrMakeObject(const pasta::Decl &decl); + + // --- Instruction emission --- + // Emits an instruction into the flat list. Does NOT add it as a top-level + // instruction in the current block -- that happens only for statement-level + // roots. Sub-expressions are linked via operand_indices and + // parent_instruction_index. + uint32_t EmitInstruction(InstructionIR inst); + + // Emit a top-level instruction (added to the current block's root list). + uint32_t EmitTopLevel(InstructionIR inst); + + // Set parent_instruction_index on all operands of inst at `inst_idx`. + void SetOperandParents(uint32_t inst_idx); + + // --- Statement emission (builds the CFG) --- + void EmitBody(const pasta::Stmt &body); + void EmitStmt(const pasta::Stmt &s); + void EmitIfStmt(const pasta::Stmt &s); + void EmitWhileStmt(const pasta::Stmt &s); + void EmitDoStmt(const pasta::Stmt &s); + void EmitForStmt(const pasta::Stmt &s); + void EmitSwitchStmt(const pasta::Stmt &s); + void EmitReturnStmt(const pasta::Stmt &s); + void EmitDeclStmt(const pasta::Stmt &s); + void EmitBreakStmt(const pasta::Stmt &s); + void EmitContinueStmt(const pasta::Stmt &s); + void EmitGotoStmt(const pasta::Stmt &s); + void EmitLabelStmt(const pasta::Stmt &s); + + // --- Expression scope for calls --- + // Ensures an EXPRESSION_SCOPE exists for the current full-expression. + // Returns the structure index. Pushes one if not already active. + uint32_t EnsureExpressionScope(mx::RawEntityId source_eid); + // Pop the expression scope (called at top-level expression boundaries). + void PopExpressionScope(); + // Check if an expression contains any function calls. + bool ContainsCall(const pasta::Expr &e); + // True if the current block already has a terminator. + bool CurrentBlockTerminated() const; + // Switch to a new dead block (after break/return/goto/continue). + void SwitchToDeadBlock(); + + // --- Initializer emission (decomposes aggregates into element stores) --- + void EmitInitializer(uint32_t dest_addr_idx, const pasta::Expr &init, + mx::RawEntityId source_eid); + + // --- Expression emission (builds nested instruction trees) --- + uint32_t EmitRValue(const pasta::Expr &e); + uint32_t EmitLValue(const pasta::Expr &e); + + // --- Conditionally-executed flag propagation --- + void MarkConditionallyExecuted(uint32_t inst_idx); + + // --- Entity ID helpers --- + mx::RawEntityId EntityIdOf(const pasta::Stmt &s); + mx::RawEntityId EntityIdOf(const pasta::Decl &d); + mx::RawEntityId TypeEntityIdOf(const pasta::Type &t); + + // --- Type helpers --- + std::optional TypeSizeBytes(const pasta::Type &t); + std::optional TypeAlignBytes(const pasta::Type &t); + // Target's size_t / pointer width in bits. + uint8_t SizeTypeWidth() const; + // Emit a CONST instruction holding a size_t value (target-width unsigned). + uint32_t EmitSizeConst(uint64_t val, + mx::RawEntityId source_eid = mx::kInvalidEntityId); + mx::ir::MemOp DetermineMemOp(bool is_store, bool is_atomic, + unsigned size_bytes, bool is_float = false); + + // --- Pre-scan --- + void ScanAddressTaken(const pasta::Stmt &s); + void EmitEntryBlockAllocas(const pasta::Stmt &body); + + // --- Post-processing --- + void InsertGotoCompensationBlocks(); + void ComputeDominators(); + void ComputeRPO(); + void VerifyBlocks(); +}; + +} // namespace ir +} // namespace indexer diff --git a/bin/Index/IndexCompileJob.cpp b/bin/Index/IndexCompileJob.cpp index a9828f3b7..cc88f9782 100644 --- a/bin/Index/IndexCompileJob.cpp +++ b/bin/Index/IndexCompileJob.cpp @@ -3212,6 +3212,21 @@ void FragmentCollector::PersistParsedFragments(void) { fragment_ids.push_back(pf->fragment_id); // NOTE(pag): To debug these, you should set a breakpoint on `__cxa_throw`. + } catch (const std::exception &ex) { + pf->has_error = true; + + if (!pf->top_level_decls.empty()) { + const pasta::Decl &leader_decl = pf->top_level_decls.front(); + LOG(ERROR) + << "Persisting fragment" + << PrefixedLocation(leader_decl, " at or near ") + << " on main job file " << main_file_path + << " triggered exception: " << ex.what(); + } else { + LOG(ERROR) + << "Persisting fragment on main job file " << main_file_path + << " triggered exception: " << ex.what(); + } } catch (...) { pf->has_error = true; @@ -3221,11 +3236,11 @@ void FragmentCollector::PersistParsedFragments(void) { << "Persisting fragment" << PrefixedLocation(leader_decl, " at or near ") << " on main job file " << main_file_path - << " triggered exception"; + << " triggered unknown exception"; } else { LOG(ERROR) << "Persisting fragment on main job file " << main_file_path - << " triggered exception"; + << " triggered unknown exception"; } continue; } diff --git a/bin/Index/Persist.cpp b/bin/Index/Persist.cpp index 8cb6fd35e..2437f06b6 100644 --- a/bin/Index/Persist.cpp +++ b/bin/Index/Persist.cpp @@ -4,6 +4,7 @@ // the LICENSE file found in the root directory of this source tree. #include "Context.h" +#include "SerializeIR.h" #include #include @@ -965,8 +966,16 @@ void GlobalIndexingState::PersistFragment( // filling `pf.macros_to_serialize`, so in order to serialize the // index information about macros, we need to do it after calling // `PersistTokenTree`. + // Generate IR BEFORE serializing ASTs so the reverse map (AST entity → + // IR instruction entity) is available during AST serialization. + auto ir_functions = GenerateIR(ast, pf, pf.em, ir_progress); + + // Serialize AST entities (now with IR instruction references). SerializePendingFragment(fb, database, pf); + // Serialize the IR into the fragment. + SerializeIR(ir_functions, pf, em, fb); + PersistTokenContexts(pf, fb); LinkEntitiesAcrossFragments(database, pf, mangler); LinkExternalReferencesInFragment(database, pf); diff --git a/bin/Index/Serialize.cpp b/bin/Index/Serialize.cpp index efabc6035..6c2f00d2a 100644 --- a/bin/Index/Serialize.cpp +++ b/bin/Index/Serialize.cpp @@ -5445,117 +5445,118 @@ void SerializeStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::S (void) pf; b.setVal0(es.ParentDeclId(e)); b.setVal1(es.ParentStmtId(e)); - if (auto r2 = ReferencedDecl(e)) { - b.setVal2(es.EntityId(r2.value())); + b.setVal2(es.IREntityId(e)); + if (auto r3 = ReferencedDecl(e)) { + b.setVal3(es.EntityId(r3.value())); } - b.setVal3(es.EntityId(e.IgnoreContainers())); + b.setVal4(es.EntityId(e.IgnoreContainers())); do { - auto v4 = e.Children(); - auto sv4 = b.initVal4(static_cast(v4.size())); - auto i4 = 0u; - for (const auto &e4 : v4) { - sv4.set(i4, es.EntityId(e4)); - ++i4; + auto v5 = e.Children(); + auto sv5 = b.initVal5(static_cast(v5.size())); + auto i5 = 0u; + for (const auto &e5 : v5) { + sv5.set(i5, es.EntityId(e5)); + ++i5; } } while (false); - auto p5 = es.EntityIds(e.Tokens()); - b.setVal5(p5.first); - b.setVal6(p5.second); - b.setVal7(static_cast(mx::FromPasta(e.Kind()))); - b.setVal8(es.EntityId(e.StripLabelLikeStatements())); + auto p6 = es.EntityIds(e.Tokens()); + b.setVal6(p6.first); + b.setVal7(p6.second); + b.setVal8(static_cast(mx::FromPasta(e.Kind()))); + b.setVal9(es.EntityId(e.StripLabelLikeStatements())); } void SerializeSEHTryStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SEHTryStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.ExceptHandler())); - b.setVal10(es.EntityId(e.FinallyHandler())); - b.setVal11(es.EntityId(e.Handler())); - b.setVal12(e.IsCXXTry()); - b.setVal13(es.EntityId(e.TryBlock())); - auto et14 = es.EntityId(e.TryToken()); - b.setVal14(et14); + b.setVal10(es.EntityId(e.ExceptHandler())); + b.setVal11(es.EntityId(e.FinallyHandler())); + b.setVal12(es.EntityId(e.Handler())); + b.setVal13(e.IsCXXTry()); + b.setVal14(es.EntityId(e.TryBlock())); + auto et15 = es.EntityId(e.TryToken()); + b.setVal15(et15); } void SerializeSEHLeaveStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SEHLeaveStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.LeaveToken()); - b.setVal9(et9); + auto et10 = es.EntityId(e.LeaveToken()); + b.setVal10(et10); } void SerializeSEHFinallyStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SEHFinallyStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Block())); - auto et10 = es.EntityId(e.FinallyToken()); - b.setVal10(et10); + b.setVal10(es.EntityId(e.Block())); + auto et11 = es.EntityId(e.FinallyToken()); + b.setVal11(et11); } void SerializeSEHExceptStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SEHExceptStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Block())); - auto et10 = es.EntityId(e.ExceptToken()); - b.setVal10(et10); - b.setVal11(es.EntityId(e.FilterExpression())); + b.setVal10(es.EntityId(e.Block())); + auto et11 = es.EntityId(e.ExceptToken()); + b.setVal11(et11); + b.setVal12(es.EntityId(e.FilterExpression())); } void SerializeReturnStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ReturnStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto v9 = e.NRVOCandidate(); - if (v9) { - auto id9 = es.EntityId(v9.value()); - b.setVal9(id9); - } else { - b.setVal9(mx::kInvalidEntityId); - } - auto v10 = e.ReturnValue(); + auto v10 = e.NRVOCandidate(); if (v10) { auto id10 = es.EntityId(v10.value()); b.setVal10(id10); } else { b.setVal10(mx::kInvalidEntityId); } - auto et11 = es.EntityId(e.ReturnToken()); - b.setVal11(et11); + auto v11 = e.ReturnValue(); + if (v11) { + auto id11 = es.EntityId(v11.value()); + b.setVal11(id11); + } else { + b.setVal11(mx::kInvalidEntityId); + } + auto et12 = es.EntityId(e.ReturnToken()); + b.setVal12(et12); } void SerializeObjCForCollectionStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCForCollectionStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Body())); - b.setVal10(es.EntityId(e.Collection())); - b.setVal11(es.EntityId(e.Element())); - auto et13 = es.EntityId(e.ForToken()); - b.setVal13(et13); - auto et14 = es.EntityId(e.RParenToken()); + b.setVal10(es.EntityId(e.Body())); + b.setVal11(es.EntityId(e.Collection())); + b.setVal12(es.EntityId(e.Element())); + auto et14 = es.EntityId(e.ForToken()); b.setVal14(et14); + auto et15 = es.EntityId(e.RParenToken()); + b.setVal15(et15); } void SerializeObjCAutoreleasePoolStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCAutoreleasePoolStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.AtToken()); - b.setVal9(et9); - b.setVal10(es.EntityId(e.SubStatement())); + auto et10 = es.EntityId(e.AtToken()); + b.setVal10(et10); + b.setVal11(es.EntityId(e.SubStatement())); } void SerializeObjCAtTryStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCAtTryStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.AtTryToken()); - b.setVal9(et9); - b.setVal10(es.EntityId(e.FinallyStatement())); - b.setVal11(es.EntityId(e.TryBody())); + auto et10 = es.EntityId(e.AtTryToken()); + b.setVal10(et10); + b.setVal11(es.EntityId(e.FinallyStatement())); + b.setVal12(es.EntityId(e.TryBody())); do { - auto v15 = e.CatchStatements(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.CatchStatements(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -5563,49 +5564,49 @@ void SerializeObjCAtTryStmt(const PendingFragment &pf, const EntityMapper &es, m void SerializeObjCAtThrowStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCAtThrowStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.ThrowExpression())); - auto et10 = es.EntityId(e.ThrowToken()); - b.setVal10(et10); + b.setVal10(es.EntityId(e.ThrowExpression())); + auto et11 = es.EntityId(e.ThrowToken()); + b.setVal11(et11); } void SerializeObjCAtSynchronizedStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCAtSynchronizedStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.AtSynchronizedToken()); - b.setVal9(et9); - b.setVal10(es.EntityId(e.SynchBody())); - b.setVal11(es.EntityId(e.SynchExpression())); + auto et10 = es.EntityId(e.AtSynchronizedToken()); + b.setVal10(et10); + b.setVal11(es.EntityId(e.SynchBody())); + b.setVal12(es.EntityId(e.SynchExpression())); } void SerializeObjCAtFinallyStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCAtFinallyStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.AtFinallyToken()); - b.setVal9(et9); - b.setVal10(es.EntityId(e.FinallyBody())); + auto et10 = es.EntityId(e.AtFinallyToken()); + b.setVal10(et10); + b.setVal11(es.EntityId(e.FinallyBody())); } void SerializeObjCAtCatchStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCAtCatchStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.AtCatchToken()); - b.setVal9(et9); - b.setVal10(es.EntityId(e.CatchBody())); - b.setVal11(es.EntityId(e.CatchParameterDeclaration())); - auto et13 = es.EntityId(e.RParenToken()); - b.setVal13(et13); - b.setVal12(e.HasEllipsis()); + auto et10 = es.EntityId(e.AtCatchToken()); + b.setVal10(et10); + b.setVal11(es.EntityId(e.CatchBody())); + b.setVal12(es.EntityId(e.CatchParameterDeclaration())); + auto et14 = es.EntityId(e.RParenToken()); + b.setVal14(et14); + b.setVal13(e.HasEllipsis()); } void SerializeOMPExecutableDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPExecutableDirective &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.AssociatedStatement())); - b.setVal10(es.EntityId(e.InnermostCapturedStatement())); - b.setVal11(es.EntityId(e.RawStatement())); - b.setVal13(es.EntityId(e.StructuredBlock())); - b.setVal12(e.HasAssociatedStatement()); - b.setVal16(e.IsStandaloneDirective()); + b.setVal10(es.EntityId(e.AssociatedStatement())); + b.setVal11(es.EntityId(e.InnermostCapturedStatement())); + b.setVal12(es.EntityId(e.RawStatement())); + b.setVal14(es.EntityId(e.StructuredBlock())); + b.setVal13(e.HasAssociatedStatement()); + b.setVal17(e.IsStandaloneDirective()); } void SerializeOMPErrorDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPErrorDirective &e, const TokenTree *) { @@ -5616,8 +5617,8 @@ void SerializeOMPErrorDirective(const PendingFragment &pf, const EntityMapper &e void SerializeOMPDispatchDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPDispatchDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - auto et14 = es.EntityId(e.TargetCallToken()); - b.setVal14(et14); + auto et15 = es.EntityId(e.TargetCallToken()); + b.setVal15(et15); } void SerializeOMPDepobjDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPDepobjDirective &e, const TokenTree *) { @@ -5648,16 +5649,16 @@ void SerializeOMPBarrierDirective(const PendingFragment &pf, const EntityMapper void SerializeOMPAtomicDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPAtomicDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.ConditionExpression())); - b.setVal17(es.EntityId(e.D())); - b.setVal18(es.EntityId(e.Expression())); - b.setVal19(es.EntityId(e.R())); - b.setVal20(es.EntityId(e.UpdateExpression())); - b.setVal21(es.EntityId(e.V())); - b.setVal22(es.EntityId(e.X())); - b.setVal23(e.IsFailOnly()); - b.setVal24(e.IsPostfixUpdate()); - b.setVal25(e.IsXLHSInRHSPart()); + b.setVal15(es.EntityId(e.ConditionExpression())); + b.setVal18(es.EntityId(e.D())); + b.setVal19(es.EntityId(e.Expression())); + b.setVal20(es.EntityId(e.R())); + b.setVal21(es.EntityId(e.UpdateExpression())); + b.setVal22(es.EntityId(e.V())); + b.setVal23(es.EntityId(e.X())); + b.setVal24(e.IsFailOnly()); + b.setVal25(e.IsPostfixUpdate()); + b.setVal26(e.IsXLHSInRHSPart()); } void SerializeOMPTeamsDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTeamsDirective &e, const TokenTree *) { @@ -5678,13 +5679,13 @@ void SerializeOMPTaskwaitDirective(const PendingFragment &pf, const EntityMapper void SerializeOMPTaskgroupDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTaskgroupDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.ReductionReference())); + b.setVal15(es.EntityId(e.ReductionReference())); } void SerializeOMPTaskDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTaskDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal23(e.HasCancel()); + b.setVal24(e.HasCancel()); } void SerializeOMPTargetUpdateDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTargetUpdateDirective &e, const TokenTree *) { @@ -5700,8 +5701,8 @@ void SerializeOMPTargetTeamsDirective(const PendingFragment &pf, const EntityMap void SerializeOMPTargetParallelDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTargetParallelDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal15(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPTargetExitDataDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTargetExitDataDirective &e, const TokenTree *) { @@ -5732,14 +5733,14 @@ void SerializeOMPSingleDirective(const PendingFragment &pf, const EntityMapper & void SerializeOMPSectionsDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPSectionsDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal15(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPSectionDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPSectionDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal23(e.HasCancel()); + b.setVal24(e.HasCancel()); } void SerializeOMPScopeDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPScopeDirective &e, const TokenTree *) { @@ -5755,27 +5756,27 @@ void SerializeOMPScanDirective(const PendingFragment &pf, const EntityMapper &es void SerializeOMPParallelSectionsDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelSectionsDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal15(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPParallelMasterDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelMasterDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal15(es.EntityId(e.TaskReductionReferenceExpression())); } void SerializeOMPParallelMaskedDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelMaskedDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal15(es.EntityId(e.TaskReductionReferenceExpression())); } void SerializeOMPParallelDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal15(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPOrderedDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPOrderedDirective &e, const TokenTree *) { @@ -5786,7 +5787,7 @@ void SerializeOMPOrderedDirective(const PendingFragment &pf, const EntityMapper void SerializeOMPMetaDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPMetaDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.IfStatement())); + b.setVal15(es.EntityId(e.IfStatement())); } void SerializeOMPMasterDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPMasterDirective &e, const TokenTree *) { @@ -5802,14 +5803,14 @@ void SerializeOMPMaskedDirective(const PendingFragment &pf, const EntityMapper & void SerializeOMPLoopBasedDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPLoopBasedDirective &e, const TokenTree *) { (void) pf; SerializeOMPExecutableDirective(pf, es, b, e, nullptr); - b.setVal26(e.LoopsNumber()); + b.setVal27(e.LoopsNumber()); } void SerializeOMPLoopTransformationDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPLoopTransformationDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopBasedDirective(pf, es, b, e, nullptr); - b.setVal14(es.EntityId(e.PreInitializers())); - b.setVal17(es.EntityId(e.TransformedStatement())); + b.setVal15(es.EntityId(e.PreInitializers())); + b.setVal18(es.EntityId(e.TransformedStatement())); } void SerializeOMPUnrollDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPUnrollDirective &e, const TokenTree *) { @@ -5826,25 +5827,16 @@ void SerializeOMPLoopDirective(const PendingFragment &pf, const EntityMapper &es (void) pf; SerializeOMPLoopBasedDirective(pf, es, b, e, nullptr); do { - auto v15 = e.Counters(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; - } - } while (false); - do { - auto v27 = e.DependentCounters(); - auto sv27 = b.initVal27(static_cast(v27.size())); - auto i27 = 0u; - for (const auto &e27 : v27) { - sv27.set(i27, es.EntityId(e27)); - ++i27; + auto v16 = e.Counters(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); do { - auto v28 = e.DependentInitializers(); + auto v28 = e.DependentCounters(); auto sv28 = b.initVal28(static_cast(v28.size())); auto i28 = 0u; for (const auto &e28 : v28) { @@ -5853,7 +5845,7 @@ void SerializeOMPLoopDirective(const PendingFragment &pf, const EntityMapper &es } } while (false); do { - auto v29 = e.Finals(); + auto v29 = e.DependentInitializers(); auto sv29 = b.initVal29(static_cast(v29.size())); auto i29 = 0u; for (const auto &e29 : v29) { @@ -5862,7 +5854,7 @@ void SerializeOMPLoopDirective(const PendingFragment &pf, const EntityMapper &es } } while (false); do { - auto v30 = e.FinalsConditions(); + auto v30 = e.Finals(); auto sv30 = b.initVal30(static_cast(v30.size())); auto i30 = 0u; for (const auto &e30 : v30) { @@ -5870,46 +5862,46 @@ void SerializeOMPLoopDirective(const PendingFragment &pf, const EntityMapper &es ++i30; } } while (false); - b.setVal14(es.EntityId(e.Body())); - b.setVal17(es.EntityId(e.CalculateLastIteration())); - b.setVal18(es.EntityId(e.CombinedCondition())); - b.setVal19(es.EntityId(e.CombinedDistanceCondition())); - b.setVal20(es.EntityId(e.CombinedEnsureUpperBound())); - b.setVal21(es.EntityId(e.CombinedInitializer())); - b.setVal22(es.EntityId(e.CombinedLowerBoundVariable())); - b.setVal31(es.EntityId(e.CombinedNextLowerBound())); - b.setVal32(es.EntityId(e.CombinedNextUpperBound())); - b.setVal33(es.EntityId(e.CombinedParallelForInDistanceCondition())); - b.setVal34(es.EntityId(e.CombinedUpperBoundVariable())); - b.setVal35(es.EntityId(e.Condition())); - b.setVal36(es.EntityId(e.DistanceIncrement())); - b.setVal37(es.EntityId(e.EnsureUpperBound())); - b.setVal38(es.EntityId(e.Increment())); - b.setVal39(es.EntityId(e.Initializer())); - b.setVal40(es.EntityId(e.IsLastIterationVariable())); - b.setVal41(es.EntityId(e.IterationVariable())); - b.setVal42(es.EntityId(e.LastIteration())); - b.setVal43(es.EntityId(e.LowerBoundVariable())); - b.setVal44(es.EntityId(e.NextLowerBound())); - b.setVal45(es.EntityId(e.NextUpperBound())); - b.setVal46(es.EntityId(e.PreCondition())); - b.setVal47(es.EntityId(e.PreInitializers())); - b.setVal48(es.EntityId(e.PrevEnsureUpperBound())); - b.setVal49(es.EntityId(e.PrevLowerBoundVariable())); - b.setVal50(es.EntityId(e.PrevUpperBoundVariable())); - b.setVal51(es.EntityId(e.StrideVariable())); - b.setVal52(es.EntityId(e.UpperBoundVariable())); do { - auto v53 = e.Initializers(); - auto sv53 = b.initVal53(static_cast(v53.size())); - auto i53 = 0u; - for (const auto &e53 : v53) { - sv53.set(i53, es.EntityId(e53)); - ++i53; + auto v31 = e.FinalsConditions(); + auto sv31 = b.initVal31(static_cast(v31.size())); + auto i31 = 0u; + for (const auto &e31 : v31) { + sv31.set(i31, es.EntityId(e31)); + ++i31; } } while (false); + b.setVal15(es.EntityId(e.Body())); + b.setVal18(es.EntityId(e.CalculateLastIteration())); + b.setVal19(es.EntityId(e.CombinedCondition())); + b.setVal20(es.EntityId(e.CombinedDistanceCondition())); + b.setVal21(es.EntityId(e.CombinedEnsureUpperBound())); + b.setVal22(es.EntityId(e.CombinedInitializer())); + b.setVal23(es.EntityId(e.CombinedLowerBoundVariable())); + b.setVal32(es.EntityId(e.CombinedNextLowerBound())); + b.setVal33(es.EntityId(e.CombinedNextUpperBound())); + b.setVal34(es.EntityId(e.CombinedParallelForInDistanceCondition())); + b.setVal35(es.EntityId(e.CombinedUpperBoundVariable())); + b.setVal36(es.EntityId(e.Condition())); + b.setVal37(es.EntityId(e.DistanceIncrement())); + b.setVal38(es.EntityId(e.EnsureUpperBound())); + b.setVal39(es.EntityId(e.Increment())); + b.setVal40(es.EntityId(e.Initializer())); + b.setVal41(es.EntityId(e.IsLastIterationVariable())); + b.setVal42(es.EntityId(e.IterationVariable())); + b.setVal43(es.EntityId(e.LastIteration())); + b.setVal44(es.EntityId(e.LowerBoundVariable())); + b.setVal45(es.EntityId(e.NextLowerBound())); + b.setVal46(es.EntityId(e.NextUpperBound())); + b.setVal47(es.EntityId(e.PreCondition())); + b.setVal48(es.EntityId(e.PreInitializers())); + b.setVal49(es.EntityId(e.PrevEnsureUpperBound())); + b.setVal50(es.EntityId(e.PrevLowerBoundVariable())); + b.setVal51(es.EntityId(e.PrevUpperBoundVariable())); + b.setVal52(es.EntityId(e.StrideVariable())); + b.setVal53(es.EntityId(e.UpperBoundVariable())); do { - auto v54 = e.PrivateCounters(); + auto v54 = e.Initializers(); auto sv54 = b.initVal54(static_cast(v54.size())); auto i54 = 0u; for (const auto &e54 : v54) { @@ -5918,7 +5910,7 @@ void SerializeOMPLoopDirective(const PendingFragment &pf, const EntityMapper &es } } while (false); do { - auto v55 = e.Updates(); + auto v55 = e.PrivateCounters(); auto sv55 = b.initVal55(static_cast(v55.size())); auto i55 = 0u; for (const auto &e55 : v55) { @@ -5926,6 +5918,15 @@ void SerializeOMPLoopDirective(const PendingFragment &pf, const EntityMapper &es ++i55; } } while (false); + do { + auto v56 = e.Updates(); + auto sv56 = b.initVal56(static_cast(v56.size())); + auto i56 = 0u; + for (const auto &e56 : v56) { + sv56.set(i56, es.EntityId(e56)); + ++i56; + } + } while (false); } void SerializeOMPGenericLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPGenericLoopDirective &e, const TokenTree *) { @@ -5941,8 +5942,8 @@ void SerializeOMPForSimdDirective(const PendingFragment &pf, const EntityMapper void SerializeOMPForDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPForDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal56(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal57(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPDistributeSimdDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPDistributeSimdDirective &e, const TokenTree *) { @@ -5958,8 +5959,8 @@ void SerializeOMPDistributeParallelForSimdDirective(const PendingFragment &pf, c void SerializeOMPDistributeParallelForDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPDistributeParallelForDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal56(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal57(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPDistributeDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPDistributeDirective &e, const TokenTree *) { @@ -5985,8 +5986,8 @@ void SerializeOMPTeamsDistributeParallelForSimdDirective(const PendingFragment & void SerializeOMPTeamsDistributeParallelForDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTeamsDistributeParallelForDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal56(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal57(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPTeamsDistributeDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTeamsDistributeDirective &e, const TokenTree *) { @@ -6002,7 +6003,7 @@ void SerializeOMPTaskLoopSimdDirective(const PendingFragment &pf, const EntityMa void SerializeOMPTaskLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTaskLoopDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal23(e.HasCancel()); + b.setVal24(e.HasCancel()); } void SerializeOMPTargetTeamsGenericLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTargetTeamsGenericLoopDirective &e, const TokenTree *) { @@ -6023,8 +6024,8 @@ void SerializeOMPTargetTeamsDistributeParallelForSimdDirective(const PendingFrag void SerializeOMPTargetTeamsDistributeParallelForDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTargetTeamsDistributeParallelForDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal56(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal57(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPTargetTeamsDistributeDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTargetTeamsDistributeDirective &e, const TokenTree *) { @@ -6050,8 +6051,8 @@ void SerializeOMPTargetParallelForSimdDirective(const PendingFragment &pf, const void SerializeOMPTargetParallelForDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPTargetParallelForDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal56(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal57(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPSimdDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPSimdDirective &e, const TokenTree *) { @@ -6067,7 +6068,7 @@ void SerializeOMPParallelMasterTaskLoopSimdDirective(const PendingFragment &pf, void SerializeOMPParallelMasterTaskLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelMasterTaskLoopDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal23(e.HasCancel()); + b.setVal24(e.HasCancel()); } void SerializeOMPParallelMaskedTaskLoopSimdDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelMaskedTaskLoopSimdDirective &e, const TokenTree *) { @@ -6078,7 +6079,7 @@ void SerializeOMPParallelMaskedTaskLoopSimdDirective(const PendingFragment &pf, void SerializeOMPParallelMaskedTaskLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelMaskedTaskLoopDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal23(e.HasCancel()); + b.setVal24(e.HasCancel()); } void SerializeOMPParallelGenericLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelGenericLoopDirective &e, const TokenTree *) { @@ -6094,8 +6095,8 @@ void SerializeOMPParallelForSimdDirective(const PendingFragment &pf, const Entit void SerializeOMPParallelForDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPParallelForDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal56(es.EntityId(e.TaskReductionReferenceExpression())); - b.setVal23(e.HasCancel()); + b.setVal57(es.EntityId(e.TaskReductionReferenceExpression())); + b.setVal24(e.HasCancel()); } void SerializeOMPMasterTaskLoopSimdDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPMasterTaskLoopSimdDirective &e, const TokenTree *) { @@ -6106,7 +6107,7 @@ void SerializeOMPMasterTaskLoopSimdDirective(const PendingFragment &pf, const En void SerializeOMPMasterTaskLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPMasterTaskLoopDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal23(e.HasCancel()); + b.setVal24(e.HasCancel()); } void SerializeOMPMaskedTaskLoopSimdDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPMaskedTaskLoopSimdDirective &e, const TokenTree *) { @@ -6117,7 +6118,7 @@ void SerializeOMPMaskedTaskLoopSimdDirective(const PendingFragment &pf, const En void SerializeOMPMaskedTaskLoopDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPMaskedTaskLoopDirective &e, const TokenTree *) { (void) pf; SerializeOMPLoopDirective(pf, es, b, e, nullptr); - b.setVal23(e.HasCancel()); + b.setVal24(e.HasCancel()); } void SerializeOMPInteropDirective(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPInteropDirective &e, const TokenTree *) { @@ -6133,311 +6134,311 @@ void SerializeOMPFlushDirective(const PendingFragment &pf, const EntityMapper &e void SerializeOMPCanonicalLoop(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPCanonicalLoop &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.DistanceFunc())); - b.setVal10(es.EntityId(e.LoopStatement())); - b.setVal11(es.EntityId(e.LoopVariableFunc())); - b.setVal13(es.EntityId(e.LoopVariableReference())); + b.setVal10(es.EntityId(e.DistanceFunc())); + b.setVal11(es.EntityId(e.LoopStatement())); + b.setVal12(es.EntityId(e.LoopVariableFunc())); + b.setVal14(es.EntityId(e.LoopVariableReference())); } void SerializeNullStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::NullStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.SemiToken()); - b.setVal9(et9); - b.setVal12(e.HasLeadingEmptyMacro()); + auto et10 = es.EntityId(e.SemiToken()); + b.setVal10(et10); + b.setVal13(e.HasLeadingEmptyMacro()); } void SerializeMSDependentExistsStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MSDependentExistsStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.KeywordToken()); - b.setVal9(et9); - b.setVal10(es.EntityId(e.SubStatement())); - b.setVal12(e.IsIfExists()); - b.setVal16(e.IsIfNotExists()); + auto et10 = es.EntityId(e.KeywordToken()); + b.setVal10(et10); + b.setVal11(es.EntityId(e.SubStatement())); + b.setVal13(e.IsIfExists()); + b.setVal17(e.IsIfNotExists()); } void SerializeIndirectGotoStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::IndirectGotoStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto v9 = e.ConstantTarget(); - if (v9) { - auto id9 = es.EntityId(v9.value()); - b.setVal9(id9); + auto v10 = e.ConstantTarget(); + if (v10) { + auto id10 = es.EntityId(v10.value()); + b.setVal10(id10); } else { - b.setVal9(mx::kInvalidEntityId); + b.setVal10(mx::kInvalidEntityId); } - auto et10 = es.EntityId(e.GotoToken()); - b.setVal10(et10); - auto et11 = es.EntityId(e.StarToken()); + auto et11 = es.EntityId(e.GotoToken()); b.setVal11(et11); - b.setVal13(es.EntityId(e.Target())); + auto et12 = es.EntityId(e.StarToken()); + b.setVal12(et12); + b.setVal14(es.EntityId(e.Target())); } void SerializeIfStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::IfStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Condition())); - auto v10 = e.ConditionVariable(); - if (v10) { - auto id10 = es.EntityId(v10.value()); - b.setVal10(id10); - } else { - b.setVal10(mx::kInvalidEntityId); - } - auto v11 = e.ConditionVariableDeclarationStatement(); + b.setVal10(es.EntityId(e.Condition())); + auto v11 = e.ConditionVariable(); if (v11) { auto id11 = es.EntityId(v11.value()); b.setVal11(id11); } else { b.setVal11(mx::kInvalidEntityId); } - auto v13 = e.Else(); - if (v13) { - auto id13 = es.EntityId(v13.value()); - b.setVal13(id13); + auto v12 = e.ConditionVariableDeclarationStatement(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); } else { - b.setVal13(mx::kInvalidEntityId); + b.setVal12(mx::kInvalidEntityId); } - auto et14 = es.EntityId(e.ElseToken()); - b.setVal14(et14); - auto et17 = es.EntityId(e.IfToken()); - b.setVal17(et17); - auto v18 = e.Initializer(); - if (v18) { - auto id18 = es.EntityId(v18.value()); - b.setVal18(id18); + auto v14 = e.Else(); + if (v14) { + auto id14 = es.EntityId(v14.value()); + b.setVal14(id14); } else { - b.setVal18(mx::kInvalidEntityId); + b.setVal14(mx::kInvalidEntityId); } - auto et19 = es.EntityId(e.LParenToken()); - b.setVal19(et19); - auto v20 = e.NondiscardedCase(); - if (v20) { - auto id20 = es.EntityId(v20.value()); - b.setVal20(id20); + auto et15 = es.EntityId(e.ElseToken()); + b.setVal15(et15); + auto et18 = es.EntityId(e.IfToken()); + b.setVal18(et18); + auto v19 = e.Initializer(); + if (v19) { + auto id19 = es.EntityId(v19.value()); + b.setVal19(id19); } else { - b.setVal20(mx::kInvalidEntityId); + b.setVal19(mx::kInvalidEntityId); } - auto et21 = es.EntityId(e.RParenToken()); - b.setVal21(et21); - b.setVal57(static_cast(mx::FromPasta(e.StatementKind()))); - b.setVal22(es.EntityId(e.Then())); - b.setVal12(e.HasElseStorage()); - b.setVal16(e.HasInitializerStorage()); - b.setVal23(e.HasVariableStorage()); - b.setVal24(e.IsConsteval()); - b.setVal25(e.IsConstexpr()); - b.setVal58(e.IsNegatedConsteval()); - b.setVal59(e.IsNonNegatedConsteval()); - b.setVal60(e.IsObjCAvailabilityCheck()); + auto et20 = es.EntityId(e.LParenToken()); + b.setVal20(et20); + auto v21 = e.NondiscardedCase(); + if (v21) { + auto id21 = es.EntityId(v21.value()); + b.setVal21(id21); + } else { + b.setVal21(mx::kInvalidEntityId); + } + auto et22 = es.EntityId(e.RParenToken()); + b.setVal22(et22); + b.setVal58(static_cast(mx::FromPasta(e.StatementKind()))); + b.setVal23(es.EntityId(e.Then())); + b.setVal13(e.HasElseStorage()); + b.setVal17(e.HasInitializerStorage()); + b.setVal24(e.HasVariableStorage()); + b.setVal25(e.IsConsteval()); + b.setVal26(e.IsConstexpr()); + b.setVal59(e.IsNegatedConsteval()); + b.setVal60(e.IsNonNegatedConsteval()); + b.setVal61(e.IsObjCAvailabilityCheck()); } void SerializeGotoStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::GotoStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.GotoToken()); - b.setVal9(et9); - b.setVal10(es.EntityId(e.Label())); - auto et11 = es.EntityId(e.LabelToken()); - b.setVal11(et11); + auto et10 = es.EntityId(e.GotoToken()); + b.setVal10(et10); + b.setVal11(es.EntityId(e.Label())); + auto et12 = es.EntityId(e.LabelToken()); + b.setVal12(et12); } void SerializeForStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ForStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Body())); - auto v10 = e.Condition(); - if (v10) { - auto id10 = es.EntityId(v10.value()); - b.setVal10(id10); - } else { - b.setVal10(mx::kInvalidEntityId); - } - auto v11 = e.ConditionVariable(); + b.setVal10(es.EntityId(e.Body())); + auto v11 = e.Condition(); if (v11) { auto id11 = es.EntityId(v11.value()); b.setVal11(id11); } else { b.setVal11(mx::kInvalidEntityId); } - auto v13 = e.ConditionVariableDeclarationStatement(); - if (v13) { - auto id13 = es.EntityId(v13.value()); - b.setVal13(id13); + auto v12 = e.ConditionVariable(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); } else { - b.setVal13(mx::kInvalidEntityId); + b.setVal12(mx::kInvalidEntityId); } - auto et14 = es.EntityId(e.ForToken()); - b.setVal14(et14); - auto v17 = e.Increment(); - if (v17) { - auto id17 = es.EntityId(v17.value()); - b.setVal17(id17); + auto v14 = e.ConditionVariableDeclarationStatement(); + if (v14) { + auto id14 = es.EntityId(v14.value()); + b.setVal14(id14); } else { - b.setVal17(mx::kInvalidEntityId); + b.setVal14(mx::kInvalidEntityId); } - auto v18 = e.Initializer(); + auto et15 = es.EntityId(e.ForToken()); + b.setVal15(et15); + auto v18 = e.Increment(); if (v18) { auto id18 = es.EntityId(v18.value()); b.setVal18(id18); } else { b.setVal18(mx::kInvalidEntityId); } - auto et19 = es.EntityId(e.LParenToken()); - b.setVal19(et19); - auto et20 = es.EntityId(e.RParenToken()); + auto v19 = e.Initializer(); + if (v19) { + auto id19 = es.EntityId(v19.value()); + b.setVal19(id19); + } else { + b.setVal19(mx::kInvalidEntityId); + } + auto et20 = es.EntityId(e.LParenToken()); b.setVal20(et20); + auto et21 = es.EntityId(e.RParenToken()); + b.setVal21(et21); } void SerializeDoStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DoStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Body())); - b.setVal10(es.EntityId(e.Condition())); - auto et11 = es.EntityId(e.DoToken()); - b.setVal11(et11); - auto et13 = es.EntityId(e.RParenToken()); - b.setVal13(et13); - auto et14 = es.EntityId(e.WhileToken()); + b.setVal10(es.EntityId(e.Body())); + b.setVal11(es.EntityId(e.Condition())); + auto et12 = es.EntityId(e.DoToken()); + b.setVal12(et12); + auto et14 = es.EntityId(e.RParenToken()); b.setVal14(et14); + auto et15 = es.EntityId(e.WhileToken()); + b.setVal15(et15); } void SerializeDeclStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DeclStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); do { - auto v15 = e.Declarations(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Declarations(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto v9 = e.SingleDeclaration(); - if (v9) { - auto id9 = es.EntityId(v9.value()); - b.setVal9(id9); + auto v10 = e.SingleDeclaration(); + if (v10) { + auto id10 = es.EntityId(v10.value()); + b.setVal10(id10); } else { - b.setVal9(mx::kInvalidEntityId); + b.setVal10(mx::kInvalidEntityId); } - b.setVal12(e.IsSingleDeclaration()); + b.setVal13(e.IsSingleDeclaration()); } void SerializeCoroutineBodyStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CoroutineBodyStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); do { - auto v15 = e.ChildrenExclBody(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.ChildrenExclBody(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - b.setVal9(es.EntityId(e.Allocate())); - b.setVal10(es.EntityId(e.Body())); - b.setVal11(es.EntityId(e.Deallocate())); - b.setVal13(es.EntityId(e.ExceptionHandler())); - b.setVal14(es.EntityId(e.FallthroughHandler())); - b.setVal17(es.EntityId(e.FinalSuspendStatement())); - b.setVal18(es.EntityId(e.InitializerSuspendStatement())); + b.setVal10(es.EntityId(e.Allocate())); + b.setVal11(es.EntityId(e.Body())); + b.setVal12(es.EntityId(e.Deallocate())); + b.setVal14(es.EntityId(e.ExceptionHandler())); + b.setVal15(es.EntityId(e.FallthroughHandler())); + b.setVal18(es.EntityId(e.FinalSuspendStatement())); + b.setVal19(es.EntityId(e.InitializerSuspendStatement())); do { - auto v27 = e.ParameterMoves(); - auto sv27 = b.initVal27(static_cast(v27.size())); - auto i27 = 0u; - for (const auto &e27 : v27) { - sv27.set(i27, es.EntityId(e27)); - ++i27; + auto v28 = e.ParameterMoves(); + auto sv28 = b.initVal28(static_cast(v28.size())); + auto i28 = 0u; + for (const auto &e28 : v28) { + sv28.set(i28, es.EntityId(e28)); + ++i28; } } while (false); - b.setVal19(es.EntityId(e.PromiseDeclaration())); - b.setVal20(es.EntityId(e.PromiseDeclarationStatement())); - auto v21 = e.ResultDeclaration(); - if (v21) { - auto id21 = es.EntityId(v21.value()); - b.setVal21(id21); + b.setVal20(es.EntityId(e.PromiseDeclaration())); + b.setVal21(es.EntityId(e.PromiseDeclarationStatement())); + auto v22 = e.ResultDeclaration(); + if (v22) { + auto id22 = es.EntityId(v22.value()); + b.setVal22(id22); } else { - b.setVal21(mx::kInvalidEntityId); + b.setVal22(mx::kInvalidEntityId); } - b.setVal22(es.EntityId(e.ReturnStatement())); - auto v31 = e.ReturnStatementOnAllocFailure(); - if (v31) { - auto id31 = es.EntityId(v31.value()); - b.setVal31(id31); + b.setVal23(es.EntityId(e.ReturnStatement())); + auto v32 = e.ReturnStatementOnAllocFailure(); + if (v32) { + auto id32 = es.EntityId(v32.value()); + b.setVal32(id32); } else { - b.setVal31(mx::kInvalidEntityId); + b.setVal32(mx::kInvalidEntityId); } - b.setVal32(es.EntityId(e.ReturnValue())); - b.setVal33(es.EntityId(e.ReturnValueInitializer())); - b.setVal12(e.HasDependentPromiseType()); + b.setVal33(es.EntityId(e.ReturnValue())); + b.setVal34(es.EntityId(e.ReturnValueInitializer())); + b.setVal13(e.HasDependentPromiseType()); } void SerializeCoreturnStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CoreturnStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.KeywordToken()); - b.setVal9(et9); - auto v10 = e.Operand(); - if (v10) { - auto id10 = es.EntityId(v10.value()); - b.setVal10(id10); + auto et10 = es.EntityId(e.KeywordToken()); + b.setVal10(et10); + auto v11 = e.Operand(); + if (v11) { + auto id11 = es.EntityId(v11.value()); + b.setVal11(id11); } else { - b.setVal10(mx::kInvalidEntityId); + b.setVal11(mx::kInvalidEntityId); } - b.setVal11(es.EntityId(e.PromiseCall())); - b.setVal12(e.IsImplicit()); + b.setVal12(es.EntityId(e.PromiseCall())); + b.setVal13(e.IsImplicit()); } void SerializeContinueStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ContinueStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.ContinueToken()); - b.setVal9(et9); + auto et10 = es.EntityId(e.ContinueToken()); + b.setVal10(et10); } void SerializeCompoundStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CompoundStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.LeftBraceToken()); - b.setVal9(et9); - auto et10 = es.EntityId(e.RightBraceToken()); + auto et10 = es.EntityId(e.LeftBraceToken()); b.setVal10(et10); - auto v11 = e.StatementExpressionResult(); - if (v11) { - auto id11 = es.EntityId(v11.value()); - b.setVal11(id11); + auto et11 = es.EntityId(e.RightBraceToken()); + b.setVal11(et11); + auto v12 = e.StatementExpressionResult(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); } else { - b.setVal11(mx::kInvalidEntityId); + b.setVal12(mx::kInvalidEntityId); } - b.setVal12(e.HasStoredFPFeatures()); - b.setVal26(e.Size()); + b.setVal13(e.HasStoredFPFeatures()); + b.setVal27(e.Size()); } void SerializeCapturedStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CapturedStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.CapturedDeclaration())); - b.setVal10(es.EntityId(e.CapturedRecordDeclaration())); - b.setVal57(static_cast(mx::FromPasta(e.CapturedRegionKind()))); - b.setVal11(es.EntityId(e.CapturedStatement())); + b.setVal10(es.EntityId(e.CapturedDeclaration())); + b.setVal11(es.EntityId(e.CapturedRecordDeclaration())); + b.setVal58(static_cast(mx::FromPasta(e.CapturedRegionKind()))); + b.setVal12(es.EntityId(e.CapturedStatement())); } void SerializeCXXTryStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXTryStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.TryBlock())); - auto et10 = es.EntityId(e.TryToken()); - b.setVal10(et10); + b.setVal10(es.EntityId(e.TryBlock())); + auto et11 = es.EntityId(e.TryToken()); + b.setVal11(et11); do { - auto v15 = e.Handlers(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Handlers(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -6445,123 +6446,104 @@ void SerializeCXXTryStmt(const PendingFragment &pf, const EntityMapper &es, mx:: void SerializeCXXForRangeStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXForRangeStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto v9 = e.BeginStatement(); - if (v9) { - auto id9 = es.EntityId(v9.value()); - b.setVal9(id9); - } else { - b.setVal9(mx::kInvalidEntityId); - } - b.setVal10(es.EntityId(e.Body())); - auto et11 = es.EntityId(e.CoawaitToken()); - b.setVal11(et11); - auto et13 = es.EntityId(e.ColonToken()); - b.setVal13(et13); - auto v14 = e.Condition(); - if (v14) { - auto id14 = es.EntityId(v14.value()); - b.setVal14(id14); + auto v10 = e.BeginStatement(); + if (v10) { + auto id10 = es.EntityId(v10.value()); + b.setVal10(id10); } else { - b.setVal14(mx::kInvalidEntityId); + b.setVal10(mx::kInvalidEntityId); } - auto v17 = e.EndStatement(); - if (v17) { - auto id17 = es.EntityId(v17.value()); - b.setVal17(id17); + b.setVal11(es.EntityId(e.Body())); + auto et12 = es.EntityId(e.CoawaitToken()); + b.setVal12(et12); + auto et14 = es.EntityId(e.ColonToken()); + b.setVal14(et14); + auto v15 = e.Condition(); + if (v15) { + auto id15 = es.EntityId(v15.value()); + b.setVal15(id15); } else { - b.setVal17(mx::kInvalidEntityId); + b.setVal15(mx::kInvalidEntityId); } - auto et18 = es.EntityId(e.ForToken()); - b.setVal18(et18); - auto v19 = e.Increment(); - if (v19) { - auto id19 = es.EntityId(v19.value()); - b.setVal19(id19); + auto v18 = e.EndStatement(); + if (v18) { + auto id18 = es.EntityId(v18.value()); + b.setVal18(id18); } else { - b.setVal19(mx::kInvalidEntityId); + b.setVal18(mx::kInvalidEntityId); } - auto v20 = e.Initializer(); + auto et19 = es.EntityId(e.ForToken()); + b.setVal19(et19); + auto v20 = e.Increment(); if (v20) { auto id20 = es.EntityId(v20.value()); b.setVal20(id20); } else { b.setVal20(mx::kInvalidEntityId); } - b.setVal21(es.EntityId(e.LoopVariableStatement())); - b.setVal22(es.EntityId(e.LoopVariable())); - auto et31 = es.EntityId(e.RParenToken()); - b.setVal31(et31); - b.setVal32(es.EntityId(e.RangeInitializer())); - b.setVal33(es.EntityId(e.RangeStatement())); + auto v21 = e.Initializer(); + if (v21) { + auto id21 = es.EntityId(v21.value()); + b.setVal21(id21); + } else { + b.setVal21(mx::kInvalidEntityId); + } + b.setVal22(es.EntityId(e.LoopVariableStatement())); + b.setVal23(es.EntityId(e.LoopVariable())); + auto et32 = es.EntityId(e.RParenToken()); + b.setVal32(et32); + b.setVal33(es.EntityId(e.RangeInitializer())); + b.setVal34(es.EntityId(e.RangeStatement())); } void SerializeCXXCatchStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXCatchStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.CatchToken()); - b.setVal9(et9); - auto v10 = e.CaughtType(); - if (v10) { - auto id10 = es.EntityId(v10.value()); - b.setVal10(id10); - } else { - b.setVal10(mx::kInvalidEntityId); - } - auto v11 = e.ExceptionDeclaration(); + auto et10 = es.EntityId(e.CatchToken()); + b.setVal10(et10); + auto v11 = e.CaughtType(); if (v11) { auto id11 = es.EntityId(v11.value()); b.setVal11(id11); } else { b.setVal11(mx::kInvalidEntityId); } - b.setVal13(es.EntityId(e.HandlerBlock())); + auto v12 = e.ExceptionDeclaration(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); + } else { + b.setVal12(mx::kInvalidEntityId); + } + b.setVal14(es.EntityId(e.HandlerBlock())); } void SerializeBreakStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::BreakStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.BreakToken()); - b.setVal9(et9); + auto et10 = es.EntityId(e.BreakToken()); + b.setVal10(et10); } void SerializeAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::AsmStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal61(e.GenerateAssemblyString()); - auto et9 = es.EntityId(e.AssemblyToken()); - b.setVal9(et9); - do { - auto v15 = e.Inputs(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; - } - } while (false); - b.setVal12(e.IsSimple()); - b.setVal16(e.IsVolatile()); - do { - auto v27 = e.Outputs(); - auto sv27 = b.initVal27(static_cast(v27.size())); - auto i27 = 0u; - for (const auto &e27 : v27) { - sv27.set(i27, es.EntityId(e27)); - ++i27; - } - } while (false); + b.setVal62(e.GenerateAssemblyString()); + auto et10 = es.EntityId(e.AssemblyToken()); + b.setVal10(et10); do { - auto v62 = e.OutputConstraints(); - auto sv62 = b.initVal62(static_cast(v62.size())); - auto i62 = 0u; - for (const auto &e62 : v62) { - std::string se62(e62.data(), e62.size()); - sv62.set(i62, se62); - ++i62; + auto v16 = e.Inputs(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); + b.setVal13(e.IsSimple()); + b.setVal17(e.IsVolatile()); do { - auto v28 = e.OutputExpressions(); + auto v28 = e.Outputs(); auto sv28 = b.initVal28(static_cast(v28.size())); auto i28 = 0u; for (const auto &e28 : v28) { @@ -6570,7 +6552,7 @@ void SerializeAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast } } while (false); do { - auto v63 = e.InputConstraints(); + auto v63 = e.OutputConstraints(); auto sv63 = b.initVal63(static_cast(v63.size())); auto i63 = 0u; for (const auto &e63 : v63) { @@ -6580,7 +6562,7 @@ void SerializeAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast } } while (false); do { - auto v29 = e.InputExpressions(); + auto v29 = e.OutputExpressions(); auto sv29 = b.initVal29(static_cast(v29.size())); auto i29 = 0u; for (const auto &e29 : v29) { @@ -6589,7 +6571,7 @@ void SerializeAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast } } while (false); do { - auto v64 = e.Clobbers(); + auto v64 = e.InputConstraints(); auto sv64 = b.initVal64(static_cast(v64.size())); auto i64 = 0u; for (const auto &e64 : v64) { @@ -6598,13 +6580,17 @@ void SerializeAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast ++i64; } } while (false); -} - -void SerializeMSAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MSAsmStmt &e, const TokenTree *) { - (void) pf; - SerializeAsmStmt(pf, es, b, e, nullptr); do { - auto v65 = e.AllConstraints(); + auto v30 = e.InputExpressions(); + auto sv30 = b.initVal30(static_cast(v30.size())); + auto i30 = 0u; + for (const auto &e30 : v30) { + sv30.set(i30, es.EntityId(e30)); + ++i30; + } + } while (false); + do { + auto v65 = e.Clobbers(); auto sv65 = b.initVal65(static_cast(v65.size())); auto i65 = 0u; for (const auto &e65 : v65) { @@ -6613,60 +6599,56 @@ void SerializeMSAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::a ++i65; } } while (false); - do { - auto v30 = e.AllExpressions(); - auto sv30 = b.initVal30(static_cast(v30.size())); - auto i30 = 0u; - for (const auto &e30 : v30) { - sv30.set(i30, es.EntityId(e30)); - ++i30; - } - } while (false); - auto v66 = e.AssemblyString(); - std::string s66(v66.data(), v66.size()); - b.setVal66(s66); - auto et10 = es.EntityId(e.LBraceToken()); - b.setVal10(et10); - b.setVal23(e.HasBraces()); } -void SerializeGCCAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::GCCAsmStmt &e, const TokenTree *) { +void SerializeMSAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MSAsmStmt &e, const TokenTree *) { (void) pf; SerializeAsmStmt(pf, es, b, e, nullptr); - b.setVal10(es.EntityId(e.AssemblyString())); - auto et11 = es.EntityId(e.RParenToken()); - b.setVal11(et11); - b.setVal23(e.IsAssemblyGoto()); do { - auto v30 = e.Labels(); - auto sv30 = b.initVal30(static_cast(v30.size())); - auto i30 = 0u; - for (const auto &e30 : v30) { - sv30.set(i30, es.EntityId(e30)); - ++i30; + auto v66 = e.AllConstraints(); + auto sv66 = b.initVal66(static_cast(v66.size())); + auto i66 = 0u; + for (const auto &e66 : v66) { + std::string se66(e66.data(), e66.size()); + sv66.set(i66, se66); + ++i66; } } while (false); do { - auto v53 = e.OutputConstraintLiterals(); - auto sv53 = b.initVal53(static_cast(v53.size())); - auto i53 = 0u; - for (const auto &e53 : v53) { - sv53.set(i53, es.EntityId(e53)); - ++i53; + auto v31 = e.AllExpressions(); + auto sv31 = b.initVal31(static_cast(v31.size())); + auto i31 = 0u; + for (const auto &e31 : v31) { + sv31.set(i31, es.EntityId(e31)); + ++i31; } } while (false); + auto v67 = e.AssemblyString(); + std::string s67(v67.data(), v67.size()); + b.setVal67(s67); + auto et11 = es.EntityId(e.LBraceToken()); + b.setVal11(et11); + b.setVal24(e.HasBraces()); +} + +void SerializeGCCAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::GCCAsmStmt &e, const TokenTree *) { + (void) pf; + SerializeAsmStmt(pf, es, b, e, nullptr); + b.setVal11(es.EntityId(e.AssemblyString())); + auto et12 = es.EntityId(e.RParenToken()); + b.setVal12(et12); + b.setVal24(e.IsAssemblyGoto()); do { - auto v65 = e.OutputNames(); - auto sv65 = b.initVal65(static_cast(v65.size())); - auto i65 = 0u; - for (const auto &e65 : v65) { - std::string se65(e65.data(), e65.size()); - sv65.set(i65, se65); - ++i65; + auto v31 = e.Labels(); + auto sv31 = b.initVal31(static_cast(v31.size())); + auto i31 = 0u; + for (const auto &e31 : v31) { + sv31.set(i31, es.EntityId(e31)); + ++i31; } } while (false); do { - auto v54 = e.InputConstraintLiterals(); + auto v54 = e.OutputConstraintLiterals(); auto sv54 = b.initVal54(static_cast(v54.size())); auto i54 = 0u; for (const auto &e54 : v54) { @@ -6675,17 +6657,17 @@ void SerializeGCCAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx:: } } while (false); do { - auto v67 = e.InputNames(); - auto sv67 = b.initVal67(static_cast(v67.size())); - auto i67 = 0u; - for (const auto &e67 : v67) { - std::string se67(e67.data(), e67.size()); - sv67.set(i67, se67); - ++i67; + auto v66 = e.OutputNames(); + auto sv66 = b.initVal66(static_cast(v66.size())); + auto i66 = 0u; + for (const auto &e66 : v66) { + std::string se66(e66.data(), e66.size()); + sv66.set(i66, se66); + ++i66; } } while (false); do { - auto v55 = e.ClobberStringLiterals(); + auto v55 = e.InputConstraintLiterals(); auto sv55 = b.initVal55(static_cast(v55.size())); auto i55 = 0u; for (const auto &e55 : v55) { @@ -6694,195 +6676,214 @@ void SerializeGCCAsmStmt(const PendingFragment &pf, const EntityMapper &es, mx:: } } while (false); do { - auto v68 = e.LabelExpressions(); + auto v68 = e.InputNames(); auto sv68 = b.initVal68(static_cast(v68.size())); auto i68 = 0u; for (const auto &e68 : v68) { - sv68.set(i68, es.EntityId(e68)); + std::string se68(e68.data(), e68.size()); + sv68.set(i68, se68); ++i68; } } while (false); do { - auto v69 = e.LabelNames(); + auto v56 = e.ClobberStringLiterals(); + auto sv56 = b.initVal56(static_cast(v56.size())); + auto i56 = 0u; + for (const auto &e56 : v56) { + sv56.set(i56, es.EntityId(e56)); + ++i56; + } + } while (false); + do { + auto v69 = e.LabelExpressions(); auto sv69 = b.initVal69(static_cast(v69.size())); auto i69 = 0u; for (const auto &e69 : v69) { - std::string se69(e69.data(), e69.size()); - sv69.set(i69, se69); + sv69.set(i69, es.EntityId(e69)); ++i69; } } while (false); + do { + auto v70 = e.LabelNames(); + auto sv70 = b.initVal70(static_cast(v70.size())); + auto i70 = 0u; + for (const auto &e70 : v70) { + std::string se70(e70.data(), e70.size()); + sv70.set(i70, se70); + ++i70; + } + } while (false); } void SerializeWhileStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::WhileStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Body())); - b.setVal10(es.EntityId(e.Condition())); - auto v11 = e.ConditionVariable(); - if (v11) { - auto id11 = es.EntityId(v11.value()); - b.setVal11(id11); + b.setVal10(es.EntityId(e.Body())); + b.setVal11(es.EntityId(e.Condition())); + auto v12 = e.ConditionVariable(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); } else { - b.setVal11(mx::kInvalidEntityId); + b.setVal12(mx::kInvalidEntityId); } - auto v13 = e.ConditionVariableDeclarationStatement(); - if (v13) { - auto id13 = es.EntityId(v13.value()); - b.setVal13(id13); + auto v14 = e.ConditionVariableDeclarationStatement(); + if (v14) { + auto id14 = es.EntityId(v14.value()); + b.setVal14(id14); } else { - b.setVal13(mx::kInvalidEntityId); + b.setVal14(mx::kInvalidEntityId); } - auto et14 = es.EntityId(e.LParenToken()); - b.setVal14(et14); - auto et17 = es.EntityId(e.RParenToken()); - b.setVal17(et17); - auto et18 = es.EntityId(e.WhileToken()); + auto et15 = es.EntityId(e.LParenToken()); + b.setVal15(et15); + auto et18 = es.EntityId(e.RParenToken()); b.setVal18(et18); - b.setVal12(e.HasVariableStorage()); + auto et19 = es.EntityId(e.WhileToken()); + b.setVal19(et19); + b.setVal13(e.HasVariableStorage()); } void SerializeValueStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ValueStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto v9 = e.ExpressionStatement(); - if (v9) { - auto id9 = es.EntityId(v9.value()); - b.setVal9(id9); + auto v10 = e.ExpressionStatement(); + if (v10) { + auto id10 = es.EntityId(v10.value()); + b.setVal10(id10); } else { - b.setVal9(mx::kInvalidEntityId); + b.setVal10(mx::kInvalidEntityId); } } void SerializeLabelStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::LabelStmt &e, const TokenTree *) { (void) pf; SerializeValueStmt(pf, es, b, e, nullptr); - b.setVal10(es.EntityId(e.Declaration())); - auto et11 = es.EntityId(e.IdentifierToken()); - b.setVal11(et11); - auto v61 = e.Name(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - b.setVal13(es.EntityId(e.SubStatement())); - b.setVal12(e.IsSideEntry()); + b.setVal11(es.EntityId(e.Declaration())); + auto et12 = es.EntityId(e.IdentifierToken()); + b.setVal12(et12); + auto v62 = e.Name(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + b.setVal14(es.EntityId(e.SubStatement())); + b.setVal13(e.IsSideEntry()); } void SerializeExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::Expr &e, const TokenTree *) { (void) pf; SerializeValueStmt(pf, es, b, e, nullptr); - b.setVal10(es.EntityId(e.IgnoreCasts())); - b.setVal11(es.EntityId(e.IgnoreConversionOperatorSingleStep())); - b.setVal13(es.EntityId(e.IgnoreImplicitCasts())); - b.setVal14(es.EntityId(e.IgnoreImplicit())); - b.setVal17(es.EntityId(e.IgnoreImplicitAsWritten())); - b.setVal18(es.EntityId(e.IgnoreParenthesisBaseCasts())); - b.setVal19(es.EntityId(e.IgnoreParenthesisCasts())); - b.setVal20(es.EntityId(e.IgnoreParenthesisImplicitCasts())); - b.setVal21(es.EntityId(e.IgnoreParenthesisLValueCasts())); - auto v22 = e.IgnoreParenthesisNoopCasts(); - if (v22) { - auto id22 = es.EntityId(v22.value()); - b.setVal22(id22); + b.setVal11(es.EntityId(e.IgnoreCasts())); + b.setVal12(es.EntityId(e.IgnoreConversionOperatorSingleStep())); + b.setVal14(es.EntityId(e.IgnoreImplicitCasts())); + b.setVal15(es.EntityId(e.IgnoreImplicit())); + b.setVal18(es.EntityId(e.IgnoreImplicitAsWritten())); + b.setVal19(es.EntityId(e.IgnoreParenthesisBaseCasts())); + b.setVal20(es.EntityId(e.IgnoreParenthesisCasts())); + b.setVal21(es.EntityId(e.IgnoreParenthesisImplicitCasts())); + b.setVal22(es.EntityId(e.IgnoreParenthesisLValueCasts())); + auto v23 = e.IgnoreParenthesisNoopCasts(); + if (v23) { + auto id23 = es.EntityId(v23.value()); + b.setVal23(id23); } else { - b.setVal22(mx::kInvalidEntityId); + b.setVal23(mx::kInvalidEntityId); } - b.setVal31(es.EntityId(e.IgnoreParentheses())); - b.setVal32(es.EntityId(e.IgnoreUnlessSpelledInSource())); - b.setVal12(e.ContainsErrors()); - b.setVal16(e.ContainsUnexpandedParameterPack()); - auto et33 = es.EntityId(e.ExpressionToken()); - b.setVal33(et33); - auto v34 = e.ObjCProperty(); - if (v34) { - auto id34 = es.EntityId(v34.value()); - b.setVal34(id34); - } else { - b.setVal34(mx::kInvalidEntityId); - } - b.setVal57(static_cast(mx::FromPasta(e.ObjectKind()))); - auto v35 = e.ReferencedDeclarationOfCallee(); + b.setVal32(es.EntityId(e.IgnoreParentheses())); + b.setVal33(es.EntityId(e.IgnoreUnlessSpelledInSource())); + b.setVal13(e.ContainsErrors()); + b.setVal17(e.ContainsUnexpandedParameterPack()); + auto et34 = es.EntityId(e.ExpressionToken()); + b.setVal34(et34); + auto v35 = e.ObjCProperty(); if (v35) { auto id35 = es.EntityId(v35.value()); b.setVal35(id35); } else { b.setVal35(mx::kInvalidEntityId); } - auto v36 = e.SourceBitField(); + b.setVal58(static_cast(mx::FromPasta(e.ObjectKind()))); + auto v36 = e.ReferencedDeclarationOfCallee(); if (v36) { auto id36 = es.EntityId(v36.value()); b.setVal36(id36); } else { b.setVal36(mx::kInvalidEntityId); } - auto v37 = e.Type(); + auto v37 = e.SourceBitField(); if (v37) { auto id37 = es.EntityId(v37.value()); b.setVal37(id37); } else { b.setVal37(mx::kInvalidEntityId); } - b.setVal70(static_cast(mx::FromPasta(e.ValueKind()))); - b.setVal23(e.HasNonTrivialCall()); - b.setVal24(e.IsDefaultArgument()); - b.setVal25(e.IsGLValue()); - b.setVal58(e.IsImplicitCXXThis()); - b.setVal59(e.IsInstantiationDependent()); - b.setVal60(e.IsLValue()); - b.setVal71(e.IsOBJCGCCandidate()); - b.setVal72(e.IsObjCSelfExpression()); - b.setVal73(e.IsOrdinaryOrBitFieldObject()); - b.setVal74(e.IsPRValue()); - auto v75 = e.IsReadIfDiscardedInCPlusPlus11(); - if (v75) { - b.setVal75(static_cast(v75.value())); - b.setVal76(true); + auto v38 = e.Type(); + if (v38) { + auto id38 = es.EntityId(v38.value()); + b.setVal38(id38); } else { - b.setVal76(false); + b.setVal38(mx::kInvalidEntityId); } - b.setVal77(e.IsTypeDependent()); - b.setVal78(e.IsValueDependent()); - b.setVal79(e.IsXValue()); - b.setVal80(e.RefersToBitField()); - b.setVal81(e.RefersToGlobalRegisterVariable()); - b.setVal82(e.RefersToMatrixElement()); - b.setVal83(e.RefersToVectorElement()); + b.setVal71(static_cast(mx::FromPasta(e.ValueKind()))); + b.setVal24(e.HasNonTrivialCall()); + b.setVal25(e.IsDefaultArgument()); + b.setVal26(e.IsGLValue()); + b.setVal59(e.IsImplicitCXXThis()); + b.setVal60(e.IsInstantiationDependent()); + b.setVal61(e.IsLValue()); + b.setVal72(e.IsOBJCGCCandidate()); + b.setVal73(e.IsObjCSelfExpression()); + b.setVal74(e.IsOrdinaryOrBitFieldObject()); + b.setVal75(e.IsPRValue()); + auto v76 = e.IsReadIfDiscardedInCPlusPlus11(); + if (v76) { + b.setVal76(static_cast(v76.value())); + b.setVal77(true); + } else { + b.setVal77(false); + } + b.setVal78(e.IsTypeDependent()); + b.setVal79(e.IsValueDependent()); + b.setVal80(e.IsXValue()); + b.setVal81(e.RefersToBitField()); + b.setVal82(e.RefersToGlobalRegisterVariable()); + b.setVal83(e.RefersToMatrixElement()); + b.setVal84(e.RefersToVectorElement()); } void SerializeDesignatedInitUpdateExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DesignatedInitUpdateExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - b.setVal39(es.EntityId(e.Updater())); + b.setVal39(es.EntityId(e.Base())); + b.setVal40(es.EntityId(e.Updater())); } void SerializeDesignatedInitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DesignatedInitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.Designators(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Designators(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto p38 = es.EntityIds(e.DesignatorsTokens()); - b.setVal38(p38.first); - b.setVal39(p38.second); - auto et40 = es.EntityId(e.EqualOrColonToken()); - b.setVal40(et40); - b.setVal41(es.EntityId(e.Initializer())); - b.setVal84(e.IsDirectInitializer()); - b.setVal26(e.Size()); - b.setVal85(e.UsesGNUSyntax()); + auto p39 = es.EntityIds(e.DesignatorsTokens()); + b.setVal39(p39.first); + b.setVal40(p39.second); + auto et41 = es.EntityId(e.EqualOrColonToken()); + b.setVal41(et41); + b.setVal42(es.EntityId(e.Initializer())); + b.setVal85(e.IsDirectInitializer()); + b.setVal27(e.Size()); + b.setVal86(e.UsesGNUSyntax()); do { - auto v27 = e.SubExpressions(); - auto sv27 = b.initVal27(static_cast(v27.size())); - auto i27 = 0u; - for (const auto &e27 : v27) { - sv27.set(i27, es.EntityId(e27)); - ++i27; + auto v28 = e.SubExpressions(); + auto sv28 = b.initVal28(static_cast(v28.size())); + auto i28 = 0u; + for (const auto &e28 : v28) { + sv28.set(i28, es.EntityId(e28)); + ++i28; } } while (false); } @@ -6890,61 +6891,61 @@ void SerializeDesignatedInitExpr(const PendingFragment &pf, const EntityMapper & void SerializeDependentScopeDeclRefExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DependentScopeDeclRefExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.LAngleToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RAngleToken()); + auto et39 = es.EntityId(e.LAngleToken()); b.setVal39(et39); - auto et40 = es.EntityId(e.TemplateKeywordToken()); + auto et40 = es.EntityId(e.RAngleToken()); b.setVal40(et40); - b.setVal84(e.HasExplicitTemplateArguments()); - b.setVal85(e.HasTemplateKeyword()); + auto et41 = es.EntityId(e.TemplateKeywordToken()); + b.setVal41(et41); + b.setVal85(e.HasExplicitTemplateArguments()); + b.setVal86(e.HasTemplateKeyword()); } void SerializeDependentCoawaitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DependentCoawaitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.KeywordToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.Operand())); - b.setVal40(es.EntityId(e.OperatorCoawaitLookup())); + auto et39 = es.EntityId(e.KeywordToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.Operand())); + b.setVal41(es.EntityId(e.OperatorCoawaitLookup())); } void SerializeDeclRefExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DeclRefExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Declaration())); - auto et39 = es.EntityId(e.LAngleToken()); - b.setVal39(et39); - auto et40 = es.EntityId(e.RAngleToken()); + b.setVal39(es.EntityId(e.Declaration())); + auto et40 = es.EntityId(e.LAngleToken()); b.setVal40(et40); - auto et41 = es.EntityId(e.TemplateKeywordToken()); + auto et41 = es.EntityId(e.RAngleToken()); b.setVal41(et41); - b.setVal84(e.HadMultipleCandidates()); - b.setVal85(e.HasExplicitTemplateArguments()); - b.setVal86(e.HasQualifier()); - b.setVal87(e.IsCapturedByCopyInLambdaWithExplicitObjectParameter()); - b.setVal88(e.IsImmediateEscalating()); - b.setVal89(static_cast(mx::FromPasta(e.IsNonOdrUse()))); - b.setVal90(e.RefersToEnclosingVariableOrCapture()); + auto et42 = es.EntityId(e.TemplateKeywordToken()); + b.setVal42(et42); + b.setVal85(e.HadMultipleCandidates()); + b.setVal86(e.HasExplicitTemplateArguments()); + b.setVal87(e.HasQualifier()); + b.setVal88(e.IsCapturedByCopyInLambdaWithExplicitObjectParameter()); + b.setVal89(e.IsImmediateEscalating()); + b.setVal90(static_cast(mx::FromPasta(e.IsNonOdrUse()))); + b.setVal91(e.RefersToEnclosingVariableOrCapture()); } void SerializeCoroutineSuspendExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CoroutineSuspendExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.CommonExpression())); - auto et39 = es.EntityId(e.KeywordToken()); - b.setVal39(et39); - b.setVal40(es.EntityId(e.OpaqueValue())); - b.setVal41(es.EntityId(e.Operand())); - b.setVal42(es.EntityId(e.ReadyExpression())); - b.setVal43(es.EntityId(e.ResumeExpression())); - b.setVal44(es.EntityId(e.SuspendExpression())); + b.setVal39(es.EntityId(e.CommonExpression())); + auto et40 = es.EntityId(e.KeywordToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.OpaqueValue())); + b.setVal42(es.EntityId(e.Operand())); + b.setVal43(es.EntityId(e.ReadyExpression())); + b.setVal44(es.EntityId(e.ResumeExpression())); + b.setVal45(es.EntityId(e.SuspendExpression())); } void SerializeCoawaitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CoawaitExpr &e, const TokenTree *) { (void) pf; SerializeCoroutineSuspendExpr(pf, es, b, e, nullptr); - b.setVal84(e.IsImplicit()); + b.setVal85(e.IsImplicit()); } void SerializeCoyieldExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CoyieldExpr &e, const TokenTree *) { @@ -6955,126 +6956,126 @@ void SerializeCoyieldExpr(const PendingFragment &pf, const EntityMapper &es, mx: void SerializeConvertVectorExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ConvertVectorExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.BuiltinToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.BuiltinToken()); b.setVal39(et39); - b.setVal40(es.EntityId(e.SrcExpression())); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.SrcExpression())); } void SerializeConceptSpecializationExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ConceptSpecializationExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.ConceptNameToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.FoundDeclaration())); - b.setVal40(es.EntityId(e.NamedConcept())); - b.setVal41(es.EntityId(e.SpecializationDeclaration())); + auto et39 = es.EntityId(e.ConceptNameToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.FoundDeclaration())); + b.setVal41(es.EntityId(e.NamedConcept())); + b.setVal42(es.EntityId(e.SpecializationDeclaration())); do { - auto v15 = e.TemplateArguments(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.TemplateArguments(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto et42 = es.EntityId(e.TemplateKeywordToken()); - b.setVal42(et42); - b.setVal84(e.HasExplicitTemplateArguments()); + auto et43 = es.EntityId(e.TemplateKeywordToken()); + b.setVal43(et43); + b.setVal85(e.HasExplicitTemplateArguments()); } void SerializeCompoundLiteralExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CompoundLiteralExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Initializer())); - auto et39 = es.EntityId(e.LParenToken()); - b.setVal39(et39); - b.setVal84(e.IsFileScope()); + b.setVal39(es.EntityId(e.Initializer())); + auto et40 = es.EntityId(e.LParenToken()); + b.setVal40(et40); + b.setVal85(e.IsFileScope()); } void SerializeChooseExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ChooseExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.BuiltinToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.ChosenSubExpression())); - b.setVal40(es.EntityId(e.Condition())); - b.setVal41(es.EntityId(e.LHS())); - b.setVal42(es.EntityId(e.RHS())); - auto et43 = es.EntityId(e.RParenToken()); - b.setVal43(et43); - b.setVal84(e.IsConditionDependent()); - b.setVal85(e.IsConditionTrue()); + auto et39 = es.EntityId(e.BuiltinToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.ChosenSubExpression())); + b.setVal41(es.EntityId(e.Condition())); + b.setVal42(es.EntityId(e.LHS())); + b.setVal43(es.EntityId(e.RHS())); + auto et44 = es.EntityId(e.RParenToken()); + b.setVal44(et44); + b.setVal85(e.IsConditionDependent()); + b.setVal86(e.IsConditionTrue()); } void SerializeCharacterLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CharacterLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal89(static_cast(mx::FromPasta(e.LiteralKind()))); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - b.setVal26(e.Value()); + b.setVal90(static_cast(mx::FromPasta(e.LiteralKind()))); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + b.setVal27(e.Value()); } void SerializeCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CastExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal84(e.ChangesVolatileQualification()); - b.setVal89(static_cast(mx::FromPasta(e.CastKind()))); - auto v61 = e.CastKindName(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - auto v38 = e.ConversionFunction(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); + b.setVal85(e.ChangesVolatileQualification()); + b.setVal90(static_cast(mx::FromPasta(e.CastKind()))); + auto v62 = e.CastKindName(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + auto v39 = e.ConversionFunction(); + if (v39) { + auto id39 = es.EntityId(v39.value()); + b.setVal39(id39); } else { - b.setVal38(mx::kInvalidEntityId); + b.setVal39(mx::kInvalidEntityId); } - b.setVal39(es.EntityId(e.SubExpression())); - b.setVal40(es.EntityId(e.SubExpressionAsWritten())); - auto v41 = e.TargetUnionField(); - if (v41) { - auto id41 = es.EntityId(v41.value()); - b.setVal41(id41); + b.setVal40(es.EntityId(e.SubExpression())); + b.setVal41(es.EntityId(e.SubExpressionAsWritten())); + auto v42 = e.TargetUnionField(); + if (v42) { + auto id42 = es.EntityId(v42.value()); + b.setVal42(id42); } else { - b.setVal41(mx::kInvalidEntityId); + b.setVal42(mx::kInvalidEntityId); } - b.setVal85(e.HasStoredFPFeatures()); + b.setVal86(e.HasStoredFPFeatures()); } void SerializeImplicitCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ImplicitCastExpr &e, const TokenTree *) { (void) pf; SerializeCastExpr(pf, es, b, e, nullptr); - b.setVal86(e.IsPartOfExplicitCast()); + b.setVal87(e.IsPartOfExplicitCast()); } void SerializeExplicitCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ExplicitCastExpr &e, const TokenTree *) { (void) pf; SerializeCastExpr(pf, es, b, e, nullptr); - b.setVal42(es.EntityId(e.TypeAsWritten())); + b.setVal43(es.EntityId(e.TypeAsWritten())); } void SerializeCXXNamedCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXNamedCastExpr &e, const TokenTree *) { (void) pf; SerializeExplicitCastExpr(pf, es, b, e, nullptr); - auto p43 = es.EntityIds(e.AngleBrackets()); - b.setVal43(p43.first); - b.setVal44(p43.second); - auto v66 = e.CastName(); - std::string s66(v66.data(), v66.size()); - b.setVal66(s66); - auto et45 = es.EntityId(e.OperatorToken()); - b.setVal45(et45); - auto et46 = es.EntityId(e.RParenToken()); + auto p44 = es.EntityIds(e.AngleBrackets()); + b.setVal44(p44.first); + b.setVal45(p44.second); + auto v67 = e.CastName(); + std::string s67(v67.data(), v67.size()); + b.setVal67(s67); + auto et46 = es.EntityId(e.OperatorToken()); b.setVal46(et46); + auto et47 = es.EntityId(e.RParenToken()); + b.setVal47(et47); } void SerializeCXXDynamicCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXDynamicCastExpr &e, const TokenTree *) { (void) pf; SerializeCXXNamedCastExpr(pf, es, b, e, nullptr); - b.setVal86(e.IsAlwaysNull()); + b.setVal87(e.IsAlwaysNull()); } void SerializeCXXConstCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXConstCastExpr &e, const TokenTree *) { @@ -7100,20 +7101,20 @@ void SerializeCXXReinterpretCastExpr(const PendingFragment &pf, const EntityMapp void SerializeCXXFunctionalCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXFunctionalCastExpr &e, const TokenTree *) { (void) pf; SerializeExplicitCastExpr(pf, es, b, e, nullptr); - auto et43 = es.EntityId(e.LParenToken()); - b.setVal43(et43); - auto et44 = es.EntityId(e.RParenToken()); + auto et44 = es.EntityId(e.LParenToken()); b.setVal44(et44); - b.setVal86(e.IsListInitialization()); + auto et45 = es.EntityId(e.RParenToken()); + b.setVal45(et45); + b.setVal87(e.IsListInitialization()); } void SerializeCStyleCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CStyleCastExpr &e, const TokenTree *) { (void) pf; SerializeExplicitCastExpr(pf, es, b, e, nullptr); - auto et43 = es.EntityId(e.LParenToken()); - b.setVal43(et43); - auto et44 = es.EntityId(e.RParenToken()); + auto et44 = es.EntityId(e.LParenToken()); b.setVal44(et44); + auto et45 = es.EntityId(e.RParenToken()); + b.setVal45(et45); } void SerializeBuiltinBitCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::BuiltinBitCastExpr &e, const TokenTree *) { @@ -7124,339 +7125,339 @@ void SerializeBuiltinBitCastExpr(const PendingFragment &pf, const EntityMapper & void SerializeObjCBridgedCastExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCBridgedCastExpr &e, const TokenTree *) { (void) pf; SerializeExplicitCastExpr(pf, es, b, e, nullptr); - auto et43 = es.EntityId(e.BridgeKeywordToken()); - b.setVal43(et43); - b.setVal91(static_cast(mx::FromPasta(e.BridgeKind()))); - auto v66 = e.BridgeKindName(); - std::string s66(v66.data(), v66.size()); - b.setVal66(s66); - auto et44 = es.EntityId(e.LParenToken()); + auto et44 = es.EntityId(e.BridgeKeywordToken()); b.setVal44(et44); + b.setVal92(static_cast(mx::FromPasta(e.BridgeKind()))); + auto v67 = e.BridgeKindName(); + std::string s67(v67.data(), v67.size()); + b.setVal67(s67); + auto et45 = es.EntityId(e.LParenToken()); + b.setVal45(et45); } void SerializeCallExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CallExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.Arguments(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Arguments(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - b.setVal89(static_cast(mx::FromPasta(e.ADLCallKind()))); - b.setVal26(e.BuiltinCallee()); - b.setVal38(es.EntityId(e.CallReturnType())); - b.setVal39(es.EntityId(e.Callee())); - auto v40 = e.CalleeDeclaration(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); - } else { - b.setVal40(mx::kInvalidEntityId); - } - auto v41 = e.DirectCallee(); + b.setVal90(static_cast(mx::FromPasta(e.ADLCallKind()))); + b.setVal27(e.BuiltinCallee()); + b.setVal39(es.EntityId(e.CallReturnType())); + b.setVal40(es.EntityId(e.Callee())); + auto v41 = e.CalleeDeclaration(); if (v41) { auto id41 = es.EntityId(v41.value()); b.setVal41(id41); } else { b.setVal41(mx::kInvalidEntityId); } - auto et42 = es.EntityId(e.RParenToken()); - b.setVal42(et42); - b.setVal84(e.HasStoredFPFeatures()); - b.setVal85(e.HasUnusedResultAttribute()); - b.setVal86(e.IsBuiltinAssumeFalse()); - b.setVal87(e.IsCallToStdMove()); - b.setVal88(e.IsUnevaluatedBuiltinCall()); - b.setVal90(e.UsesADL()); + auto v42 = e.DirectCallee(); + if (v42) { + auto id42 = es.EntityId(v42.value()); + b.setVal42(id42); + } else { + b.setVal42(mx::kInvalidEntityId); + } + auto et43 = es.EntityId(e.RParenToken()); + b.setVal43(et43); + b.setVal85(e.HasStoredFPFeatures()); + b.setVal86(e.HasUnusedResultAttribute()); + b.setVal87(e.IsBuiltinAssumeFalse()); + b.setVal88(e.IsCallToStdMove()); + b.setVal89(e.IsUnevaluatedBuiltinCall()); + b.setVal91(e.UsesADL()); } void SerializeCXXOperatorCallExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXOperatorCallExpr &e, const TokenTree *) { (void) pf; SerializeCallExpr(pf, es, b, e, nullptr); - b.setVal91(static_cast(mx::FromPasta(e.Operator()))); - auto et43 = es.EntityId(e.OperatorToken()); - b.setVal43(et43); - b.setVal92(e.IsAssignmentOperation()); - b.setVal93(e.IsComparisonOperation()); - b.setVal94(e.IsInfixBinaryOperation()); + b.setVal92(static_cast(mx::FromPasta(e.Operator()))); + auto et44 = es.EntityId(e.OperatorToken()); + b.setVal44(et44); + b.setVal93(e.IsAssignmentOperation()); + b.setVal94(e.IsComparisonOperation()); + b.setVal95(e.IsInfixBinaryOperation()); } void SerializeCXXMemberCallExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXMemberCallExpr &e, const TokenTree *) { (void) pf; SerializeCallExpr(pf, es, b, e, nullptr); - b.setVal43(es.EntityId(e.ImplicitObjectArgument())); - auto v44 = e.MethodDeclaration(); - if (v44) { - auto id44 = es.EntityId(v44.value()); - b.setVal44(id44); + b.setVal44(es.EntityId(e.ImplicitObjectArgument())); + auto v45 = e.MethodDeclaration(); + if (v45) { + auto id45 = es.EntityId(v45.value()); + b.setVal45(id45); } else { - b.setVal44(mx::kInvalidEntityId); + b.setVal45(mx::kInvalidEntityId); } - b.setVal45(es.EntityId(e.ObjectType())); - b.setVal46(es.EntityId(e.RecordDeclaration())); + b.setVal46(es.EntityId(e.ObjectType())); + b.setVal47(es.EntityId(e.RecordDeclaration())); } void SerializeCUDAKernelCallExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CUDAKernelCallExpr &e, const TokenTree *) { (void) pf; SerializeCallExpr(pf, es, b, e, nullptr); - b.setVal43(es.EntityId(e.Config())); + b.setVal44(es.EntityId(e.Config())); } void SerializeUserDefinedLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::UserDefinedLiteral &e, const TokenTree *) { (void) pf; SerializeCallExpr(pf, es, b, e, nullptr); - auto v43 = e.CookedLiteral(); - if (v43) { - auto id43 = es.EntityId(v43.value()); - b.setVal43(id43); + auto v44 = e.CookedLiteral(); + if (v44) { + auto id44 = es.EntityId(v44.value()); + b.setVal44(id44); } else { - b.setVal43(mx::kInvalidEntityId); + b.setVal44(mx::kInvalidEntityId); } - b.setVal91(static_cast(mx::FromPasta(e.LiteralOperatorKind()))); - auto et44 = es.EntityId(e.UDSuffixToken()); - b.setVal44(et44); + b.setVal92(static_cast(mx::FromPasta(e.LiteralOperatorKind()))); + auto et45 = es.EntityId(e.UDSuffixToken()); + b.setVal45(et45); } void SerializeCXXUuidofExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXUuidofExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.ExpressionOperand(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); + auto v39 = e.ExpressionOperand(); + if (v39) { + auto id39 = es.EntityId(v39.value()); + b.setVal39(id39); } else { - b.setVal38(mx::kInvalidEntityId); + b.setVal39(mx::kInvalidEntityId); } - b.setVal39(es.EntityId(e.GuidDeclaration())); - auto v40 = e.TypeOperand(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + b.setVal40(es.EntityId(e.GuidDeclaration())); + auto v41 = e.TypeOperand(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - b.setVal41(es.EntityId(e.TypeOperandSourceInfo())); - b.setVal84(e.IsTypeOperand()); + b.setVal42(es.EntityId(e.TypeOperandSourceInfo())); + b.setVal85(e.IsTypeOperand()); } void SerializeCXXUnresolvedConstructExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXUnresolvedConstructExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.Arguments(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Arguments(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto et38 = es.EntityId(e.LParenToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.LParenToken()); b.setVal39(et39); - b.setVal40(es.EntityId(e.TypeAsWritten())); - b.setVal84(e.IsListInitialization()); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.TypeAsWritten())); + b.setVal85(e.IsListInitialization()); } void SerializeCXXTypeidExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXTypeidExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.ExpressionOperand(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); - } else { - b.setVal38(mx::kInvalidEntityId); - } - auto v39 = e.TypeOperand(); + auto v39 = e.ExpressionOperand(); if (v39) { auto id39 = es.EntityId(v39.value()); b.setVal39(id39); } else { b.setVal39(mx::kInvalidEntityId); } - auto v40 = e.TypeOperandSourceInfo(); + auto v40 = e.TypeOperand(); if (v40) { auto id40 = es.EntityId(v40.value()); b.setVal40(id40); } else { b.setVal40(mx::kInvalidEntityId); } - auto v84 = e.IsMostDerived(); - if (v84) { - b.setVal84(static_cast(v84.value())); - b.setVal85(true); + auto v41 = e.TypeOperandSourceInfo(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal85(false); + b.setVal41(mx::kInvalidEntityId); + } + auto v85 = e.IsMostDerived(); + if (v85) { + b.setVal85(static_cast(v85.value())); + b.setVal86(true); + } else { + b.setVal86(false); } - b.setVal86(e.IsPotentiallyEvaluated()); - b.setVal87(e.IsTypeOperand()); + b.setVal87(e.IsPotentiallyEvaluated()); + b.setVal88(e.IsTypeOperand()); } void SerializeCXXThrowExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXThrowExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.SubExpression(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); + auto v39 = e.SubExpression(); + if (v39) { + auto id39 = es.EntityId(v39.value()); + b.setVal39(id39); } else { - b.setVal38(mx::kInvalidEntityId); + b.setVal39(mx::kInvalidEntityId); } - auto et39 = es.EntityId(e.ThrowToken()); - b.setVal39(et39); - b.setVal84(e.IsThrownVariableInScope()); + auto et40 = es.EntityId(e.ThrowToken()); + b.setVal40(et40); + b.setVal85(e.IsThrownVariableInScope()); } void SerializeCXXThisExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXThisExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - b.setVal84(e.IsImplicit()); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + b.setVal85(e.IsImplicit()); } void SerializeCXXStdInitializerListExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXStdInitializerListExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.SubExpression())); + b.setVal39(es.EntityId(e.SubExpression())); } void SerializeCXXScalarValueInitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXScalarValueInitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.RParenToken()); - b.setVal38(et38); + auto et39 = es.EntityId(e.RParenToken()); + b.setVal39(et39); } void SerializeCXXRewrittenBinaryOperator(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXRewrittenBinaryOperator &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.LHS())); - b.setVal89(static_cast(mx::FromPasta(e.Opcode()))); - auto v61 = e.OpcodeString(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - b.setVal91(static_cast(mx::FromPasta(e.Operator()))); - auto et39 = es.EntityId(e.OperatorToken()); - b.setVal39(et39); - b.setVal40(es.EntityId(e.RHS())); - b.setVal41(es.EntityId(e.SemanticForm())); - b.setVal84(e.IsAssignmentOperation()); - b.setVal85(e.IsComparisonOperation()); - b.setVal86(e.IsReversed()); + b.setVal39(es.EntityId(e.LHS())); + b.setVal90(static_cast(mx::FromPasta(e.Opcode()))); + auto v62 = e.OpcodeString(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + b.setVal92(static_cast(mx::FromPasta(e.Operator()))); + auto et40 = es.EntityId(e.OperatorToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.RHS())); + b.setVal42(es.EntityId(e.SemanticForm())); + b.setVal85(e.IsAssignmentOperation()); + b.setVal86(e.IsComparisonOperation()); + b.setVal87(e.IsReversed()); } void SerializeCXXPseudoDestructorExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXPseudoDestructorExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - auto et39 = es.EntityId(e.ColonColonToken()); - b.setVal39(et39); - auto v40 = e.DestroyedType(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + b.setVal39(es.EntityId(e.Base())); + auto et40 = es.EntityId(e.ColonColonToken()); + b.setVal40(et40); + auto v41 = e.DestroyedType(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - auto et41 = es.EntityId(e.DestroyedTypeToken()); - b.setVal41(et41); - auto et42 = es.EntityId(e.OperatorToken()); + auto et42 = es.EntityId(e.DestroyedTypeToken()); b.setVal42(et42); - auto et43 = es.EntityId(e.TildeToken()); + auto et43 = es.EntityId(e.OperatorToken()); b.setVal43(et43); - b.setVal84(e.HasQualifier()); - b.setVal85(e.IsArrow()); + auto et44 = es.EntityId(e.TildeToken()); + b.setVal44(et44); + b.setVal85(e.HasQualifier()); + b.setVal86(e.IsArrow()); } void SerializeCXXParenListInitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXParenListInitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.ArrayFiller())); - auto et39 = es.EntityId(e.InitializerToken()); - b.setVal39(et39); - b.setVal40(es.EntityId(e.InitializedFieldInUnion())); + b.setVal39(es.EntityId(e.ArrayFiller())); + auto et40 = es.EntityId(e.InitializerToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.InitializedFieldInUnion())); } void SerializeCXXNullPtrLiteralExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXNullPtrLiteralExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); } void SerializeCXXNoexceptExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXNoexceptExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Operand())); - b.setVal84(e.Value()); + b.setVal39(es.EntityId(e.Operand())); + b.setVal85(e.Value()); } void SerializeCXXNewExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXNewExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal84(e.DoesUsualArrayDeleteWantSize()); - b.setVal38(es.EntityId(e.AllocatedType())); - auto v39 = e.ArraySize(); - if (v39) { - auto id39 = es.EntityId(v39.value()); - b.setVal39(id39); - } else { - b.setVal39(mx::kInvalidEntityId); - } - auto v40 = e.ConstructExpression(); + b.setVal85(e.DoesUsualArrayDeleteWantSize()); + b.setVal39(es.EntityId(e.AllocatedType())); + auto v40 = e.ArraySize(); if (v40) { auto id40 = es.EntityId(v40.value()); b.setVal40(id40); } else { b.setVal40(mx::kInvalidEntityId); } - auto p41 = es.EntityIds(e.DirectInitializerRange()); - b.setVal41(p41.first); - b.setVal42(p41.second); - b.setVal89(static_cast(mx::FromPasta(e.InitializationStyle()))); - auto v43 = e.Initializer(); - if (v43) { - auto id43 = es.EntityId(v43.value()); - b.setVal43(id43); + auto v41 = e.ConstructExpression(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal43(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - auto v44 = e.OperatorDelete(); + auto p42 = es.EntityIds(e.DirectInitializerRange()); + b.setVal42(p42.first); + b.setVal43(p42.second); + b.setVal90(static_cast(mx::FromPasta(e.InitializationStyle()))); + auto v44 = e.Initializer(); if (v44) { auto id44 = es.EntityId(v44.value()); b.setVal44(id44); } else { b.setVal44(mx::kInvalidEntityId); } - auto v45 = e.OperatorNew(); + auto v45 = e.OperatorDelete(); if (v45) { auto id45 = es.EntityId(v45.value()); b.setVal45(id45); } else { b.setVal45(mx::kInvalidEntityId); } - auto p46 = es.EntityIds(e.TypeIdParentheses()); - b.setVal46(p46.first); - b.setVal47(p46.second); - b.setVal85(e.HasInitializer()); - b.setVal86(e.IsArray()); - b.setVal87(e.IsGlobalNew()); - b.setVal88(e.IsParenthesisTypeId()); - b.setVal90(e.PassAlignment()); + auto v46 = e.OperatorNew(); + if (v46) { + auto id46 = es.EntityId(v46.value()); + b.setVal46(id46); + } else { + b.setVal46(mx::kInvalidEntityId); + } + auto p47 = es.EntityIds(e.TypeIdParentheses()); + b.setVal47(p47.first); + b.setVal48(p47.second); + b.setVal86(e.HasInitializer()); + b.setVal87(e.IsArray()); + b.setVal88(e.IsGlobalNew()); + b.setVal89(e.IsParenthesisTypeId()); + b.setVal91(e.PassAlignment()); do { - auto v15 = e.PlacementArguments(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.PlacementArguments(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -7464,174 +7465,174 @@ void SerializeCXXNewExpr(const PendingFragment &pf, const EntityMapper &es, mx:: void SerializeCXXInheritedCtorInitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXInheritedCtorInitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal84(e.ConstructsVirtualBase()); - b.setVal89(static_cast(mx::FromPasta(e.ConstructionKind()))); - b.setVal38(es.EntityId(e.Constructor())); - auto et39 = es.EntityId(e.Token()); - b.setVal39(et39); - b.setVal85(e.InheritedFromVirtualBase()); + b.setVal85(e.ConstructsVirtualBase()); + b.setVal90(static_cast(mx::FromPasta(e.ConstructionKind()))); + b.setVal39(es.EntityId(e.Constructor())); + auto et40 = es.EntityId(e.Token()); + b.setVal40(et40); + b.setVal86(e.InheritedFromVirtualBase()); } void SerializeCXXFoldExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXFoldExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.Callee(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); - } else { - b.setVal38(mx::kInvalidEntityId); - } - auto et39 = es.EntityId(e.EllipsisToken()); - b.setVal39(et39); - auto v40 = e.Initializer(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + auto v39 = e.Callee(); + if (v39) { + auto id39 = es.EntityId(v39.value()); + b.setVal39(id39); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal39(mx::kInvalidEntityId); } - auto v41 = e.LHS(); + auto et40 = es.EntityId(e.EllipsisToken()); + b.setVal40(et40); + auto v41 = e.Initializer(); if (v41) { auto id41 = es.EntityId(v41.value()); b.setVal41(id41); } else { b.setVal41(mx::kInvalidEntityId); } - auto et42 = es.EntityId(e.LParenToken()); - b.setVal42(et42); - b.setVal89(static_cast(mx::FromPasta(e.Operator()))); - b.setVal43(es.EntityId(e.Pattern())); - auto v44 = e.RHS(); - if (v44) { - auto id44 = es.EntityId(v44.value()); - b.setVal44(id44); + auto v42 = e.LHS(); + if (v42) { + auto id42 = es.EntityId(v42.value()); + b.setVal42(id42); } else { - b.setVal44(mx::kInvalidEntityId); + b.setVal42(mx::kInvalidEntityId); } - auto et45 = es.EntityId(e.RParenToken()); - b.setVal45(et45); - b.setVal84(e.IsLeftFold()); - b.setVal85(e.IsRightFold()); + auto et43 = es.EntityId(e.LParenToken()); + b.setVal43(et43); + b.setVal90(static_cast(mx::FromPasta(e.Operator()))); + b.setVal44(es.EntityId(e.Pattern())); + auto v45 = e.RHS(); + if (v45) { + auto id45 = es.EntityId(v45.value()); + b.setVal45(id45); + } else { + b.setVal45(mx::kInvalidEntityId); + } + auto et46 = es.EntityId(e.RParenToken()); + b.setVal46(et46); + b.setVal85(e.IsLeftFold()); + b.setVal86(e.IsRightFold()); } void SerializeCXXDependentScopeMemberExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXDependentScopeMemberExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.Base(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); + auto v39 = e.Base(); + if (v39) { + auto id39 = es.EntityId(v39.value()); + b.setVal39(id39); } else { - b.setVal38(mx::kInvalidEntityId); + b.setVal39(mx::kInvalidEntityId); } - b.setVal39(es.EntityId(e.BaseType())); - auto v40 = e.FirstQualifierFoundInScope(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + b.setVal40(es.EntityId(e.BaseType())); + auto v41 = e.FirstQualifierFoundInScope(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - auto et41 = es.EntityId(e.LAngleToken()); - b.setVal41(et41); - auto et42 = es.EntityId(e.MemberToken()); + auto et42 = es.EntityId(e.LAngleToken()); b.setVal42(et42); - auto et43 = es.EntityId(e.OperatorToken()); + auto et43 = es.EntityId(e.MemberToken()); b.setVal43(et43); - auto et44 = es.EntityId(e.RAngleToken()); + auto et44 = es.EntityId(e.OperatorToken()); b.setVal44(et44); - auto et45 = es.EntityId(e.TemplateKeywordToken()); + auto et45 = es.EntityId(e.RAngleToken()); b.setVal45(et45); - b.setVal84(e.HasExplicitTemplateArguments()); - b.setVal85(e.HasTemplateKeyword()); - b.setVal86(e.IsArrow()); - b.setVal87(e.IsImplicitAccess()); + auto et46 = es.EntityId(e.TemplateKeywordToken()); + b.setVal46(et46); + b.setVal85(e.HasExplicitTemplateArguments()); + b.setVal86(e.HasTemplateKeyword()); + b.setVal87(e.IsArrow()); + b.setVal88(e.IsImplicitAccess()); } void SerializeCXXDeleteExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXDeleteExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal84(e.DoesUsualArrayDeleteWantSize()); - b.setVal38(es.EntityId(e.Argument())); - auto v39 = e.DestroyedType(); - if (v39) { - auto id39 = es.EntityId(v39.value()); - b.setVal39(id39); - } else { - b.setVal39(mx::kInvalidEntityId); - } - auto v40 = e.OperatorDelete(); + b.setVal85(e.DoesUsualArrayDeleteWantSize()); + b.setVal39(es.EntityId(e.Argument())); + auto v40 = e.DestroyedType(); if (v40) { auto id40 = es.EntityId(v40.value()); b.setVal40(id40); } else { b.setVal40(mx::kInvalidEntityId); } - b.setVal85(e.IsArrayForm()); - b.setVal86(e.IsArrayFormAsWritten()); - b.setVal87(e.IsGlobalDelete()); + auto v41 = e.OperatorDelete(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); + } else { + b.setVal41(mx::kInvalidEntityId); + } + b.setVal86(e.IsArrayForm()); + b.setVal87(e.IsArrayFormAsWritten()); + b.setVal88(e.IsGlobalDelete()); } void SerializeCXXDefaultInitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXDefaultInitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.Expression(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); + auto v39 = e.Expression(); + if (v39) { + auto id39 = es.EntityId(v39.value()); + b.setVal39(id39); } else { - b.setVal38(mx::kInvalidEntityId); + b.setVal39(mx::kInvalidEntityId); } - b.setVal39(es.EntityId(e.Field())); - b.setVal40(es.EntityId(e.RewrittenExpression())); - auto et41 = es.EntityId(e.UsedToken()); - b.setVal41(et41); - b.setVal84(e.HasRewrittenInitializer()); + b.setVal40(es.EntityId(e.Field())); + b.setVal41(es.EntityId(e.RewrittenExpression())); + auto et42 = es.EntityId(e.UsedToken()); + b.setVal42(et42); + b.setVal85(e.HasRewrittenInitializer()); } void SerializeCXXDefaultArgExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXDefaultArgExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Expression())); - b.setVal39(es.EntityId(e.Parameter())); - auto v40 = e.RewrittenExpression(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + b.setVal39(es.EntityId(e.Expression())); + b.setVal40(es.EntityId(e.Parameter())); + auto v41 = e.RewrittenExpression(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - auto et41 = es.EntityId(e.UsedToken()); - b.setVal41(et41); - b.setVal84(e.HasRewrittenInitializer()); + auto et42 = es.EntityId(e.UsedToken()); + b.setVal42(et42); + b.setVal85(e.HasRewrittenInitializer()); } void SerializeCXXConstructExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXConstructExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.Arguments(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Arguments(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - b.setVal89(static_cast(mx::FromPasta(e.ConstructionKind()))); - b.setVal38(es.EntityId(e.Constructor())); - auto et39 = es.EntityId(e.Token()); - b.setVal39(et39); - auto p40 = es.EntityIds(e.ParenthesisOrBraceRange()); - b.setVal40(p40.first); - b.setVal41(p40.second); - b.setVal84(e.HadMultipleCandidates()); - b.setVal85(e.IsElidable()); - b.setVal86(e.IsImmediateEscalating()); - b.setVal87(e.IsListInitialization()); - b.setVal88(e.IsStdInitializerListInitialization()); - b.setVal90(e.RequiresZeroInitialization()); + b.setVal90(static_cast(mx::FromPasta(e.ConstructionKind()))); + b.setVal39(es.EntityId(e.Constructor())); + auto et40 = es.EntityId(e.Token()); + b.setVal40(et40); + auto p41 = es.EntityIds(e.ParenthesisOrBraceRange()); + b.setVal41(p41.first); + b.setVal42(p41.second); + b.setVal85(e.HadMultipleCandidates()); + b.setVal86(e.IsElidable()); + b.setVal87(e.IsImmediateEscalating()); + b.setVal88(e.IsListInitialization()); + b.setVal89(e.IsStdInitializerListInitialization()); + b.setVal91(e.RequiresZeroInitialization()); } void SerializeCXXTemporaryObjectExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXTemporaryObjectExpr &e, const TokenTree *) { @@ -7642,120 +7643,120 @@ void SerializeCXXTemporaryObjectExpr(const PendingFragment &pf, const EntityMapp void SerializeCXXBoolLiteralExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXBoolLiteralExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - b.setVal84(e.Value()); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + b.setVal85(e.Value()); } void SerializeCXXBindTemporaryExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CXXBindTemporaryExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.SubExpression())); + b.setVal39(es.EntityId(e.SubExpression())); } void SerializeBlockExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::BlockExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.BlockDeclaration())); - b.setVal39(es.EntityId(e.Body())); - auto et40 = es.EntityId(e.CaretToken()); - b.setVal40(et40); - b.setVal41(es.EntityId(e.FunctionType())); + b.setVal39(es.EntityId(e.BlockDeclaration())); + b.setVal40(es.EntityId(e.Body())); + auto et41 = es.EntityId(e.CaretToken()); + b.setVal41(et41); + b.setVal42(es.EntityId(e.FunctionType())); } void SerializeBinaryOperator(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::BinaryOperator &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.LHS())); - b.setVal89(static_cast(mx::FromPasta(e.Opcode()))); - auto v61 = e.OpcodeString(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - auto et39 = es.EntityId(e.OperatorToken()); - b.setVal39(et39); - b.setVal40(es.EntityId(e.RHS())); - b.setVal84(e.HasStoredFPFeatures()); - b.setVal85(e.IsAdditiveOperation()); - b.setVal86(e.IsAssignmentOperation()); - b.setVal87(e.IsBitwiseOperation()); - b.setVal88(e.IsCommaOperation()); - b.setVal90(e.IsComparisonOperation()); - b.setVal92(e.IsCompoundAssignmentOperation()); - b.setVal93(e.IsEqualityOperation()); - b.setVal94(e.IsLogicalOperation()); - b.setVal95(e.IsMultiplicativeOperation()); - b.setVal96(e.IsPointerMemoryOperation()); - b.setVal97(e.IsRelationalOperation()); - b.setVal98(e.IsShiftAssignOperation()); - b.setVal99(e.IsShiftOperation()); + b.setVal39(es.EntityId(e.LHS())); + b.setVal90(static_cast(mx::FromPasta(e.Opcode()))); + auto v62 = e.OpcodeString(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + auto et40 = es.EntityId(e.OperatorToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.RHS())); + b.setVal85(e.HasStoredFPFeatures()); + b.setVal86(e.IsAdditiveOperation()); + b.setVal87(e.IsAssignmentOperation()); + b.setVal88(e.IsBitwiseOperation()); + b.setVal89(e.IsCommaOperation()); + b.setVal91(e.IsComparisonOperation()); + b.setVal93(e.IsCompoundAssignmentOperation()); + b.setVal94(e.IsEqualityOperation()); + b.setVal95(e.IsLogicalOperation()); + b.setVal96(e.IsMultiplicativeOperation()); + b.setVal97(e.IsPointerMemoryOperation()); + b.setVal98(e.IsRelationalOperation()); + b.setVal99(e.IsShiftAssignOperation()); + b.setVal100(e.IsShiftOperation()); } void SerializeCompoundAssignOperator(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CompoundAssignOperator &e, const TokenTree *) { (void) pf; SerializeBinaryOperator(pf, es, b, e, nullptr); - b.setVal41(es.EntityId(e.ComputationLHSType())); - b.setVal42(es.EntityId(e.ComputationResultType())); + b.setVal42(es.EntityId(e.ComputationLHSType())); + b.setVal43(es.EntityId(e.ComputationResultType())); } void SerializeAtomicExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::AtomicExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.BuiltinToken()); - b.setVal38(et38); - b.setVal89(static_cast(mx::FromPasta(e.Operation()))); - auto v61 = e.OperationAsString(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - b.setVal39(es.EntityId(e.Order())); - auto v40 = e.OrderFail(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); - } else { - b.setVal40(mx::kInvalidEntityId); - } - b.setVal41(es.EntityId(e.Pointer())); - auto et42 = es.EntityId(e.RParenToken()); - b.setVal42(et42); - auto v43 = e.Scope(); - if (v43) { - auto id43 = es.EntityId(v43.value()); - b.setVal43(id43); + auto et39 = es.EntityId(e.BuiltinToken()); + b.setVal39(et39); + b.setVal90(static_cast(mx::FromPasta(e.Operation()))); + auto v62 = e.OperationAsString(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + b.setVal40(es.EntityId(e.Order())); + auto v41 = e.OrderFail(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal43(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - auto v44 = e.Value1(); + b.setVal42(es.EntityId(e.Pointer())); + auto et43 = es.EntityId(e.RParenToken()); + b.setVal43(et43); + auto v44 = e.Scope(); if (v44) { auto id44 = es.EntityId(v44.value()); b.setVal44(id44); } else { b.setVal44(mx::kInvalidEntityId); } - auto v45 = e.Value2(); + auto v45 = e.Value1(); if (v45) { auto id45 = es.EntityId(v45.value()); b.setVal45(id45); } else { b.setVal45(mx::kInvalidEntityId); } - b.setVal46(es.EntityId(e.ValueType())); - auto v47 = e.Weak(); - if (v47) { - auto id47 = es.EntityId(v47.value()); - b.setVal47(id47); + auto v46 = e.Value2(); + if (v46) { + auto id46 = es.EntityId(v46.value()); + b.setVal46(id46); } else { - b.setVal47(mx::kInvalidEntityId); + b.setVal46(mx::kInvalidEntityId); } - b.setVal84(e.IsCmpXChg()); - b.setVal85(e.IsOpenCL()); - b.setVal86(e.IsVolatile()); + b.setVal47(es.EntityId(e.ValueType())); + auto v48 = e.Weak(); + if (v48) { + auto id48 = es.EntityId(v48.value()); + b.setVal48(id48); + } else { + b.setVal48(mx::kInvalidEntityId); + } + b.setVal85(e.IsCmpXChg()); + b.setVal86(e.IsOpenCL()); + b.setVal87(e.IsVolatile()); do { - auto v15 = e.SubExpressions(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.SubExpressions(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -7763,38 +7764,38 @@ void SerializeAtomicExpr(const PendingFragment &pf, const EntityMapper &es, mx:: void SerializeAsTypeExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::AsTypeExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.BuiltinToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.BuiltinToken()); b.setVal39(et39); - b.setVal40(es.EntityId(e.SrcExpression())); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.SrcExpression())); } void SerializeArrayTypeTraitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ArrayTypeTraitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.DimensionExpression())); - b.setVal39(es.EntityId(e.QueriedType())); - b.setVal89(static_cast(mx::FromPasta(e.Trait()))); - b.setVal40(e.Value()); + b.setVal39(es.EntityId(e.DimensionExpression())); + b.setVal40(es.EntityId(e.QueriedType())); + b.setVal90(static_cast(mx::FromPasta(e.Trait()))); + b.setVal41(e.Value()); } void SerializeArraySubscriptExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ArraySubscriptExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - b.setVal39(es.EntityId(e.Index())); - b.setVal40(es.EntityId(e.LHS())); - auto et41 = es.EntityId(e.RBracketToken()); - b.setVal41(et41); - b.setVal42(es.EntityId(e.RHS())); + b.setVal39(es.EntityId(e.Base())); + b.setVal40(es.EntityId(e.Index())); + b.setVal41(es.EntityId(e.LHS())); + auto et42 = es.EntityId(e.RBracketToken()); + b.setVal42(et42); + b.setVal43(es.EntityId(e.RHS())); } void SerializeArrayInitLoopExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ArrayInitLoopExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.CommonExpression())); - b.setVal39(es.EntityId(e.SubExpression())); + b.setVal39(es.EntityId(e.CommonExpression())); + b.setVal40(es.EntityId(e.SubExpression())); } void SerializeArrayInitIndexExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ArrayInitIndexExpr &e, const TokenTree *) { @@ -7805,91 +7806,91 @@ void SerializeArrayInitIndexExpr(const PendingFragment &pf, const EntityMapper & void SerializeAddrLabelExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::AddrLabelExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.AmpAmpToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.Label())); - auto et40 = es.EntityId(e.LabelToken()); - b.setVal40(et40); + auto et39 = es.EntityId(e.AmpAmpToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.Label())); + auto et41 = es.EntityId(e.LabelToken()); + b.setVal41(et41); } void SerializeAbstractConditionalOperator(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::AbstractConditionalOperator &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.ColonToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.Condition())); - b.setVal40(es.EntityId(e.FalseExpression())); - auto et41 = es.EntityId(e.QuestionToken()); - b.setVal41(et41); - b.setVal42(es.EntityId(e.TrueExpression())); + auto et39 = es.EntityId(e.ColonToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.Condition())); + b.setVal41(es.EntityId(e.FalseExpression())); + auto et42 = es.EntityId(e.QuestionToken()); + b.setVal42(et42); + b.setVal43(es.EntityId(e.TrueExpression())); } void SerializeConditionalOperator(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ConditionalOperator &e, const TokenTree *) { (void) pf; SerializeAbstractConditionalOperator(pf, es, b, e, nullptr); - b.setVal43(es.EntityId(e.LHS())); - b.setVal44(es.EntityId(e.RHS())); + b.setVal44(es.EntityId(e.LHS())); + b.setVal45(es.EntityId(e.RHS())); } void SerializeBinaryConditionalOperator(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::BinaryConditionalOperator &e, const TokenTree *) { (void) pf; SerializeAbstractConditionalOperator(pf, es, b, e, nullptr); - b.setVal43(es.EntityId(e.Common())); - b.setVal44(es.EntityId(e.OpaqueValue())); + b.setVal44(es.EntityId(e.Common())); + b.setVal45(es.EntityId(e.OpaqueValue())); } void SerializeVAArgExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::VAArgExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.BuiltinToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.BuiltinToken()); b.setVal39(et39); - b.setVal40(es.EntityId(e.SubExpression())); - b.setVal84(e.IsMicrosoftABI()); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.SubExpression())); + b.setVal85(e.IsMicrosoftABI()); } void SerializeUnaryOperator(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::UnaryOperator &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal84(e.CanOverflow()); - b.setVal89(static_cast(mx::FromPasta(e.Opcode()))); - auto et38 = es.EntityId(e.OperatorToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.SubExpression())); - b.setVal85(e.HasStoredFPFeatures()); - b.setVal86(e.IsArithmeticOperation()); - b.setVal87(e.IsDecrementOperation()); - b.setVal88(e.IsIncrementDecrementOperation()); - b.setVal90(e.IsIncrementOperation()); - b.setVal92(e.IsPostfix()); - b.setVal93(e.IsPrefix()); + b.setVal85(e.CanOverflow()); + b.setVal90(static_cast(mx::FromPasta(e.Opcode()))); + auto et39 = es.EntityId(e.OperatorToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.SubExpression())); + b.setVal86(e.HasStoredFPFeatures()); + b.setVal87(e.IsArithmeticOperation()); + b.setVal88(e.IsDecrementOperation()); + b.setVal89(e.IsIncrementDecrementOperation()); + b.setVal91(e.IsIncrementOperation()); + b.setVal93(e.IsPostfix()); + b.setVal94(e.IsPrefix()); } void SerializeUnaryExprOrTypeTraitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::UnaryExprOrTypeTraitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.ArgumentExpression(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); - } else { - b.setVal38(mx::kInvalidEntityId); - } - auto v39 = e.ArgumentType(); + auto v39 = e.ArgumentExpression(); if (v39) { auto id39 = es.EntityId(v39.value()); b.setVal39(id39); } else { b.setVal39(mx::kInvalidEntityId); } - b.setVal89(static_cast(mx::FromPasta(e.KeywordKind()))); - auto et40 = es.EntityId(e.OperatorToken()); - b.setVal40(et40); - auto et41 = es.EntityId(e.RParenToken()); + auto v40 = e.ArgumentType(); + if (v40) { + auto id40 = es.EntityId(v40.value()); + b.setVal40(id40); + } else { + b.setVal40(mx::kInvalidEntityId); + } + b.setVal90(static_cast(mx::FromPasta(e.KeywordKind()))); + auto et41 = es.EntityId(e.OperatorToken()); b.setVal41(et41); - b.setVal42(es.EntityId(e.TypeOfArgument())); - b.setVal84(e.IsArgumentType()); + auto et42 = es.EntityId(e.RParenToken()); + b.setVal42(et42); + b.setVal43(es.EntityId(e.TypeOfArgument())); + b.setVal85(e.IsArgumentType()); } void SerializeTypoExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::TypoExpr &e, const TokenTree *) { @@ -7900,21 +7901,21 @@ void SerializeTypoExpr(const PendingFragment &pf, const EntityMapper &es, mx::as void SerializeTypeTraitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::TypeTraitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal89(static_cast(mx::FromPasta(e.Trait()))); - auto v84 = e.Value(); - if (v84) { - b.setVal84(static_cast(v84.value())); - b.setVal85(true); + b.setVal90(static_cast(mx::FromPasta(e.Trait()))); + auto v85 = e.Value(); + if (v85) { + b.setVal85(static_cast(v85.value())); + b.setVal86(true); } else { - b.setVal85(false); + b.setVal86(false); } do { - auto v15 = e.Arguments(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Arguments(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -7922,191 +7923,191 @@ void SerializeTypeTraitExpr(const PendingFragment &pf, const EntityMapper &es, m void SerializeSubstNonTypeTemplateParmPackExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SubstNonTypeTemplateParmPackExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.AssociatedDeclaration())); - b.setVal26(e.Index()); - b.setVal39(es.EntityId(e.ParameterPack())); - auto et40 = es.EntityId(e.ParameterPackToken()); - b.setVal40(et40); + b.setVal39(es.EntityId(e.AssociatedDeclaration())); + b.setVal27(e.Index()); + b.setVal40(es.EntityId(e.ParameterPack())); + auto et41 = es.EntityId(e.ParameterPackToken()); + b.setVal41(et41); } void SerializeSubstNonTypeTemplateParmExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SubstNonTypeTemplateParmExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.AssociatedDeclaration())); - b.setVal26(e.Index()); - auto et39 = es.EntityId(e.NameToken()); - b.setVal39(et39); - auto v100 = e.PackIndex(); - if (v100) { - b.setVal100(static_cast(v100.value())); - b.setVal84(true); + b.setVal39(es.EntityId(e.AssociatedDeclaration())); + b.setVal27(e.Index()); + auto et40 = es.EntityId(e.NameToken()); + b.setVal40(et40); + auto v101 = e.PackIndex(); + if (v101) { + b.setVal101(static_cast(v101.value())); + b.setVal85(true); } else { - b.setVal84(false); + b.setVal85(false); } - b.setVal40(es.EntityId(e.Parameter())); - b.setVal41(es.EntityId(e.ParameterType())); - b.setVal42(es.EntityId(e.Replacement())); - b.setVal85(e.IsReferenceParameter()); + b.setVal41(es.EntityId(e.Parameter())); + b.setVal42(es.EntityId(e.ParameterType())); + b.setVal43(es.EntityId(e.Replacement())); + b.setVal86(e.IsReferenceParameter()); } void SerializeStringLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::StringLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v84 = e.ContainsNonAscii(); - if (v84) { - b.setVal84(static_cast(v84.value())); - b.setVal85(true); + auto v85 = e.ContainsNonAscii(); + if (v85) { + b.setVal85(static_cast(v85.value())); + b.setVal86(true); } else { - b.setVal85(false); + b.setVal86(false); } - auto v86 = e.ContainsNonAsciiOrNull(); - if (v86) { - b.setVal86(static_cast(v86.value())); - b.setVal87(true); - } else { - b.setVal87(false); - } - b.setVal26(e.ByteLength()); - auto v61 = e.Bytes(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - b.setVal100(e.CharacterByteWidth()); - b.setVal89(static_cast(mx::FromPasta(e.LiteralKind()))); - b.setVal101(e.Length()); - b.setVal102(e.NumConcatenated()); - auto v66 = e.String(); - if (v66) { - if (v66->empty()) { - b.setVal66(""); - } else { - std::string s66(v66->data(), v66->size()); - b.setVal66(s66); - } + auto v87 = e.ContainsNonAsciiOrNull(); + if (v87) { + b.setVal87(static_cast(v87.value())); b.setVal88(true); } else { b.setVal88(false); } - b.setVal90(e.IsOrdinary()); - b.setVal92(e.IsPascal()); - b.setVal93(e.IsUTF16()); - b.setVal94(e.IsUTF32()); - b.setVal95(e.IsUTF8()); - b.setVal96(e.IsUnevaluated()); - b.setVal97(e.IsWide()); + b.setVal27(e.ByteLength()); + auto v62 = e.Bytes(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + b.setVal101(e.CharacterByteWidth()); + b.setVal90(static_cast(mx::FromPasta(e.LiteralKind()))); + b.setVal102(e.Length()); + b.setVal103(e.NumConcatenated()); + auto v67 = e.String(); + if (v67) { + if (v67->empty()) { + b.setVal67(""); + } else { + std::string s67(v67->data(), v67->size()); + b.setVal67(s67); + } + b.setVal89(true); + } else { + b.setVal89(false); + } + b.setVal91(e.IsOrdinary()); + b.setVal93(e.IsPascal()); + b.setVal94(e.IsUTF16()); + b.setVal95(e.IsUTF32()); + b.setVal96(e.IsUTF8()); + b.setVal97(e.IsUnevaluated()); + b.setVal98(e.IsWide()); } void SerializeStmtExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::StmtExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.LParenToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.LParenToken()); b.setVal39(et39); - b.setVal40(es.EntityId(e.SubStatement())); - b.setVal26(e.TemplateDepth()); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.SubStatement())); + b.setVal27(e.TemplateDepth()); } void SerializeSourceLocExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SourceLocExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v61 = e.BuiltinString(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - b.setVal89(static_cast(mx::FromPasta(e.IdentifierKind()))); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - b.setVal84(e.IsIntType()); + auto v62 = e.BuiltinString(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + b.setVal90(static_cast(mx::FromPasta(e.IdentifierKind()))); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + b.setVal85(e.IsIntType()); } void SerializeSizeOfPackExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SizeOfPackExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.OperatorToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.Pack())); - auto v26 = e.PackLength(); - if (v26) { - b.setVal26(static_cast(v26.value())); - b.setVal84(true); + auto et39 = es.EntityId(e.OperatorToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.Pack())); + auto v27 = e.PackLength(); + if (v27) { + b.setVal27(static_cast(v27.value())); + b.setVal85(true); } else { - b.setVal84(false); + b.setVal85(false); } - auto et40 = es.EntityId(e.PackToken()); - b.setVal40(et40); + auto et41 = es.EntityId(e.PackToken()); + b.setVal41(et41); do { - auto ov15 = e.PartialArguments(); - if (!ov15) { - b.setVal85(false); + auto ov16 = e.PartialArguments(); + if (!ov16) { + b.setVal86(false); break; } - b.setVal85(true); - auto v15 = std::move(*ov15); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + b.setVal86(true); + auto v16 = std::move(*ov16); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto et41 = es.EntityId(e.RParenToken()); - b.setVal41(et41); - b.setVal86(e.IsPartiallySubstituted()); + auto et42 = es.EntityId(e.RParenToken()); + b.setVal42(et42); + b.setVal87(e.IsPartiallySubstituted()); } void SerializeShuffleVectorExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ShuffleVectorExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.BuiltinToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.BuiltinToken()); b.setVal39(et39); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); } void SerializeSYCLUniqueStableNameExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SYCLUniqueStableNameExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal61(e.ComputeName()); - auto et38 = es.EntityId(e.LParenToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.Token()); + b.setVal62(e.ComputeName()); + auto et39 = es.EntityId(e.LParenToken()); b.setVal39(et39); - auto et40 = es.EntityId(e.RParenToken()); + auto et40 = es.EntityId(e.Token()); b.setVal40(et40); + auto et41 = es.EntityId(e.RParenToken()); + b.setVal41(et41); } void SerializeRequiresExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::RequiresExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Body())); - auto et39 = es.EntityId(e.LParenToken()); - b.setVal39(et39); + b.setVal39(es.EntityId(e.Body())); + auto et40 = es.EntityId(e.LParenToken()); + b.setVal40(et40); do { - auto v15 = e.LocalParameters(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.LocalParameters(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto et40 = es.EntityId(e.RBraceToken()); - b.setVal40(et40); - auto et41 = es.EntityId(e.RParenToken()); + auto et41 = es.EntityId(e.RBraceToken()); b.setVal41(et41); - auto et42 = es.EntityId(e.RequiresKeywordToken()); + auto et42 = es.EntityId(e.RParenToken()); b.setVal42(et42); + auto et43 = es.EntityId(e.RequiresKeywordToken()); + b.setVal43(et43); } void SerializeRecoveryExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::RecoveryExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.SubExpressions(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.SubExpressions(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -8114,25 +8115,25 @@ void SerializeRecoveryExpr(const PendingFragment &pf, const EntityMapper &es, mx void SerializePseudoObjectExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::PseudoObjectExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.ResultExpression())); - b.setVal26(e.ResultExpressionIndex()); - b.setVal39(es.EntityId(e.SyntacticForm())); + b.setVal39(es.EntityId(e.ResultExpression())); + b.setVal27(e.ResultExpressionIndex()); + b.setVal40(es.EntityId(e.SyntacticForm())); do { - auto v15 = e.Semantics(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Semantics(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); do { - auto v27 = e.SemanticExpressions(); - auto sv27 = b.initVal27(static_cast(v27.size())); - auto i27 = 0u; - for (const auto &e27 : v27) { - sv27.set(i27, es.EntityId(e27)); - ++i27; + auto v28 = e.SemanticExpressions(); + auto sv28 = b.initVal28(static_cast(v28.size())); + auto i28 = 0u; + for (const auto &e28 : v28) { + sv28.set(i28, es.EntityId(e28)); + ++i28; } } while (false); } @@ -8140,36 +8141,36 @@ void SerializePseudoObjectExpr(const PendingFragment &pf, const EntityMapper &es void SerializePredefinedExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::PredefinedExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.FunctionName(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); + auto v39 = e.FunctionName(); + if (v39) { + auto id39 = es.EntityId(v39.value()); + b.setVal39(id39); } else { - b.setVal38(mx::kInvalidEntityId); + b.setVal39(mx::kInvalidEntityId); } - b.setVal89(static_cast(mx::FromPasta(e.IdentifierKind()))); - auto v61 = e.IdentifierKindName(); - std::string s61(v61.data(), v61.size()); - b.setVal61(s61); - auto et39 = es.EntityId(e.Token()); - b.setVal39(et39); - b.setVal84(e.IsTransparent()); + b.setVal90(static_cast(mx::FromPasta(e.IdentifierKind()))); + auto v62 = e.IdentifierKindName(); + std::string s62(v62.data(), v62.size()); + b.setVal62(s62); + auto et40 = es.EntityId(e.Token()); + b.setVal40(et40); + b.setVal85(e.IsTransparent()); } void SerializeParenListExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ParenListExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.LParenToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.LParenToken()); b.setVal39(et39); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); do { - auto v15 = e.Expressions(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Expressions(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -8177,202 +8178,202 @@ void SerializeParenListExpr(const PendingFragment &pf, const EntityMapper &es, m void SerializeParenExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ParenExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.LParenToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.LParenToken()); b.setVal39(et39); - b.setVal40(es.EntityId(e.SubExpression())); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.SubExpression())); } void SerializePackExpansionExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::PackExpansionExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.EllipsisToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.Pattern())); + auto et39 = es.EntityId(e.EllipsisToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.Pattern())); } void SerializeOverloadExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OverloadExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.Declarations(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Declarations(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto et38 = es.EntityId(e.LAngleToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.NameToken()); + auto et39 = es.EntityId(e.LAngleToken()); b.setVal39(et39); - auto v40 = e.NamingClass(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + auto et40 = es.EntityId(e.NameToken()); + b.setVal40(et40); + auto v41 = e.NamingClass(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - auto et41 = es.EntityId(e.RAngleToken()); - b.setVal41(et41); - auto et42 = es.EntityId(e.TemplateKeywordToken()); + auto et42 = es.EntityId(e.RAngleToken()); b.setVal42(et42); - b.setVal84(e.HasExplicitTemplateArguments()); - b.setVal85(e.HasTemplateKeyword()); + auto et43 = es.EntityId(e.TemplateKeywordToken()); + b.setVal43(et43); + b.setVal85(e.HasExplicitTemplateArguments()); + b.setVal86(e.HasTemplateKeyword()); } void SerializeUnresolvedMemberExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::UnresolvedMemberExpr &e, const TokenTree *) { (void) pf; SerializeOverloadExpr(pf, es, b, e, nullptr); - b.setVal43(es.EntityId(e.BaseType())); - auto et44 = es.EntityId(e.MemberToken()); - b.setVal44(et44); - auto et45 = es.EntityId(e.OperatorToken()); + b.setVal44(es.EntityId(e.BaseType())); + auto et45 = es.EntityId(e.MemberToken()); b.setVal45(et45); - b.setVal86(e.HasUnresolvedUsing()); - b.setVal87(e.IsArrow()); - b.setVal88(e.IsImplicitAccess()); + auto et46 = es.EntityId(e.OperatorToken()); + b.setVal46(et46); + b.setVal87(e.HasUnresolvedUsing()); + b.setVal88(e.IsArrow()); + b.setVal89(e.IsImplicitAccess()); } void SerializeUnresolvedLookupExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::UnresolvedLookupExpr &e, const TokenTree *) { (void) pf; SerializeOverloadExpr(pf, es, b, e, nullptr); - b.setVal86(e.IsOverloaded()); - b.setVal87(e.RequiresADL()); + b.setVal87(e.IsOverloaded()); + b.setVal88(e.RequiresADL()); } void SerializeOpaqueValueExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OpaqueValueExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - auto v39 = e.SourceExpression(); - if (v39) { - auto id39 = es.EntityId(v39.value()); - b.setVal39(id39); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + auto v40 = e.SourceExpression(); + if (v40) { + auto id40 = es.EntityId(v40.value()); + b.setVal40(id40); } else { - b.setVal39(mx::kInvalidEntityId); + b.setVal40(mx::kInvalidEntityId); } - b.setVal84(e.IsUnique()); + b.setVal85(e.IsUnique()); } void SerializeOffsetOfExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OffsetOfExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.OperatorToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.OperatorToken()); b.setVal39(et39); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); } void SerializeObjCSubscriptRefExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCSubscriptRefExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.AtIndexMethodDeclaration())); - b.setVal39(es.EntityId(e.BaseExpression())); - b.setVal40(es.EntityId(e.KeyExpression())); - auto et41 = es.EntityId(e.RBracketToken()); - b.setVal41(et41); - b.setVal84(e.IsArraySubscriptReferenceExpression()); + b.setVal39(es.EntityId(e.AtIndexMethodDeclaration())); + b.setVal40(es.EntityId(e.BaseExpression())); + b.setVal41(es.EntityId(e.KeyExpression())); + auto et42 = es.EntityId(e.RBracketToken()); + b.setVal42(et42); + b.setVal85(e.IsArraySubscriptReferenceExpression()); } void SerializeObjCStringLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCStringLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.AtToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.String())); + auto et39 = es.EntityId(e.AtToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.String())); } void SerializeObjCSelectorExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCSelectorExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.AtToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.AtToken()); b.setVal39(et39); + auto et40 = es.EntityId(e.RParenToken()); + b.setVal40(et40); } void SerializeObjCProtocolExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCProtocolExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.AtToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.Protocol())); - auto et40 = es.EntityId(e.ProtocolIdToken()); - b.setVal40(et40); - auto et41 = es.EntityId(e.RParenToken()); + auto et39 = es.EntityId(e.AtToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.Protocol())); + auto et41 = es.EntityId(e.ProtocolIdToken()); b.setVal41(et41); + auto et42 = es.EntityId(e.RParenToken()); + b.setVal42(et42); } void SerializeObjCPropertyRefExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCPropertyRefExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - b.setVal39(es.EntityId(e.ClassReceiver())); - b.setVal40(es.EntityId(e.ExplicitProperty())); - b.setVal41(es.EntityId(e.ImplicitPropertyGetter())); - b.setVal42(es.EntityId(e.ImplicitPropertySetter())); - auto et43 = es.EntityId(e.Token()); - b.setVal43(et43); - auto et44 = es.EntityId(e.ReceiverToken()); + b.setVal39(es.EntityId(e.Base())); + b.setVal40(es.EntityId(e.ClassReceiver())); + b.setVal41(es.EntityId(e.ExplicitProperty())); + b.setVal42(es.EntityId(e.ImplicitPropertyGetter())); + b.setVal43(es.EntityId(e.ImplicitPropertySetter())); + auto et44 = es.EntityId(e.Token()); b.setVal44(et44); - b.setVal45(es.EntityId(e.ReceiverType())); - b.setVal46(es.EntityId(e.SuperReceiverType())); - b.setVal84(e.IsClassReceiver()); - b.setVal85(e.IsExplicitProperty()); - b.setVal86(e.IsImplicitProperty()); - b.setVal87(e.IsMessagingGetter()); - b.setVal88(e.IsMessagingSetter()); - b.setVal90(e.IsObjectReceiver()); - b.setVal92(e.IsSuperReceiver()); + auto et45 = es.EntityId(e.ReceiverToken()); + b.setVal45(et45); + b.setVal46(es.EntityId(e.ReceiverType())); + b.setVal47(es.EntityId(e.SuperReceiverType())); + b.setVal85(e.IsClassReceiver()); + b.setVal86(e.IsExplicitProperty()); + b.setVal87(e.IsImplicitProperty()); + b.setVal88(e.IsMessagingGetter()); + b.setVal89(e.IsMessagingSetter()); + b.setVal91(e.IsObjectReceiver()); + b.setVal93(e.IsSuperReceiver()); } void SerializeObjCMessageExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCMessageExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.Arguments(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Arguments(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - b.setVal38(es.EntityId(e.CallReturnType())); - b.setVal39(es.EntityId(e.ClassReceiver())); - b.setVal40(es.EntityId(e.InstanceReceiver())); - auto et41 = es.EntityId(e.LeftToken()); - b.setVal41(et41); - b.setVal42(es.EntityId(e.MethodDeclaration())); - b.setVal89(static_cast(mx::FromPasta(e.MethodFamily()))); - b.setVal43(es.EntityId(e.ReceiverInterface())); - b.setVal91(static_cast(mx::FromPasta(e.ReceiverKind()))); - auto p44 = es.EntityIds(e.ReceiverRange()); - b.setVal44(p44.first); - b.setVal45(p44.second); - b.setVal46(es.EntityId(e.ReceiverType())); - auto et47 = es.EntityId(e.RightToken()); - b.setVal47(et47); - auto et48 = es.EntityId(e.SelectorStartToken()); + b.setVal39(es.EntityId(e.CallReturnType())); + b.setVal40(es.EntityId(e.ClassReceiver())); + b.setVal41(es.EntityId(e.InstanceReceiver())); + auto et42 = es.EntityId(e.LeftToken()); + b.setVal42(et42); + b.setVal43(es.EntityId(e.MethodDeclaration())); + b.setVal90(static_cast(mx::FromPasta(e.MethodFamily()))); + b.setVal44(es.EntityId(e.ReceiverInterface())); + b.setVal92(static_cast(mx::FromPasta(e.ReceiverKind()))); + auto p45 = es.EntityIds(e.ReceiverRange()); + b.setVal45(p45.first); + b.setVal46(p45.second); + b.setVal47(es.EntityId(e.ReceiverType())); + auto et48 = es.EntityId(e.RightToken()); b.setVal48(et48); - auto et49 = es.EntityId(e.SuperToken()); + auto et49 = es.EntityId(e.SelectorStartToken()); b.setVal49(et49); - b.setVal50(es.EntityId(e.SuperType())); - b.setVal84(e.IsClassMessage()); - b.setVal85(e.IsDelegateInitializerCall()); - b.setVal86(e.IsImplicit()); - b.setVal87(e.IsInstanceMessage()); + auto et50 = es.EntityId(e.SuperToken()); + b.setVal50(et50); + b.setVal51(es.EntityId(e.SuperType())); + b.setVal85(e.IsClassMessage()); + b.setVal86(e.IsDelegateInitializerCall()); + b.setVal87(e.IsImplicit()); + b.setVal88(e.IsInstanceMessage()); do { - auto v27 = e.SelectorTokens(); - auto sv27 = b.initVal27(static_cast(v27.size())); - auto i27 = 0u; - for (const auto &e27 : v27) { - sv27.set(i27, es.EntityId(e27)); - ++i27; + auto v28 = e.SelectorTokens(); + auto sv28 = b.initVal28(static_cast(v28.size())); + auto i28 = 0u; + for (const auto &e28 : v28) { + sv28.set(i28, es.EntityId(e28)); + ++i28; } } while (false); } @@ -8380,87 +8381,87 @@ void SerializeObjCMessageExpr(const PendingFragment &pf, const EntityMapper &es, void SerializeObjCIvarRefExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCIvarRefExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - b.setVal39(es.EntityId(e.Declaration())); - auto et40 = es.EntityId(e.Token()); - b.setVal40(et40); - auto et41 = es.EntityId(e.OperationToken()); + b.setVal39(es.EntityId(e.Base())); + b.setVal40(es.EntityId(e.Declaration())); + auto et41 = es.EntityId(e.Token()); b.setVal41(et41); - b.setVal84(e.IsArrow()); - b.setVal85(e.IsFreeInstanceVariable()); + auto et42 = es.EntityId(e.OperationToken()); + b.setVal42(et42); + b.setVal85(e.IsArrow()); + b.setVal86(e.IsFreeInstanceVariable()); } void SerializeObjCIsaExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCIsaExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - auto et39 = es.EntityId(e.BaseTokenEnd()); - b.setVal39(et39); - auto et40 = es.EntityId(e.IsaMemberToken()); + b.setVal39(es.EntityId(e.Base())); + auto et40 = es.EntityId(e.BaseTokenEnd()); b.setVal40(et40); - auto et41 = es.EntityId(e.OperationToken()); + auto et41 = es.EntityId(e.IsaMemberToken()); b.setVal41(et41); - b.setVal84(e.IsArrow()); + auto et42 = es.EntityId(e.OperationToken()); + b.setVal42(et42); + b.setVal85(e.IsArrow()); } void SerializeObjCIndirectCopyRestoreExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCIndirectCopyRestoreExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.SubExpression())); - b.setVal84(e.ShouldCopy()); + b.setVal39(es.EntityId(e.SubExpression())); + b.setVal85(e.ShouldCopy()); } void SerializeObjCEncodeExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCEncodeExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.AtToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.EncodedType())); - auto et40 = es.EntityId(e.RParenToken()); - b.setVal40(et40); + auto et39 = es.EntityId(e.AtToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.EncodedType())); + auto et41 = es.EntityId(e.RParenToken()); + b.setVal41(et41); } void SerializeObjCDictionaryLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCDictionaryLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.DictionaryWithObjectsMethod())); + b.setVal39(es.EntityId(e.DictionaryWithObjectsMethod())); } void SerializeObjCBoxedExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCBoxedExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.AtToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.BoxingMethod())); - b.setVal40(es.EntityId(e.SubExpression())); - b.setVal84(e.IsExpressibleAsConstantInitializer()); + auto et39 = es.EntityId(e.AtToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.BoxingMethod())); + b.setVal41(es.EntityId(e.SubExpression())); + b.setVal85(e.IsExpressibleAsConstantInitializer()); } void SerializeObjCBoolLiteralExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCBoolLiteralExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - b.setVal84(e.Value()); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + b.setVal85(e.Value()); } void SerializeObjCAvailabilityCheckExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCAvailabilityCheckExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal84(e.HasVersion()); + b.setVal85(e.HasVersion()); } void SerializeObjCArrayLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ObjCArrayLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.ArrayWithObjectsMethod())); + b.setVal39(es.EntityId(e.ArrayWithObjectsMethod())); do { - auto v15 = e.Elements(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Elements(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -8468,46 +8469,46 @@ void SerializeObjCArrayLiteral(const PendingFragment &pf, const EntityMapper &es void SerializeOMPIteratorExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPIteratorExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.IteratorKwToken()); - b.setVal38(et38); - auto et39 = es.EntityId(e.LParenToken()); + auto et39 = es.EntityId(e.IteratorKwToken()); b.setVal39(et39); - auto et40 = es.EntityId(e.RParenToken()); + auto et40 = es.EntityId(e.LParenToken()); b.setVal40(et40); + auto et41 = es.EntityId(e.RParenToken()); + b.setVal41(et41); } void SerializeOMPArrayShapingExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPArrayShapingExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); + b.setVal39(es.EntityId(e.Base())); do { - auto v15 = e.Dimensions(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Dimensions(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto et39 = es.EntityId(e.LParenToken()); - b.setVal39(et39); - auto et40 = es.EntityId(e.RParenToken()); + auto et40 = es.EntityId(e.LParenToken()); b.setVal40(et40); + auto et41 = es.EntityId(e.RParenToken()); + b.setVal41(et41); } void SerializeOMPArraySectionExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::OMPArraySectionExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - auto et39 = es.EntityId(e.FirstColonToken()); - b.setVal39(et39); - auto et40 = es.EntityId(e.SecondColonToken()); + b.setVal39(es.EntityId(e.Base())); + auto et40 = es.EntityId(e.FirstColonToken()); b.setVal40(et40); - b.setVal41(es.EntityId(e.Length())); - b.setVal42(es.EntityId(e.LowerBound())); - auto et43 = es.EntityId(e.RBracketToken()); - b.setVal43(et43); - b.setVal44(es.EntityId(e.Stride())); + auto et41 = es.EntityId(e.SecondColonToken()); + b.setVal41(et41); + b.setVal42(es.EntityId(e.Length())); + b.setVal43(es.EntityId(e.LowerBound())); + auto et44 = es.EntityId(e.RBracketToken()); + b.setVal44(et44); + b.setVal45(es.EntityId(e.Stride())); } void SerializeNoInitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::NoInitExpr &e, const TokenTree *) { @@ -8518,195 +8519,195 @@ void SerializeNoInitExpr(const PendingFragment &pf, const EntityMapper &es, mx:: void SerializeMemberExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MemberExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - auto et39 = es.EntityId(e.LAngleToken()); - b.setVal39(et39); - b.setVal40(es.EntityId(e.MemberDeclaration())); - auto et41 = es.EntityId(e.MemberToken()); - b.setVal41(et41); - auto et42 = es.EntityId(e.OperatorToken()); + b.setVal39(es.EntityId(e.Base())); + auto et40 = es.EntityId(e.LAngleToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.MemberDeclaration())); + auto et42 = es.EntityId(e.MemberToken()); b.setVal42(et42); - auto et43 = es.EntityId(e.RAngleToken()); + auto et43 = es.EntityId(e.OperatorToken()); b.setVal43(et43); - auto et44 = es.EntityId(e.TemplateKeywordToken()); + auto et44 = es.EntityId(e.RAngleToken()); b.setVal44(et44); - b.setVal84(e.HadMultipleCandidates()); - b.setVal85(e.HasExplicitTemplateArguments()); - b.setVal86(e.HasQualifier()); - b.setVal87(e.HasTemplateKeyword()); - b.setVal88(e.IsArrow()); - b.setVal90(e.IsImplicitAccess()); - b.setVal89(static_cast(mx::FromPasta(e.IsNonOdrUse()))); + auto et45 = es.EntityId(e.TemplateKeywordToken()); + b.setVal45(et45); + b.setVal85(e.HadMultipleCandidates()); + b.setVal86(e.HasExplicitTemplateArguments()); + b.setVal87(e.HasQualifier()); + b.setVal88(e.HasTemplateKeyword()); + b.setVal89(e.IsArrow()); + b.setVal91(e.IsImplicitAccess()); + b.setVal90(static_cast(mx::FromPasta(e.IsNonOdrUse()))); } void SerializeMatrixSubscriptExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MatrixSubscriptExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - b.setVal39(es.EntityId(e.ColumnIndex())); - auto et40 = es.EntityId(e.RBracketToken()); - b.setVal40(et40); - b.setVal41(es.EntityId(e.RowIndex())); - b.setVal84(e.IsIncomplete()); + b.setVal39(es.EntityId(e.Base())); + b.setVal40(es.EntityId(e.ColumnIndex())); + auto et41 = es.EntityId(e.RBracketToken()); + b.setVal41(et41); + b.setVal42(es.EntityId(e.RowIndex())); + b.setVal85(e.IsIncomplete()); } void SerializeMaterializeTemporaryExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MaterializeTemporaryExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.ExtendingDeclaration(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); - } else { - b.setVal38(mx::kInvalidEntityId); - } - auto v39 = e.LifetimeExtendedTemporaryDeclaration(); + auto v39 = e.ExtendingDeclaration(); if (v39) { auto id39 = es.EntityId(v39.value()); b.setVal39(id39); } else { b.setVal39(mx::kInvalidEntityId); } - b.setVal26(e.ManglingNumber()); - b.setVal89(static_cast(mx::FromPasta(e.StorageDuration()))); - b.setVal40(es.EntityId(e.SubExpression())); - b.setVal84(e.IsBoundToLvalueReference()); - b.setVal85(e.IsUsableInConstantExpressions()); + auto v40 = e.LifetimeExtendedTemporaryDeclaration(); + if (v40) { + auto id40 = es.EntityId(v40.value()); + b.setVal40(id40); + } else { + b.setVal40(mx::kInvalidEntityId); + } + b.setVal27(e.ManglingNumber()); + b.setVal90(static_cast(mx::FromPasta(e.StorageDuration()))); + b.setVal41(es.EntityId(e.SubExpression())); + b.setVal85(e.IsBoundToLvalueReference()); + b.setVal86(e.IsUsableInConstantExpressions()); } void SerializeMSPropertySubscriptExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MSPropertySubscriptExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Base())); - b.setVal39(es.EntityId(e.Index())); - auto et40 = es.EntityId(e.RBracketToken()); - b.setVal40(et40); + b.setVal39(es.EntityId(e.Base())); + b.setVal40(es.EntityId(e.Index())); + auto et41 = es.EntityId(e.RBracketToken()); + b.setVal41(et41); } void SerializeMSPropertyRefExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::MSPropertyRefExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.BaseExpression())); - auto et39 = es.EntityId(e.MemberToken()); - b.setVal39(et39); - b.setVal40(es.EntityId(e.PropertyDeclaration())); - b.setVal84(e.IsArrow()); - b.setVal85(e.IsImplicitAccess()); + b.setVal39(es.EntityId(e.BaseExpression())); + auto et40 = es.EntityId(e.MemberToken()); + b.setVal40(et40); + b.setVal41(es.EntityId(e.PropertyDeclaration())); + b.setVal85(e.IsArrow()); + b.setVal86(e.IsImplicitAccess()); } void SerializeLambdaExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::LambdaExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.Body())); - b.setVal39(es.EntityId(e.CallOperator())); - b.setVal89(static_cast(mx::FromPasta(e.CaptureDefault()))); - auto et40 = es.EntityId(e.CaptureDefaultToken()); - b.setVal40(et40); - b.setVal41(es.EntityId(e.CompoundStatementBody())); - auto v42 = e.DependentCallOperator(); - if (v42) { - auto id42 = es.EntityId(v42.value()); - b.setVal42(id42); + b.setVal39(es.EntityId(e.Body())); + b.setVal40(es.EntityId(e.CallOperator())); + b.setVal90(static_cast(mx::FromPasta(e.CaptureDefault()))); + auto et41 = es.EntityId(e.CaptureDefaultToken()); + b.setVal41(et41); + b.setVal42(es.EntityId(e.CompoundStatementBody())); + auto v43 = e.DependentCallOperator(); + if (v43) { + auto id43 = es.EntityId(v43.value()); + b.setVal43(id43); } else { - b.setVal42(mx::kInvalidEntityId); + b.setVal43(mx::kInvalidEntityId); } do { - auto v15 = e.ExplicitTemplateParameters(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.ExplicitTemplateParameters(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto p43 = es.EntityIds(e.IntroducerRange()); - b.setVal43(p43.first); - b.setVal44(p43.second); - b.setVal45(es.EntityId(e.LambdaClass())); - auto v46 = e.TemplateParameterList(); - if (v46) { - auto id46 = es.EntityId(v46.value()); - b.setVal46(id46); - } else { - b.setVal46(mx::kInvalidEntityId); - } - auto v47 = e.TrailingRequiresClause(); + auto p44 = es.EntityIds(e.IntroducerRange()); + b.setVal44(p44.first); + b.setVal45(p44.second); + b.setVal46(es.EntityId(e.LambdaClass())); + auto v47 = e.TemplateParameterList(); if (v47) { auto id47 = es.EntityId(v47.value()); b.setVal47(id47); } else { b.setVal47(mx::kInvalidEntityId); } - b.setVal84(e.HasExplicitParameters()); - b.setVal85(e.HasExplicitResultType()); - b.setVal86(e.IsGenericLambda()); - b.setVal87(e.IsMutable()); + auto v48 = e.TrailingRequiresClause(); + if (v48) { + auto id48 = es.EntityId(v48.value()); + b.setVal48(id48); + } else { + b.setVal48(mx::kInvalidEntityId); + } + b.setVal85(e.HasExplicitParameters()); + b.setVal86(e.HasExplicitResultType()); + b.setVal87(e.IsGenericLambda()); + b.setVal88(e.IsMutable()); } void SerializeIntegerLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::IntegerLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); } void SerializeInitListExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::InitListExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto v38 = e.ArrayFiller(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); - } else { - b.setVal38(mx::kInvalidEntityId); - } - auto v39 = e.InitializedFieldInUnion(); + auto v39 = e.ArrayFiller(); if (v39) { auto id39 = es.EntityId(v39.value()); b.setVal39(id39); } else { b.setVal39(mx::kInvalidEntityId); } - auto et40 = es.EntityId(e.LBraceToken()); - b.setVal40(et40); - auto et41 = es.EntityId(e.RBraceToken()); - b.setVal41(et41); - auto v42 = e.SemanticForm(); - if (v42) { - auto id42 = es.EntityId(v42.value()); - b.setVal42(id42); + auto v40 = e.InitializedFieldInUnion(); + if (v40) { + auto id40 = es.EntityId(v40.value()); + b.setVal40(id40); } else { - b.setVal42(mx::kInvalidEntityId); + b.setVal40(mx::kInvalidEntityId); } - auto v43 = e.SyntacticForm(); + auto et41 = es.EntityId(e.LBraceToken()); + b.setVal41(et41); + auto et42 = es.EntityId(e.RBraceToken()); + b.setVal42(et42); + auto v43 = e.SemanticForm(); if (v43) { auto id43 = es.EntityId(v43.value()); b.setVal43(id43); } else { b.setVal43(mx::kInvalidEntityId); } - b.setVal84(e.HadArrayRangeDesignator()); - b.setVal85(e.HasArrayFiller()); - b.setVal86(e.HasDesignatedInitializer()); + auto v44 = e.SyntacticForm(); + if (v44) { + auto id44 = es.EntityId(v44.value()); + b.setVal44(id44); + } else { + b.setVal44(mx::kInvalidEntityId); + } + b.setVal85(e.HadArrayRangeDesignator()); + b.setVal86(e.HasArrayFiller()); + b.setVal87(e.HasDesignatedInitializer()); do { - auto v15 = e.Initializers(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Initializers(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - b.setVal87(e.IsExplicit()); - b.setVal88(e.IsSemanticForm()); - b.setVal90(e.IsStringLiteralInitializer()); - b.setVal92(e.IsSyntacticForm()); - auto v93 = e.IsTransparent(); - if (v93) { - b.setVal93(static_cast(v93.value())); - b.setVal94(true); + b.setVal88(e.IsExplicit()); + b.setVal89(e.IsSemanticForm()); + b.setVal91(e.IsStringLiteralInitializer()); + b.setVal93(e.IsSyntacticForm()); + auto v94 = e.IsTransparent(); + if (v94) { + b.setVal94(static_cast(v94.value())); + b.setVal95(true); } else { - b.setVal94(false); + b.setVal95(false); } } @@ -8718,74 +8719,74 @@ void SerializeImplicitValueInitExpr(const PendingFragment &pf, const EntityMappe void SerializeImaginaryLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ImaginaryLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.SubExpression())); + b.setVal39(es.EntityId(e.SubExpression())); } void SerializeGenericSelectionExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::GenericSelectionExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); do { - auto v15 = e.AssociationExpressions(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.AssociationExpressions(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - auto v38 = e.ControllingExpression(); - if (v38) { - auto id38 = es.EntityId(v38.value()); - b.setVal38(id38); - } else { - b.setVal38(mx::kInvalidEntityId); - } - auto v39 = e.ControllingType(); + auto v39 = e.ControllingExpression(); if (v39) { auto id39 = es.EntityId(v39.value()); b.setVal39(id39); } else { b.setVal39(mx::kInvalidEntityId); } - auto et40 = es.EntityId(e.DefaultToken()); - b.setVal40(et40); - auto et41 = es.EntityId(e.GenericToken()); + auto v40 = e.ControllingType(); + if (v40) { + auto id40 = es.EntityId(v40.value()); + b.setVal40(id40); + } else { + b.setVal40(mx::kInvalidEntityId); + } + auto et41 = es.EntityId(e.DefaultToken()); b.setVal41(et41); - auto et42 = es.EntityId(e.RParenToken()); + auto et42 = es.EntityId(e.GenericToken()); b.setVal42(et42); - auto v43 = e.ResultExpression(); - if (v43) { - auto id43 = es.EntityId(v43.value()); - b.setVal43(id43); + auto et43 = es.EntityId(e.RParenToken()); + b.setVal43(et43); + auto v44 = e.ResultExpression(); + if (v44) { + auto id44 = es.EntityId(v44.value()); + b.setVal44(id44); } else { - b.setVal43(mx::kInvalidEntityId); + b.setVal44(mx::kInvalidEntityId); } - b.setVal26(e.ResultIndex()); - b.setVal84(e.IsExpressionPredicate()); - b.setVal85(e.IsResultDependent()); - b.setVal86(e.IsTypePredicate()); + b.setVal27(e.ResultIndex()); + b.setVal85(e.IsExpressionPredicate()); + b.setVal86(e.IsResultDependent()); + b.setVal87(e.IsTypePredicate()); } void SerializeGNUNullExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::GNUNullExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.TokenToken()); - b.setVal38(et38); + auto et39 = es.EntityId(e.TokenToken()); + b.setVal39(et39); } void SerializeFunctionParmPackExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::FunctionParmPackExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.ParameterPack())); - auto et39 = es.EntityId(e.ParameterPackToken()); - b.setVal39(et39); + b.setVal39(es.EntityId(e.ParameterPack())); + auto et40 = es.EntityId(e.ParameterPackToken()); + b.setVal40(et40); do { - auto v15 = e.Expansions(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Expansions(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); } @@ -8793,157 +8794,157 @@ void SerializeFunctionParmPackExpr(const PendingFragment &pf, const EntityMapper void SerializeFullExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::FullExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.SubExpression())); + b.setVal39(es.EntityId(e.SubExpression())); } void SerializeExprWithCleanups(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ExprWithCleanups &e, const TokenTree *) { (void) pf; SerializeFullExpr(pf, es, b, e, nullptr); - b.setVal84(e.CleanupsHaveSideEffects()); + b.setVal85(e.CleanupsHaveSideEffects()); } void SerializeConstantExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ConstantExpr &e, const TokenTree *) { (void) pf; SerializeFullExpr(pf, es, b, e, nullptr); - b.setVal89(static_cast(mx::FromPasta(e.ResultStorageKind()))); - b.setVal84(e.HasAPValueResult()); - b.setVal85(e.IsImmediateInvocation()); + b.setVal90(static_cast(mx::FromPasta(e.ResultStorageKind()))); + b.setVal85(e.HasAPValueResult()); + b.setVal86(e.IsImmediateInvocation()); } void SerializeFloatingLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::FloatingLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - b.setVal84(e.IsExact()); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + b.setVal85(e.IsExact()); } void SerializeFixedPointLiteral(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::FixedPointLiteral &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - auto et38 = es.EntityId(e.Token()); - b.setVal38(et38); - b.setVal26(e.Scale()); + auto et39 = es.EntityId(e.Token()); + b.setVal39(et39); + b.setVal27(e.Scale()); } void SerializeExtVectorElementExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ExtVectorElementExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal84(e.ContainsDuplicateElements()); - auto et38 = es.EntityId(e.AccessorToken()); - b.setVal38(et38); - b.setVal39(es.EntityId(e.Base())); - b.setVal85(e.IsArrow()); + b.setVal85(e.ContainsDuplicateElements()); + auto et39 = es.EntityId(e.AccessorToken()); + b.setVal39(et39); + b.setVal40(es.EntityId(e.Base())); + b.setVal86(e.IsArrow()); } void SerializeExpressionTraitExpr(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::ExpressionTraitExpr &e, const TokenTree *) { (void) pf; SerializeExpr(pf, es, b, e, nullptr); - b.setVal38(es.EntityId(e.QueriedExpression())); - b.setVal89(static_cast(mx::FromPasta(e.Trait()))); - b.setVal84(e.Value()); + b.setVal39(es.EntityId(e.QueriedExpression())); + b.setVal90(static_cast(mx::FromPasta(e.Trait()))); + b.setVal85(e.Value()); } void SerializeAttributedStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::AttributedStmt &e, const TokenTree *) { (void) pf; SerializeValueStmt(pf, es, b, e, nullptr); - auto et10 = es.EntityId(e.AttributeToken()); - b.setVal10(et10); + auto et11 = es.EntityId(e.AttributeToken()); + b.setVal11(et11); do { - auto v15 = e.Attributes(); - auto sv15 = b.initVal15(static_cast(v15.size())); - auto i15 = 0u; - for (const auto &e15 : v15) { - sv15.set(i15, es.EntityId(e15)); - ++i15; + auto v16 = e.Attributes(); + auto sv16 = b.initVal16(static_cast(v16.size())); + auto i16 = 0u; + for (const auto &e16 : v16) { + sv16.set(i16, es.EntityId(e16)); + ++i16; } } while (false); - b.setVal11(es.EntityId(e.SubStatement())); + b.setVal12(es.EntityId(e.SubStatement())); } void SerializeSwitchStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SwitchStmt &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - b.setVal9(es.EntityId(e.Body())); - b.setVal10(es.EntityId(e.Condition())); - auto v11 = e.ConditionVariable(); - if (v11) { - auto id11 = es.EntityId(v11.value()); - b.setVal11(id11); - } else { - b.setVal11(mx::kInvalidEntityId); - } - auto v13 = e.ConditionVariableDeclarationStatement(); - if (v13) { - auto id13 = es.EntityId(v13.value()); - b.setVal13(id13); + b.setVal10(es.EntityId(e.Body())); + b.setVal11(es.EntityId(e.Condition())); + auto v12 = e.ConditionVariable(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); } else { - b.setVal13(mx::kInvalidEntityId); + b.setVal12(mx::kInvalidEntityId); } - auto v14 = e.Initializer(); + auto v14 = e.ConditionVariableDeclarationStatement(); if (v14) { auto id14 = es.EntityId(v14.value()); b.setVal14(id14); } else { b.setVal14(mx::kInvalidEntityId); } - auto et17 = es.EntityId(e.LParenToken()); - b.setVal17(et17); - auto et18 = es.EntityId(e.RParenToken()); + auto v15 = e.Initializer(); + if (v15) { + auto id15 = es.EntityId(v15.value()); + b.setVal15(id15); + } else { + b.setVal15(mx::kInvalidEntityId); + } + auto et18 = es.EntityId(e.LParenToken()); b.setVal18(et18); - auto v19 = e.FirstSwitchCase(); - if (v19) { - auto id19 = es.EntityId(v19.value()); - b.setVal19(id19); + auto et19 = es.EntityId(e.RParenToken()); + b.setVal19(et19); + auto v20 = e.FirstSwitchCase(); + if (v20) { + auto id20 = es.EntityId(v20.value()); + b.setVal20(id20); } else { - b.setVal19(mx::kInvalidEntityId); + b.setVal20(mx::kInvalidEntityId); } - auto et20 = es.EntityId(e.SwitchToken()); - b.setVal20(et20); - b.setVal12(e.HasInitializerStorage()); - b.setVal16(e.HasVariableStorage()); - b.setVal23(e.IsAllEnumCasesCovered()); + auto et21 = es.EntityId(e.SwitchToken()); + b.setVal21(et21); + b.setVal13(e.HasInitializerStorage()); + b.setVal17(e.HasVariableStorage()); + b.setVal24(e.IsAllEnumCasesCovered()); } void SerializeSwitchCase(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::SwitchCase &e, const TokenTree *) { (void) pf; SerializeStmt(pf, es, b, e, nullptr); - auto et9 = es.EntityId(e.ColonToken()); - b.setVal9(et9); - auto et10 = es.EntityId(e.KeywordToken()); + auto et10 = es.EntityId(e.ColonToken()); b.setVal10(et10); - auto v11 = e.NextSwitchCase(); - if (v11) { - auto id11 = es.EntityId(v11.value()); - b.setVal11(id11); + auto et11 = es.EntityId(e.KeywordToken()); + b.setVal11(et11); + auto v12 = e.NextSwitchCase(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); } else { - b.setVal11(mx::kInvalidEntityId); + b.setVal12(mx::kInvalidEntityId); } - b.setVal13(es.EntityId(e.SubStatement())); + b.setVal14(es.EntityId(e.SubStatement())); } void SerializeDefaultStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::DefaultStmt &e, const TokenTree *) { (void) pf; SerializeSwitchCase(pf, es, b, e, nullptr); - auto et14 = es.EntityId(e.DefaultToken()); - b.setVal14(et14); + auto et15 = es.EntityId(e.DefaultToken()); + b.setVal15(et15); } void SerializeCaseStmt(const PendingFragment &pf, const EntityMapper &es, mx::ast::Stmt::Builder b, const pasta::CaseStmt &e, const TokenTree *) { (void) pf; SerializeSwitchCase(pf, es, b, e, nullptr); - b.setVal12(e.CaseStatementIsGNURange()); - auto et14 = es.EntityId(e.CaseToken()); - b.setVal14(et14); - auto et17 = es.EntityId(e.EllipsisToken()); - b.setVal17(et17); - b.setVal18(es.EntityId(e.LHS())); - auto v19 = e.RHS(); - if (v19) { - auto id19 = es.EntityId(v19.value()); - b.setVal19(id19); + b.setVal13(e.CaseStatementIsGNURange()); + auto et15 = es.EntityId(e.CaseToken()); + b.setVal15(et15); + auto et18 = es.EntityId(e.EllipsisToken()); + b.setVal18(et18); + b.setVal19(es.EntityId(e.LHS())); + auto v20 = e.RHS(); + if (v20) { + auto id20 = es.EntityId(v20.value()); + b.setVal20(id20); } else { - b.setVal19(mx::kInvalidEntityId); + b.setVal20(mx::kInvalidEntityId); } } @@ -8954,77 +8955,78 @@ void SerializeDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::D (void) e; b.setVal0(es.ParentDeclId(e)); b.setVal1(es.ParentStmtId(e)); - b.setVal2(IsDefinition(e)); + b.setVal2(es.IREntityId(e)); + b.setVal3(IsDefinition(e)); do { - auto v3 = e.Attributes(); - auto sv3 = b.initVal3(static_cast(v3.size())); - auto i3 = 0u; - for (const auto &e3 : v3) { - sv3.set(i3, es.EntityId(e3)); - ++i3; + auto v4 = e.Attributes(); + auto sv4 = b.initVal4(static_cast(v4.size())); + auto i4 = 0u; + for (const auto &e4 : v4) { + sv4.set(i4, es.EntityId(e4)); + ++i4; } } while (false); - b.setVal4(static_cast(mx::FromPasta(e.Availability()))); - auto v5 = e.DefiningAttribute(); - if (v5) { - auto id5 = es.EntityId(v5.value()); - b.setVal5(id5); - } else { - b.setVal5(mx::kInvalidEntityId); - } - auto v6 = e.ExternalSourceSymbolAttribute(); + b.setVal5(static_cast(mx::FromPasta(e.Availability()))); + auto v6 = e.DefiningAttribute(); if (v6) { auto id6 = es.EntityId(v6.value()); b.setVal6(id6); } else { b.setVal6(mx::kInvalidEntityId); } - b.setVal7(static_cast(mx::FromPasta(e.FriendObjectKind()))); - auto v8 = e.MaxAlignment(); - if (v8) { - b.setVal8(static_cast(v8.value())); - b.setVal9(true); + auto v7 = e.ExternalSourceSymbolAttribute(); + if (v7) { + auto id7 = es.EntityId(v7.value()); + b.setVal7(id7); } else { - b.setVal9(false); + b.setVal7(mx::kInvalidEntityId); } - b.setVal10(static_cast(mx::FromPasta(e.ModuleOwnershipKind()))); - auto v11 = e.NonClosureContext(); - if (v11) { - auto id11 = es.EntityId(v11.value()); - b.setVal11(id11); + b.setVal8(static_cast(mx::FromPasta(e.FriendObjectKind()))); + auto v9 = e.MaxAlignment(); + if (v9) { + b.setVal9(static_cast(v9.value())); + b.setVal10(true); } else { - b.setVal11(mx::kInvalidEntityId); + b.setVal10(false); + } + b.setVal11(static_cast(mx::FromPasta(e.ModuleOwnershipKind()))); + auto v12 = e.NonClosureContext(); + if (v12) { + auto id12 = es.EntityId(v12.value()); + b.setVal12(id12); + } else { + b.setVal12(mx::kInvalidEntityId); } - b.setVal12(e.OwningModuleID()); - b.setVal13(e.TemplateDepth()); - b.setVal14(e.IsDeprecated()); - b.setVal15(e.IsFileContextDeclaration()); - b.setVal16(e.IsFunctionOrFunctionTemplate()); - b.setVal17(e.IsImplicit()); - b.setVal18(e.IsInAnonymousNamespace()); - b.setVal19(e.IsInAnotherModuleUnit()); - b.setVal20(e.IsInExportDeclarationContext()); - b.setVal21(e.IsInStdNamespace()); - b.setVal22(e.IsInvisibleOutsideTheOwningModule()); - b.setVal23(e.IsLocalExternDeclaration()); - b.setVal24(e.IsModulePrivate()); - b.setVal25(e.IsOutOfLine()); - b.setVal26(e.IsParameterPack()); - b.setVal27(e.IsTemplateDeclaration()); - b.setVal28(e.IsTemplateParameter()); - b.setVal29(e.IsTemplateParameterPack()); - b.setVal30(e.IsTemplated()); - b.setVal31(e.IsTopLevelDeclarationInObjCContainer()); - b.setVal32(e.IsUnavailable()); - b.setVal33(e.IsUnconditionallyVisible()); - b.setVal34(e.IsWeakImported()); - b.setVal35(static_cast(mx::FromPasta(e.Kind()))); - b.setVal36(static_cast(mx::FromPasta(e.Category()))); - auto et37 = pf.DeclTokenEntityId(e); - b.setVal37(et37); - auto p38 = es.EntityIds(e.Tokens()); - b.setVal38(p38.first); - b.setVal39(p38.second); + b.setVal13(e.OwningModuleID()); + b.setVal14(e.TemplateDepth()); + b.setVal15(e.IsDeprecated()); + b.setVal16(e.IsFileContextDeclaration()); + b.setVal17(e.IsFunctionOrFunctionTemplate()); + b.setVal18(e.IsImplicit()); + b.setVal19(e.IsInAnonymousNamespace()); + b.setVal20(e.IsInAnotherModuleUnit()); + b.setVal21(e.IsInExportDeclarationContext()); + b.setVal22(e.IsInStdNamespace()); + b.setVal23(e.IsInvisibleOutsideTheOwningModule()); + b.setVal24(e.IsLocalExternDeclaration()); + b.setVal25(e.IsModulePrivate()); + b.setVal26(e.IsOutOfLine()); + b.setVal27(e.IsParameterPack()); + b.setVal28(e.IsTemplateDeclaration()); + b.setVal29(e.IsTemplateParameter()); + b.setVal30(e.IsTemplateParameterPack()); + b.setVal31(e.IsTemplated()); + b.setVal32(e.IsTopLevelDeclarationInObjCContainer()); + b.setVal33(e.IsUnavailable()); + b.setVal34(e.IsUnconditionallyVisible()); + b.setVal35(e.IsWeakImported()); + b.setVal36(static_cast(mx::FromPasta(e.Kind()))); + b.setVal37(static_cast(mx::FromPasta(e.Category()))); + auto et38 = pf.DeclTokenEntityId(e); + b.setVal38(et38); + auto p39 = es.EntityIds(e.Tokens()); + b.setVal39(p39.first); + b.setVal40(p39.second); } void SerializeCapturedDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::CapturedDecl &e, const TokenTree *) { @@ -9033,16 +9035,16 @@ void SerializeCapturedDecl(const PendingFragment &pf, const EntityMapper &es, mx (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - b.setVal40(es.EntityId(e.ContextParameter())); - b.setVal41(e.ContextParameterPosition()); - b.setVal42(e.IsNothrow()); + b.setVal41(es.EntityId(e.ContextParameter())); + b.setVal42(e.ContextParameterPosition()); + b.setVal43(e.IsNothrow()); do { - auto v43 = e.Parameters(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.Parameters(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -9053,36 +9055,27 @@ void SerializeBlockDecl(const PendingFragment &pf, const EntityMapper &es, mx::a (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - b.setVal42(e.BlockMissingReturnType()); - b.setVal45(e.CanAvoidCopyToHeap()); - b.setVal46(e.CapturesCXXThis()); - b.setVal47(e.DoesNotEscape()); - auto v40 = e.BlockManglingContextDeclaration(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + b.setVal43(e.BlockMissingReturnType()); + b.setVal46(e.CanAvoidCopyToHeap()); + b.setVal47(e.CapturesCXXThis()); + b.setVal48(e.DoesNotEscape()); + auto v41 = e.BlockManglingContextDeclaration(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - b.setVal41(e.BlockManglingNumber()); - auto et48 = es.EntityId(e.CaretToken()); - b.setVal48(et48); - b.setVal49(es.EntityId(e.CompoundBody())); - b.setVal50(es.EntityId(e.SignatureAsWritten())); - b.setVal51(e.HasCaptures()); - b.setVal52(e.IsConversionFromLambda()); - b.setVal53(e.IsVariadic()); - do { - auto v43 = e.Parameters(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; - } - } while (false); + b.setVal42(e.BlockManglingNumber()); + auto et49 = es.EntityId(e.CaretToken()); + b.setVal49(et49); + b.setVal50(es.EntityId(e.CompoundBody())); + b.setVal51(es.EntityId(e.SignatureAsWritten())); + b.setVal52(e.HasCaptures()); + b.setVal53(e.IsConversionFromLambda()); + b.setVal54(e.IsVariadic()); do { - auto v44 = e.ParameterDeclarations(); + auto v44 = e.Parameters(); auto sv44 = b.initVal44(static_cast(v44.size())); auto i44 = 0u; for (const auto &e44 : v44) { @@ -9090,6 +9083,15 @@ void SerializeBlockDecl(const PendingFragment &pf, const EntityMapper &es, mx::a ++i44; } } while (false); + do { + auto v45 = e.ParameterDeclarations(); + auto sv45 = b.initVal45(static_cast(v45.size())); + auto i45 = 0u; + for (const auto &e45 : v45) { + sv45.set(i45, es.EntityId(e45)); + ++i45; + } + } while (false); } void SerializeAccessSpecDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::AccessSpecDecl &e, const TokenTree *) { @@ -9098,10 +9100,10 @@ void SerializeAccessSpecDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - auto et40 = es.EntityId(e.AccessSpecifierToken()); - b.setVal40(et40); - auto et48 = es.EntityId(e.ColonToken()); - b.setVal48(et48); + auto et41 = es.EntityId(e.AccessSpecifierToken()); + b.setVal41(et41); + auto et49 = es.EntityId(e.ColonToken()); + b.setVal49(et49); } void SerializeOMPDeclarativeDirectiveDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::OMPDeclarativeDirectiveDecl &e, const TokenTree *) { @@ -9119,12 +9121,12 @@ void SerializeOMPThreadPrivateDecl(const PendingFragment &pf, const EntityMapper (void) e; SerializeOMPDeclarativeDirectiveDecl(pf, es, b, e, nullptr); do { - auto v43 = e.Varlists(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.Varlists(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -9144,12 +9146,12 @@ void SerializeOMPAllocateDecl(const PendingFragment &pf, const EntityMapper &es, (void) e; SerializeOMPDeclarativeDirectiveDecl(pf, es, b, e, nullptr); do { - auto v43 = e.Varlists(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.Varlists(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -9167,8 +9169,8 @@ void SerializeTopLevelStmtDecl(const PendingFragment &pf, const EntityMapper &es (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - b.setVal40(es.EntityId(e.Statement())); - b.setVal42(e.IsSemiMissing()); + b.setVal41(es.EntityId(e.Statement())); + b.setVal43(e.IsSemiMissing()); } void SerializeStaticAssertDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::StaticAssertDecl &e, const TokenTree *) { @@ -9177,17 +9179,17 @@ void SerializeStaticAssertDecl(const PendingFragment &pf, const EntityMapper &es (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - b.setVal40(es.EntityId(e.AssertExpression())); - auto v48 = e.Message(); - if (v48) { - auto id48 = es.EntityId(v48.value()); - b.setVal48(id48); + b.setVal41(es.EntityId(e.AssertExpression())); + auto v49 = e.Message(); + if (v49) { + auto id49 = es.EntityId(v49.value()); + b.setVal49(id49); } else { - b.setVal48(mx::kInvalidEntityId); + b.setVal49(mx::kInvalidEntityId); } - auto et49 = es.EntityId(e.RParenToken()); - b.setVal49(et49); - b.setVal42(e.IsFailed()); + auto et50 = es.EntityId(e.RParenToken()); + b.setVal50(et50); + b.setVal43(e.IsFailed()); } void SerializeRequiresExprBodyDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::RequiresExprBodyDecl &e, const TokenTree *) { @@ -9204,12 +9206,12 @@ void SerializePragmaDetectMismatchDecl(const PendingFragment &pf, const EntityMa (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - auto v55 = e.Name(); - std::string s55(v55.data(), v55.size()); - b.setVal55(s55); - auto v56 = e.Value(); + auto v56 = e.Name(); std::string s56(v56.data(), v56.size()); b.setVal56(s56); + auto v57 = e.Value(); + std::string s57(v57.data(), v57.size()); + b.setVal57(s57); } void SerializePragmaCommentDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::PragmaCommentDecl &e, const TokenTree *) { @@ -9218,10 +9220,10 @@ void SerializePragmaCommentDecl(const PendingFragment &pf, const EntityMapper &e (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - auto v55 = e.Argument(); - std::string s55(v55.data(), v55.size()); - b.setVal55(s55); - b.setVal57(static_cast(mx::FromPasta(e.CommentKind()))); + auto v56 = e.Argument(); + std::string s56(v56.data(), v56.size()); + b.setVal56(s56); + b.setVal58(static_cast(mx::FromPasta(e.CommentKind()))); } void SerializeObjCPropertyImplDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ObjCPropertyImplDecl &e, const TokenTree *) { @@ -9230,16 +9232,16 @@ void SerializeObjCPropertyImplDecl(const PendingFragment &pf, const EntityMapper (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - b.setVal40(es.EntityId(e.GetterCXXConstructor())); - b.setVal48(es.EntityId(e.GetterMethodDeclaration())); - b.setVal49(es.EntityId(e.PropertyDeclaration())); - b.setVal57(static_cast(mx::FromPasta(e.PropertyImplementation()))); - b.setVal50(es.EntityId(e.PropertyInstanceVariableDeclaration())); - auto et58 = es.EntityId(e.PropertyInstanceVariableDeclarationToken()); - b.setVal58(et58); - b.setVal59(es.EntityId(e.SetterCXXAssignment())); - b.setVal60(es.EntityId(e.SetterMethodDeclaration())); - b.setVal42(e.IsInstanceVariableNameSpecified()); + b.setVal41(es.EntityId(e.GetterCXXConstructor())); + b.setVal49(es.EntityId(e.GetterMethodDeclaration())); + b.setVal50(es.EntityId(e.PropertyDeclaration())); + b.setVal58(static_cast(mx::FromPasta(e.PropertyImplementation()))); + b.setVal51(es.EntityId(e.PropertyInstanceVariableDeclaration())); + auto et59 = es.EntityId(e.PropertyInstanceVariableDeclarationToken()); + b.setVal59(et59); + b.setVal60(es.EntityId(e.SetterCXXAssignment())); + b.setVal61(es.EntityId(e.SetterMethodDeclaration())); + b.setVal43(e.IsInstanceVariableNameSpecified()); } void SerializeNamedDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::NamedDecl &e, const TokenTree *) { @@ -9248,31 +9250,31 @@ void SerializeNamedDecl(const PendingFragment &pf, const EntityMapper &es, mx::a (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - b.setVal57(static_cast(mx::FromPasta(e.FormalLinkage()))); - b.setVal55(Name(e)); - auto v61 = e.ObjCFStringFormattingFamily(); - if (v61) { - b.setVal61(static_cast(v61.value())); - b.setVal42(true); - } else { - b.setVal42(false); - } - b.setVal40(es.EntityId(e.UnderlyingDeclaration())); - auto v62 = e.Visibility(); + b.setVal58(static_cast(mx::FromPasta(e.FormalLinkage()))); + b.setVal56(Name(e)); + auto v62 = e.ObjCFStringFormattingFamily(); if (v62) { b.setVal62(static_cast(v62.value())); - b.setVal45(true); + b.setVal43(true); + } else { + b.setVal43(false); + } + b.setVal41(es.EntityId(e.UnderlyingDeclaration())); + auto v63 = e.Visibility(); + if (v63) { + b.setVal63(static_cast(v63.value())); + b.setVal46(true); } else { - b.setVal45(false); + b.setVal46(false); } - b.setVal46(e.HasExternalFormalLinkage()); - b.setVal47(e.HasLinkage()); - b.setVal51(e.HasLinkageBeenComputed()); - b.setVal52(e.IsCXXClassMember()); - b.setVal53(e.IsCXXInstanceMember()); - b.setVal63(e.IsExternallyDeclarable()); - b.setVal64(e.IsExternallyVisible()); - b.setVal65(e.IsLinkageValid()); + b.setVal47(e.HasExternalFormalLinkage()); + b.setVal48(e.HasLinkage()); + b.setVal52(e.HasLinkageBeenComputed()); + b.setVal53(e.IsCXXClassMember()); + b.setVal54(e.IsCXXInstanceMember()); + b.setVal64(e.IsExternallyDeclarable()); + b.setVal65(e.IsExternallyVisible()); + b.setVal66(e.IsLinkageValid()); } void SerializeLabelDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::LabelDecl &e, const TokenTree *) { @@ -9281,13 +9283,13 @@ void SerializeLabelDecl(const PendingFragment &pf, const EntityMapper &es, mx::a (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto v56 = e.MSAssemblyLabel(); - std::string s56(v56.data(), v56.size()); - b.setVal56(s56); - b.setVal48(es.EntityId(e.Statement())); - b.setVal66(e.IsGnuLocal()); - b.setVal67(e.IsMSAssemblyLabel()); - b.setVal68(e.IsResolvedMSAssemblyLabel()); + auto v57 = e.MSAssemblyLabel(); + std::string s57(v57.data(), v57.size()); + b.setVal57(s57); + b.setVal49(es.EntityId(e.Statement())); + b.setVal67(e.IsGnuLocal()); + b.setVal68(e.IsMSAssemblyLabel()); + b.setVal69(e.IsResolvedMSAssemblyLabel()); } void SerializeHLSLBufferDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::HLSLBufferDecl &e, const TokenTree *) { @@ -9296,13 +9298,13 @@ void SerializeHLSLBufferDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto et48 = es.EntityId(e.LBraceToken()); - b.setVal48(et48); - auto et49 = es.EntityId(e.TokenStart()); + auto et49 = es.EntityId(e.LBraceToken()); b.setVal49(et49); - auto et50 = es.EntityId(e.RBraceToken()); + auto et50 = es.EntityId(e.TokenStart()); b.setVal50(et50); - b.setVal66(e.IsCBuffer()); + auto et51 = es.EntityId(e.RBraceToken()); + b.setVal51(et51); + b.setVal67(e.IsCBuffer()); } void SerializeBaseUsingDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::BaseUsingDecl &e, const TokenTree *) { @@ -9312,12 +9314,12 @@ void SerializeBaseUsingDecl(const PendingFragment &pf, const EntityMapper &es, m (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); do { - auto v43 = e.Shadows(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.Shadows(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -9328,12 +9330,12 @@ void SerializeUsingEnumDecl(const PendingFragment &pf, const EntityMapper &es, m (void) b; (void) e; SerializeBaseUsingDecl(pf, es, b, e, nullptr); - b.setVal48(es.EntityId(e.EnumDeclaration())); - auto et49 = es.EntityId(e.EnumToken()); - b.setVal49(et49); - b.setVal50(es.EntityId(e.EnumType())); - auto et58 = es.EntityId(e.UsingToken()); - b.setVal58(et58); + b.setVal49(es.EntityId(e.EnumDeclaration())); + auto et50 = es.EntityId(e.EnumToken()); + b.setVal50(et50); + b.setVal51(es.EntityId(e.EnumType())); + auto et59 = es.EntityId(e.UsingToken()); + b.setVal59(et59); } void SerializeUsingDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::UsingDecl &e, const TokenTree *) { @@ -9342,10 +9344,10 @@ void SerializeUsingDecl(const PendingFragment &pf, const EntityMapper &es, mx::a (void) b; (void) e; SerializeBaseUsingDecl(pf, es, b, e, nullptr); - auto et48 = es.EntityId(e.UsingToken()); - b.setVal48(et48); - b.setVal66(e.HasTypename()); - b.setVal67(e.IsAccessDeclaration()); + auto et49 = es.EntityId(e.UsingToken()); + b.setVal49(et49); + b.setVal67(e.HasTypename()); + b.setVal68(e.IsAccessDeclaration()); } void SerializeValueDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ValueDecl &e, const TokenTree *) { @@ -9354,16 +9356,16 @@ void SerializeValueDecl(const PendingFragment &pf, const EntityMapper &es, mx::a (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto v48 = e.PotentiallyDecomposedVariableDeclaration(); - if (v48) { - auto id48 = es.EntityId(v48.value()); - b.setVal48(id48); + auto v49 = e.PotentiallyDecomposedVariableDeclaration(); + if (v49) { + auto id49 = es.EntityId(v49.value()); + b.setVal49(id49); } else { - b.setVal48(mx::kInvalidEntityId); + b.setVal49(mx::kInvalidEntityId); } - b.setVal49(es.EntityId(e.Type())); - b.setVal66(e.IsInitializerCapture()); - b.setVal67(e.IsWeak()); + b.setVal50(es.EntityId(e.Type())); + b.setVal67(e.IsInitializerCapture()); + b.setVal68(e.IsWeak()); } void SerializeUnresolvedUsingValueDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::UnresolvedUsingValueDecl &e, const TokenTree *) { @@ -9372,12 +9374,12 @@ void SerializeUnresolvedUsingValueDecl(const PendingFragment &pf, const EntityMa (void) b; (void) e; SerializeValueDecl(pf, es, b, e, nullptr); - auto et50 = es.EntityId(e.EllipsisToken()); - b.setVal50(et50); - auto et58 = es.EntityId(e.UsingToken()); - b.setVal58(et58); - b.setVal68(e.IsAccessDeclaration()); - b.setVal69(e.IsPackExpansion()); + auto et51 = es.EntityId(e.EllipsisToken()); + b.setVal51(et51); + auto et59 = es.EntityId(e.UsingToken()); + b.setVal59(et59); + b.setVal69(e.IsAccessDeclaration()); + b.setVal70(e.IsPackExpansion()); } void SerializeUnnamedGlobalConstantDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::UnnamedGlobalConstantDecl &e, const TokenTree *) { @@ -9402,13 +9404,13 @@ void SerializeOMPDeclareReductionDecl(const PendingFragment &pf, const EntityMap (void) b; (void) e; SerializeValueDecl(pf, es, b, e, nullptr); - b.setVal50(es.EntityId(e.Combiner())); - b.setVal58(es.EntityId(e.CombinerIn())); - b.setVal59(es.EntityId(e.CombinerOut())); - b.setVal60(es.EntityId(e.InitializerOriginal())); - b.setVal70(es.EntityId(e.InitializerPrivate())); - b.setVal71(es.EntityId(e.Initializer())); - b.setVal72(static_cast(mx::FromPasta(e.InitializerKind()))); + b.setVal51(es.EntityId(e.Combiner())); + b.setVal59(es.EntityId(e.CombinerIn())); + b.setVal60(es.EntityId(e.CombinerOut())); + b.setVal61(es.EntityId(e.InitializerOriginal())); + b.setVal71(es.EntityId(e.InitializerPrivate())); + b.setVal72(es.EntityId(e.Initializer())); + b.setVal73(static_cast(mx::FromPasta(e.InitializerKind()))); } void SerializeMSGuidDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::MSGuidDecl &e, const TokenTree *) { @@ -9426,28 +9428,28 @@ void SerializeIndirectFieldDecl(const PendingFragment &pf, const EntityMapper &e (void) e; SerializeValueDecl(pf, es, b, e, nullptr); do { - auto v43 = e.Chain(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.Chain(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); - auto v50 = e.AnonymousField(); - if (v50) { - auto id50 = es.EntityId(v50.value()); - b.setVal50(id50); + auto v51 = e.AnonymousField(); + if (v51) { + auto id51 = es.EntityId(v51.value()); + b.setVal51(id51); } else { - b.setVal50(mx::kInvalidEntityId); + b.setVal51(mx::kInvalidEntityId); } - b.setVal41(e.ChainingSize()); - auto v58 = e.VariableDeclaration(); - if (v58) { - auto id58 = es.EntityId(v58.value()); - b.setVal58(id58); + b.setVal42(e.ChainingSize()); + auto v59 = e.VariableDeclaration(); + if (v59) { + auto id59 = es.EntityId(v59.value()); + b.setVal59(id59); } else { - b.setVal58(mx::kInvalidEntityId); + b.setVal59(mx::kInvalidEntityId); } } @@ -9457,12 +9459,12 @@ void SerializeEnumConstantDecl(const PendingFragment &pf, const EntityMapper &es (void) b; (void) e; SerializeValueDecl(pf, es, b, e, nullptr); - auto v50 = e.InitializerExpression(); - if (v50) { - auto id50 = es.EntityId(v50.value()); - b.setVal50(id50); + auto v51 = e.InitializerExpression(); + if (v51) { + auto id51 = es.EntityId(v51.value()); + b.setVal51(id51); } else { - b.setVal50(mx::kInvalidEntityId); + b.setVal51(mx::kInvalidEntityId); } } @@ -9472,28 +9474,28 @@ void SerializeDeclaratorDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeValueDecl(pf, es, b, e, nullptr); - auto et50 = es.EntityId(e.FirstInnerToken()); - b.setVal50(et50); - auto et58 = es.EntityId(e.FirstOuterToken()); - b.setVal58(et58); - auto v59 = e.TrailingRequiresClause(); - if (v59) { - auto id59 = es.EntityId(v59.value()); - b.setVal59(id59); + auto et51 = es.EntityId(e.FirstInnerToken()); + b.setVal51(et51); + auto et59 = es.EntityId(e.FirstOuterToken()); + b.setVal59(et59); + auto v60 = e.TrailingRequiresClause(); + if (v60) { + auto id60 = es.EntityId(v60.value()); + b.setVal60(id60); } else { - b.setVal59(mx::kInvalidEntityId); + b.setVal60(mx::kInvalidEntityId); } - auto et60 = es.EntityId(e.TypeSpecEndToken()); - b.setVal60(et60); - auto et70 = es.EntityId(e.TypeSpecStartToken()); - b.setVal70(et70); + auto et61 = es.EntityId(e.TypeSpecEndToken()); + b.setVal61(et61); + auto et71 = es.EntityId(e.TypeSpecStartToken()); + b.setVal71(et71); do { - auto v43 = e.TemplateParameterLists(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.TemplateParameterLists(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -9504,79 +9506,79 @@ void SerializeVarDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast (void) b; (void) e; SerializeDeclaratorDecl(pf, es, b, e, nullptr); - auto v71 = e.ActingDefinition(); - if (v71) { - auto id71 = es.EntityId(v71.value()); - b.setVal71(id71); + auto v72 = e.ActingDefinition(); + if (v72) { + auto id72 = es.EntityId(v72.value()); + b.setVal72(id72); } else { - b.setVal71(mx::kInvalidEntityId); - } - auto v73 = e.DescribedVariableTemplate(); - if (v73) { - auto id73 = es.EntityId(v73.value()); - b.setVal73(id73); - } else { - b.setVal73(mx::kInvalidEntityId); + b.setVal72(mx::kInvalidEntityId); } - auto v74 = e.Initializer(); + auto v74 = e.DescribedVariableTemplate(); if (v74) { auto id74 = es.EntityId(v74.value()); b.setVal74(id74); } else { b.setVal74(mx::kInvalidEntityId); } - b.setVal72(static_cast(mx::FromPasta(e.InitializerStyle()))); - auto v75 = e.InitializingDeclaration(); + auto v75 = e.Initializer(); if (v75) { auto id75 = es.EntityId(v75.value()); b.setVal75(id75); } else { b.setVal75(mx::kInvalidEntityId); } - b.setVal76(static_cast(mx::FromPasta(e.LanguageLinkage()))); - b.setVal77(static_cast(mx::FromPasta(e.StorageClass()))); - b.setVal78(static_cast(mx::FromPasta(e.StorageDuration()))); - b.setVal79(static_cast(mx::FromPasta(e.TLSKind()))); - b.setVal80(static_cast(mx::FromPasta(e.TSCSpec()))); - b.setVal68(e.HasConstantInitialization()); - b.setVal69(e.HasDependentAlignment()); - b.setVal81(e.HasExternalStorage()); - auto v82 = e.HasFlexibleArrayInitializer(); - if (v82) { - b.setVal82(static_cast(v82.value())); - b.setVal83(true); - } else { - b.setVal83(false); - } - b.setVal84(e.HasGlobalStorage()); - b.setVal85(e.HasInitializer()); - b.setVal86(e.HasLocalStorage()); - b.setVal87(e.IsARCPseudoStrong()); - b.setVal88(e.IsCXXForRangeDeclaration()); - b.setVal89(e.IsConstexpr()); - b.setVal90(e.IsDirectInitializer()); - b.setVal91(e.IsEscapingByref()); - b.setVal92(e.IsExceptionVariable()); - b.setVal93(e.IsExternC()); - b.setVal94(e.IsFileVariableDeclaration()); - b.setVal95(e.IsFunctionOrMethodVariableDeclaration()); - b.setVal96(e.IsInExternCContext()); - b.setVal97(e.IsInExternCXXContext()); - b.setVal98(e.IsInline()); - b.setVal99(e.IsInlineSpecified()); - b.setVal100(e.IsKnownToBeDefined()); - b.setVal101(e.IsLocalVariableDeclaration()); - b.setVal102(e.IsLocalVariableDeclarationOrParm()); - b.setVal103(e.IsNRVOVariable()); - b.setVal104(e.IsNoDestroy()); - b.setVal105(e.IsNonEscapingByref()); - b.setVal106(e.IsObjCForDeclaration()); - b.setVal107(e.IsPreviousDeclarationInSameBlockScope()); - b.setVal108(e.IsStaticDataMember()); - b.setVal109(e.IsStaticLocal()); - b.setVal110(e.IsThisDeclarationADemotedDefinition()); - b.setVal111(e.IsUsableInConstantExpressions()); - b.setVal112(e.MightBeUsableInConstantExpressions()); + b.setVal73(static_cast(mx::FromPasta(e.InitializerStyle()))); + auto v76 = e.InitializingDeclaration(); + if (v76) { + auto id76 = es.EntityId(v76.value()); + b.setVal76(id76); + } else { + b.setVal76(mx::kInvalidEntityId); + } + b.setVal77(static_cast(mx::FromPasta(e.LanguageLinkage()))); + b.setVal78(static_cast(mx::FromPasta(e.StorageClass()))); + b.setVal79(static_cast(mx::FromPasta(e.StorageDuration()))); + b.setVal80(static_cast(mx::FromPasta(e.TLSKind()))); + b.setVal81(static_cast(mx::FromPasta(e.TSCSpec()))); + b.setVal69(e.HasConstantInitialization()); + b.setVal70(e.HasDependentAlignment()); + b.setVal82(e.HasExternalStorage()); + auto v83 = e.HasFlexibleArrayInitializer(); + if (v83) { + b.setVal83(static_cast(v83.value())); + b.setVal84(true); + } else { + b.setVal84(false); + } + b.setVal85(e.HasGlobalStorage()); + b.setVal86(e.HasInitializer()); + b.setVal87(e.HasLocalStorage()); + b.setVal88(e.IsARCPseudoStrong()); + b.setVal89(e.IsCXXForRangeDeclaration()); + b.setVal90(e.IsConstexpr()); + b.setVal91(e.IsDirectInitializer()); + b.setVal92(e.IsEscapingByref()); + b.setVal93(e.IsExceptionVariable()); + b.setVal94(e.IsExternC()); + b.setVal95(e.IsFileVariableDeclaration()); + b.setVal96(e.IsFunctionOrMethodVariableDeclaration()); + b.setVal97(e.IsInExternCContext()); + b.setVal98(e.IsInExternCXXContext()); + b.setVal99(e.IsInline()); + b.setVal100(e.IsInlineSpecified()); + b.setVal101(e.IsKnownToBeDefined()); + b.setVal102(e.IsLocalVariableDeclaration()); + b.setVal103(e.IsLocalVariableDeclarationOrParm()); + b.setVal104(e.IsNRVOVariable()); + b.setVal105(e.IsNoDestroy()); + b.setVal106(e.IsNonEscapingByref()); + b.setVal107(e.IsObjCForDeclaration()); + b.setVal108(e.IsPreviousDeclarationInSameBlockScope()); + b.setVal109(e.IsStaticDataMember()); + b.setVal110(e.IsStaticLocal()); + b.setVal111(e.IsThisDeclarationADemotedDefinition()); + b.setVal112(e.IsUsableInConstantExpressions()); + b.setVal113(e.MightBeUsableInConstantExpressions()); } void SerializeParmVarDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ParmVarDecl &e, const TokenTree *) { @@ -9585,37 +9587,37 @@ void SerializeParmVarDecl(const PendingFragment &pf, const EntityMapper &es, mx: (void) b; (void) e; SerializeVarDecl(pf, es, b, e, nullptr); - auto v113 = e.DefaultArgument(); - if (v113) { - auto id113 = es.EntityId(v113.value()); - b.setVal113(id113); - } else { - b.setVal113(mx::kInvalidEntityId); - } - auto p114 = es.EntityIds(e.DefaultArgumentRange()); - b.setVal114(p114.first); - b.setVal115(p114.second); - auto et116 = es.EntityId(e.ExplicitObjectParameterThisToken()); - b.setVal116(et116); - b.setVal41(e.FunctionScopeDepth()); - b.setVal117(e.FunctionScopeIndex()); - b.setVal118(static_cast(mx::FromPasta(e.ObjCDeclQualifier()))); - b.setVal119(es.EntityId(e.OriginalType())); - auto v120 = e.UninstantiatedDefaultArgument(); - if (v120) { - auto id120 = es.EntityId(v120.value()); - b.setVal120(id120); + auto v114 = e.DefaultArgument(); + if (v114) { + auto id114 = es.EntityId(v114.value()); + b.setVal114(id114); } else { - b.setVal120(mx::kInvalidEntityId); + b.setVal114(mx::kInvalidEntityId); } - b.setVal121(e.HasDefaultArgument()); - b.setVal122(e.HasInheritedDefaultArgument()); - b.setVal123(e.HasUninstantiatedDefaultArgument()); - b.setVal124(e.HasUnparsedDefaultArgument()); - b.setVal125(e.IsDestroyedInCallee()); - b.setVal126(e.IsExplicitObjectParameter()); - b.setVal127(e.IsKNRPromoted()); - b.setVal128(e.IsObjCMethodParameter()); + auto p115 = es.EntityIds(e.DefaultArgumentRange()); + b.setVal115(p115.first); + b.setVal116(p115.second); + auto et117 = es.EntityId(e.ExplicitObjectParameterThisToken()); + b.setVal117(et117); + b.setVal42(e.FunctionScopeDepth()); + b.setVal118(e.FunctionScopeIndex()); + b.setVal119(static_cast(mx::FromPasta(e.ObjCDeclQualifier()))); + b.setVal120(es.EntityId(e.OriginalType())); + auto v121 = e.UninstantiatedDefaultArgument(); + if (v121) { + auto id121 = es.EntityId(v121.value()); + b.setVal121(id121); + } else { + b.setVal121(mx::kInvalidEntityId); + } + b.setVal122(e.HasDefaultArgument()); + b.setVal123(e.HasInheritedDefaultArgument()); + b.setVal124(e.HasUninstantiatedDefaultArgument()); + b.setVal125(e.HasUnparsedDefaultArgument()); + b.setVal126(e.IsDestroyedInCallee()); + b.setVal127(e.IsExplicitObjectParameter()); + b.setVal128(e.IsKNRPromoted()); + b.setVal129(e.IsObjCMethodParameter()); } void SerializeOMPCapturedExprDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::OMPCapturedExprDecl &e, const TokenTree *) { @@ -9632,7 +9634,7 @@ void SerializeImplicitParamDecl(const PendingFragment &pf, const EntityMapper &e (void) b; (void) e; SerializeVarDecl(pf, es, b, e, nullptr); - b.setVal118(static_cast(mx::FromPasta(e.ParameterKind()))); + b.setVal119(static_cast(mx::FromPasta(e.ParameterKind()))); } void SerializeDecompositionDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::DecompositionDecl &e, const TokenTree *) { @@ -9642,12 +9644,12 @@ void SerializeDecompositionDecl(const PendingFragment &pf, const EntityMapper &e (void) e; SerializeVarDecl(pf, es, b, e, nullptr); do { - auto v44 = e.Bindings(); - auto sv44 = b.initVal44(static_cast(v44.size())); - auto i44 = 0u; - for (const auto &e44 : v44) { - sv44.set(i44, es.EntityId(e44)); - ++i44; + auto v45 = e.Bindings(); + auto sv45 = b.initVal45(static_cast(v45.size())); + auto i45 = 0u; + for (const auto &e45 : v45) { + sv45.set(i45, es.EntityId(e45)); + ++i45; } } while (false); } @@ -9658,24 +9660,24 @@ void SerializeVarTemplateSpecializationDecl(const PendingFragment &pf, const Ent (void) b; (void) e; SerializeVarDecl(pf, es, b, e, nullptr); - auto et113 = es.EntityId(e.ExternToken()); - b.setVal113(et113); - b.setVal118(static_cast(mx::FromPasta(e.SpecializationKind()))); - b.setVal114(es.EntityId(e.SpecializedTemplate())); + auto et114 = es.EntityId(e.ExternToken()); + b.setVal114(et114); + b.setVal119(static_cast(mx::FromPasta(e.SpecializationKind()))); + b.setVal115(es.EntityId(e.SpecializedTemplate())); do { - auto v44 = e.TemplateArguments(); - auto sv44 = b.initVal44(static_cast(v44.size())); - auto i44 = 0u; - for (const auto &e44 : v44) { - sv44.set(i44, es.EntityId(e44)); - ++i44; + auto v45 = e.TemplateArguments(); + auto sv45 = b.initVal45(static_cast(v45.size())); + auto i45 = 0u; + for (const auto &e45 : v45) { + sv45.set(i45, es.EntityId(e45)); + ++i45; } } while (false); - auto et115 = es.EntityId(e.TemplateKeywordToken()); - b.setVal115(et115); - b.setVal121(e.IsClassScopeExplicitSpecialization()); - b.setVal122(e.IsExplicitInstantiationOrSpecialization()); - b.setVal123(e.IsExplicitSpecialization()); + auto et116 = es.EntityId(e.TemplateKeywordToken()); + b.setVal116(et116); + b.setVal122(e.IsClassScopeExplicitSpecialization()); + b.setVal123(e.IsExplicitInstantiationOrSpecialization()); + b.setVal124(e.IsExplicitSpecialization()); } void SerializeVarTemplatePartialSpecializationDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::VarTemplatePartialSpecializationDecl &e, const TokenTree *) { @@ -9684,8 +9686,8 @@ void SerializeVarTemplatePartialSpecializationDecl(const PendingFragment &pf, co (void) b; (void) e; SerializeVarTemplateSpecializationDecl(pf, es, b, e, nullptr); - b.setVal116(es.EntityId(e.TemplateParameters())); - b.setVal124(e.HasAssociatedConstraints()); + b.setVal117(es.EntityId(e.TemplateParameters())); + b.setVal125(e.HasAssociatedConstraints()); } void SerializeNonTypeTemplateParmDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::NonTypeTemplateParmDecl &e, const TokenTree *) { @@ -9694,34 +9696,34 @@ void SerializeNonTypeTemplateParmDecl(const PendingFragment &pf, const EntityMap (void) b; (void) e; SerializeDeclaratorDecl(pf, es, b, e, nullptr); - b.setVal68(e.DefaultArgumentWasInherited()); - auto v71 = e.DefaultArgument(); - if (v71) { - auto id71 = es.EntityId(v71.value()); - b.setVal71(id71); + b.setVal69(e.DefaultArgumentWasInherited()); + auto v72 = e.DefaultArgument(); + if (v72) { + auto id72 = es.EntityId(v72.value()); + b.setVal72(id72); } else { - b.setVal71(mx::kInvalidEntityId); + b.setVal72(mx::kInvalidEntityId); } - auto et73 = es.EntityId(e.DefaultArgumentToken()); - b.setVal73(et73); - auto v74 = e.PlaceholderTypeConstraint(); - if (v74) { - auto id74 = es.EntityId(v74.value()); - b.setVal74(id74); + auto et74 = es.EntityId(e.DefaultArgumentToken()); + b.setVal74(et74); + auto v75 = e.PlaceholderTypeConstraint(); + if (v75) { + auto id75 = es.EntityId(v75.value()); + b.setVal75(id75); } else { - b.setVal74(mx::kInvalidEntityId); + b.setVal75(mx::kInvalidEntityId); } - b.setVal69(e.HasDefaultArgument()); - b.setVal81(e.HasPlaceholderTypeConstraint()); - b.setVal82(e.IsExpandedParameterPack()); - b.setVal83(e.IsPackExpansion()); + b.setVal70(e.HasDefaultArgument()); + b.setVal82(e.HasPlaceholderTypeConstraint()); + b.setVal83(e.IsExpandedParameterPack()); + b.setVal84(e.IsPackExpansion()); do { - auto v44 = e.ExpansionTypes(); - auto sv44 = b.initVal44(static_cast(v44.size())); - auto i44 = 0u; - for (const auto &e44 : v44) { - sv44.set(i44, es.EntityId(e44)); - ++i44; + auto v45 = e.ExpansionTypes(); + auto sv45 = b.initVal45(static_cast(v45.size())); + auto i45 = 0u; + for (const auto &e45 : v45) { + sv45.set(i45, es.EntityId(e45)); + ++i45; } } while (false); } @@ -9732,8 +9734,8 @@ void SerializeMSPropertyDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeDeclaratorDecl(pf, es, b, e, nullptr); - b.setVal68(e.HasGetter()); - b.setVal69(e.HasSetter()); + b.setVal69(e.HasGetter()); + b.setVal70(e.HasSetter()); } void SerializeFunctionDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::FunctionDecl &e, const TokenTree *) { @@ -9742,143 +9744,143 @@ void SerializeFunctionDecl(const PendingFragment &pf, const EntityMapper &es, mx (void) b; (void) e; SerializeDeclaratorDecl(pf, es, b, e, nullptr); - b.setVal68(e.BodyContainsImmediateEscalatingExpressions()); - b.setVal69(e.FriendConstraintRefersToEnclosingTemplate()); - b.setVal81(e.UsesFPIntrin()); - auto v82 = e.DoesDeclarationForceExternallyVisibleDefinition(); - if (v82) { - b.setVal82(static_cast(v82.value())); - b.setVal83(true); - } else { - b.setVal83(false); - } - b.setVal84(e.DoesThisDeclarationHaveABody()); - b.setVal41(e.BuiltinID()); - b.setVal71(es.EntityId(e.CallResultType())); - b.setVal72(static_cast(mx::FromPasta(e.ConstexprKind()))); - b.setVal73(es.EntityId(e.DeclaredReturnType())); - auto et74 = es.EntityId(e.DefaultToken()); - b.setVal74(et74); - auto v75 = e.DescribedFunctionTemplate(); - if (v75) { - auto id75 = es.EntityId(v75.value()); - b.setVal75(id75); + b.setVal69(e.BodyContainsImmediateEscalatingExpressions()); + b.setVal70(e.FriendConstraintRefersToEnclosingTemplate()); + b.setVal82(e.UsesFPIntrin()); + auto v83 = e.DoesDeclarationForceExternallyVisibleDefinition(); + if (v83) { + b.setVal83(static_cast(v83.value())); + b.setVal84(true); } else { - b.setVal75(mx::kInvalidEntityId); + b.setVal84(false); } - auto et113 = es.EntityId(e.EllipsisToken()); - b.setVal113(et113); - auto p114 = es.EntityIds(e.ExceptionSpecTokens()); - b.setVal114(p114.first); - b.setVal115(p114.second); - b.setVal76(static_cast(mx::FromPasta(e.ExceptionSpecType()))); - b.setVal77(static_cast(mx::FromPasta(e.LanguageLinkage()))); - b.setVal117(e.MemoryFunctionKind()); - b.setVal129(e.MinRequiredArguments()); - b.setVal130(e.MinRequiredExplicitArguments()); - b.setVal78(static_cast(mx::FromPasta(e.MultiVersionKind()))); - b.setVal79(static_cast(mx::FromPasta(e.OverloadedOperator()))); - auto p116 = es.EntityIds(e.ParametersTokens()); - b.setVal116(p116.first); - b.setVal119(p116.second); - b.setVal120(es.EntityId(e.ReturnType())); - b.setVal80(static_cast(mx::FromPasta(e.StorageClass()))); - b.setVal118(static_cast(mx::FromPasta(e.TemplatedKind()))); - b.setVal85(e.HasCXXExplicitFunctionObjectParameter()); - b.setVal86(e.HasImplicitReturnZero()); - b.setVal87(e.HasInheritedPrototype()); - b.setVal88(e.HasOneParameterOrDefaultArguments()); - b.setVal89(e.HasPrototype()); - b.setVal90(e.HasSkippedBody()); - b.setVal91(e.HasTrivialBody()); - b.setVal92(e.HasWrittenPrototype()); - b.setVal93(e.InstantiationIsPending()); - b.setVal94(e.IsCPUDispatchMultiVersion()); - b.setVal95(e.IsCPUSpecificMultiVersion()); - b.setVal96(e.IsConsteval()); - b.setVal97(e.IsConstexpr()); - b.setVal98(e.IsConstexprSpecified()); - b.setVal99(e.IsDefaulted()); - b.setVal100(e.IsDeleted()); - b.setVal101(e.IsDeletedAsWritten()); - b.setVal102(e.IsDestroyingOperatorDelete()); - b.setVal103(e.IsExplicitlyDefaulted()); - b.setVal104(e.IsExternC()); - b.setVal105(e.IsFunctionTemplateSpecialization()); - b.setVal106(e.IsGlobal()); - b.setVal107(e.IsImmediateEscalating()); - b.setVal108(e.IsImmediateFunction()); - b.setVal109(e.IsImplicitlyInstantiable()); - b.setVal110(e.IsInExternCContext()); - b.setVal111(e.IsInExternCXXContext()); - b.setVal112(e.IsIneligibleOrNotSelected()); - b.setVal121(e.IsInlineBuiltinDeclaration()); - auto v122 = e.IsInlineDefinitionExternallyVisible(); - if (v122) { - b.setVal122(static_cast(v122.value())); - b.setVal123(true); - } else { - b.setVal123(false); - } - b.setVal124(e.IsInlineSpecified()); - b.setVal125(e.IsInlined()); - b.setVal126(e.IsLateTemplateParsed()); - auto v127 = e.IsMSExternInline(); - if (v127) { - b.setVal127(static_cast(v127.value())); - b.setVal128(true); + b.setVal85(e.DoesThisDeclarationHaveABody()); + b.setVal42(e.BuiltinID()); + b.setVal72(es.EntityId(e.CallResultType())); + b.setVal73(static_cast(mx::FromPasta(e.ConstexprKind()))); + b.setVal74(es.EntityId(e.DeclaredReturnType())); + auto et75 = es.EntityId(e.DefaultToken()); + b.setVal75(et75); + auto v76 = e.DescribedFunctionTemplate(); + if (v76) { + auto id76 = es.EntityId(v76.value()); + b.setVal76(id76); + } else { + b.setVal76(mx::kInvalidEntityId); + } + auto et114 = es.EntityId(e.EllipsisToken()); + b.setVal114(et114); + auto p115 = es.EntityIds(e.ExceptionSpecTokens()); + b.setVal115(p115.first); + b.setVal116(p115.second); + b.setVal77(static_cast(mx::FromPasta(e.ExceptionSpecType()))); + b.setVal78(static_cast(mx::FromPasta(e.LanguageLinkage()))); + b.setVal118(e.MemoryFunctionKind()); + b.setVal130(e.MinRequiredArguments()); + b.setVal131(e.MinRequiredExplicitArguments()); + b.setVal79(static_cast(mx::FromPasta(e.MultiVersionKind()))); + b.setVal80(static_cast(mx::FromPasta(e.OverloadedOperator()))); + auto p117 = es.EntityIds(e.ParametersTokens()); + b.setVal117(p117.first); + b.setVal120(p117.second); + b.setVal121(es.EntityId(e.ReturnType())); + b.setVal81(static_cast(mx::FromPasta(e.StorageClass()))); + b.setVal119(static_cast(mx::FromPasta(e.TemplatedKind()))); + b.setVal86(e.HasCXXExplicitFunctionObjectParameter()); + b.setVal87(e.HasImplicitReturnZero()); + b.setVal88(e.HasInheritedPrototype()); + b.setVal89(e.HasOneParameterOrDefaultArguments()); + b.setVal90(e.HasPrototype()); + b.setVal91(e.HasSkippedBody()); + b.setVal92(e.HasTrivialBody()); + b.setVal93(e.HasWrittenPrototype()); + b.setVal94(e.InstantiationIsPending()); + b.setVal95(e.IsCPUDispatchMultiVersion()); + b.setVal96(e.IsCPUSpecificMultiVersion()); + b.setVal97(e.IsConsteval()); + b.setVal98(e.IsConstexpr()); + b.setVal99(e.IsConstexprSpecified()); + b.setVal100(e.IsDefaulted()); + b.setVal101(e.IsDeleted()); + b.setVal102(e.IsDeletedAsWritten()); + b.setVal103(e.IsDestroyingOperatorDelete()); + b.setVal104(e.IsExplicitlyDefaulted()); + b.setVal105(e.IsExternC()); + b.setVal106(e.IsFunctionTemplateSpecialization()); + b.setVal107(e.IsGlobal()); + b.setVal108(e.IsImmediateEscalating()); + b.setVal109(e.IsImmediateFunction()); + b.setVal110(e.IsImplicitlyInstantiable()); + b.setVal111(e.IsInExternCContext()); + b.setVal112(e.IsInExternCXXContext()); + b.setVal113(e.IsIneligibleOrNotSelected()); + b.setVal122(e.IsInlineBuiltinDeclaration()); + auto v123 = e.IsInlineDefinitionExternallyVisible(); + if (v123) { + b.setVal123(static_cast(v123.value())); + b.setVal124(true); } else { - b.setVal128(false); - } - b.setVal131(e.IsMSVCRTEntryPoint()); - b.setVal132(e.IsMain()); - b.setVal133(e.IsMemberLikeConstrainedFriend()); - b.setVal134(e.IsMultiVersion()); - b.setVal135(e.IsNoReturn()); - b.setVal136(e.IsOverloadedOperator()); - b.setVal137(e.IsPureVirtual()); - b.setVal138(e.IsReplaceableGlobalAllocationFunction()); - auto v139 = e.IsReservedGlobalPlacementOperator(); - if (v139) { - b.setVal139(static_cast(v139.value())); - b.setVal140(true); - } else { - b.setVal140(false); - } - b.setVal141(e.IsStatic()); - b.setVal142(e.IsTargetClonesMultiVersion()); - b.setVal143(e.IsTargetMultiVersion()); - b.setVal144(e.IsTemplateInstantiation()); - b.setVal145(e.IsThisDeclarationADefinition()); - b.setVal146(e.IsTrivial()); - b.setVal147(e.IsTrivialForCall()); - b.setVal148(e.IsUserProvided()); - b.setVal149(e.IsVariadic()); - b.setVal150(e.IsVirtualAsWritten()); + b.setVal124(false); + } + b.setVal125(e.IsInlineSpecified()); + b.setVal126(e.IsInlined()); + b.setVal127(e.IsLateTemplateParsed()); + auto v128 = e.IsMSExternInline(); + if (v128) { + b.setVal128(static_cast(v128.value())); + b.setVal129(true); + } else { + b.setVal129(false); + } + b.setVal132(e.IsMSVCRTEntryPoint()); + b.setVal133(e.IsMain()); + b.setVal134(e.IsMemberLikeConstrainedFriend()); + b.setVal135(e.IsMultiVersion()); + b.setVal136(e.IsNoReturn()); + b.setVal137(e.IsOverloadedOperator()); + b.setVal138(e.IsPureVirtual()); + b.setVal139(e.IsReplaceableGlobalAllocationFunction()); + auto v140 = e.IsReservedGlobalPlacementOperator(); + if (v140) { + b.setVal140(static_cast(v140.value())); + b.setVal141(true); + } else { + b.setVal141(false); + } + b.setVal142(e.IsStatic()); + b.setVal143(e.IsTargetClonesMultiVersion()); + b.setVal144(e.IsTargetMultiVersion()); + b.setVal145(e.IsTemplateInstantiation()); + b.setVal146(e.IsThisDeclarationADefinition()); + b.setVal147(e.IsTrivial()); + b.setVal148(e.IsTrivialForCall()); + b.setVal149(e.IsUserProvided()); + b.setVal150(e.IsVariadic()); + b.setVal151(e.IsVirtualAsWritten()); do { - auto v44 = e.Parameters(); - auto sv44 = b.initVal44(static_cast(v44.size())); - auto i44 = 0u; - for (const auto &e44 : v44) { - sv44.set(i44, es.EntityId(e44)); - ++i44; + auto v45 = e.Parameters(); + auto sv45 = b.initVal45(static_cast(v45.size())); + auto i45 = 0u; + for (const auto &e45 : v45) { + sv45.set(i45, es.EntityId(e45)); + ++i45; } } while (false); - b.setVal151(e.UsesSEHTry()); - auto v152 = e.Body(); - if (v152) { - auto id152 = es.EntityId(v152.value()); - b.setVal152(id152); + b.setVal152(e.UsesSEHTry()); + auto v153 = e.Body(); + if (v153) { + auto id153 = es.EntityId(v153.value()); + b.setVal153(id153); } else { - b.setVal152(mx::kInvalidEntityId); + b.setVal153(mx::kInvalidEntityId); } do { - auto v54 = e.TemplateArguments(); - auto sv54 = b.initVal54(static_cast(v54.size())); - auto i54 = 0u; - for (const auto &e54 : v54) { - sv54.set(i54, es.EntityId(e54)); - ++i54; + auto v55 = e.TemplateArguments(); + auto sv55 = b.initVal55(static_cast(v55.size())); + auto i55 = 0u; + for (const auto &e55 : v55) { + sv55.set(i55, es.EntityId(e55)); + ++i55; } } while (false); } @@ -9889,36 +9891,36 @@ void SerializeCXXMethodDecl(const PendingFragment &pf, const EntityMapper &es, m (void) b; (void) e; SerializeFunctionDecl(pf, es, b, e, nullptr); - b.setVal154(es.EntityId(e.FunctionObjectParameterReferenceType())); - b.setVal155(es.EntityId(e.FunctionObjectParameterType())); - b.setVal156(static_cast(mx::FromPasta(e.ReferenceQualifier()))); - auto v157 = e.ThisType(); - if (v157) { - auto id157 = es.EntityId(v157.value()); - b.setVal157(id157); - } else { - b.setVal157(mx::kInvalidEntityId); - } - b.setVal158(e.HasInlineBody()); - b.setVal159(e.IsConst()); - b.setVal160(e.IsCopyAssignmentOperator()); - b.setVal161(e.IsExplicitObjectMemberFunction()); - b.setVal162(e.IsImplicitObjectMemberFunction()); - b.setVal163(e.IsInstance()); - b.setVal164(e.IsLambdaStaticInvoker()); - b.setVal165(e.IsMoveAssignmentOperator()); - b.setVal166(e.IsVirtual()); - b.setVal167(e.IsVolatile()); + b.setVal155(es.EntityId(e.FunctionObjectParameterReferenceType())); + b.setVal156(es.EntityId(e.FunctionObjectParameterType())); + b.setVal157(static_cast(mx::FromPasta(e.ReferenceQualifier()))); + auto v158 = e.ThisType(); + if (v158) { + auto id158 = es.EntityId(v158.value()); + b.setVal158(id158); + } else { + b.setVal158(mx::kInvalidEntityId); + } + b.setVal159(e.HasInlineBody()); + b.setVal160(e.IsConst()); + b.setVal161(e.IsCopyAssignmentOperator()); + b.setVal162(e.IsExplicitObjectMemberFunction()); + b.setVal163(e.IsImplicitObjectMemberFunction()); + b.setVal164(e.IsInstance()); + b.setVal165(e.IsLambdaStaticInvoker()); + b.setVal166(e.IsMoveAssignmentOperator()); + b.setVal167(e.IsVirtual()); + b.setVal168(e.IsVolatile()); do { - auto v168 = e.OverriddenMethods(); - auto sv168 = b.initVal168(static_cast(v168.size())); - auto i168 = 0u; - for (const auto &e168 : v168) { - sv168.set(i168, es.EntityId(e168)); - ++i168; + auto v169 = e.OverriddenMethods(); + auto sv169 = b.initVal169(static_cast(v169.size())); + auto i169 = 0u; + for (const auto &e169 : v169) { + sv169.set(i169, es.EntityId(e169)); + ++i169; } } while (false); - b.setVal169(e.SizeOverriddenMethods()); + b.setVal170(e.SizeOverriddenMethods()); } void SerializeCXXDestructorDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::CXXDestructorDecl &e, const TokenTree *) { @@ -9927,20 +9929,20 @@ void SerializeCXXDestructorDecl(const PendingFragment &pf, const EntityMapper &e (void) b; (void) e; SerializeCXXMethodDecl(pf, es, b, e, nullptr); - auto v170 = e.OperatorDelete(); - if (v170) { - auto id170 = es.EntityId(v170.value()); - b.setVal170(id170); - } else { - b.setVal170(mx::kInvalidEntityId); - } - auto v171 = e.OperatorDeleteThisArgument(); + auto v171 = e.OperatorDelete(); if (v171) { auto id171 = es.EntityId(v171.value()); b.setVal171(id171); } else { b.setVal171(mx::kInvalidEntityId); } + auto v172 = e.OperatorDeleteThisArgument(); + if (v172) { + auto id172 = es.EntityId(v172.value()); + b.setVal172(id172); + } else { + b.setVal172(mx::kInvalidEntityId); + } } void SerializeCXXConversionDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::CXXConversionDecl &e, const TokenTree *) { @@ -9949,9 +9951,9 @@ void SerializeCXXConversionDecl(const PendingFragment &pf, const EntityMapper &e (void) b; (void) e; SerializeCXXMethodDecl(pf, es, b, e, nullptr); - b.setVal170(es.EntityId(e.ConversionType())); - b.setVal172(e.IsExplicit()); - b.setVal173(e.IsLambdaToBlockPointerConversion()); + b.setVal171(es.EntityId(e.ConversionType())); + b.setVal173(e.IsExplicit()); + b.setVal174(e.IsLambdaToBlockPointerConversion()); } void SerializeCXXConstructorDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::CXXConstructorDecl &e, const TokenTree *) { @@ -9960,27 +9962,27 @@ void SerializeCXXConstructorDecl(const PendingFragment &pf, const EntityMapper & (void) b; (void) e; SerializeCXXMethodDecl(pf, es, b, e, nullptr); - auto v170 = e.TargetConstructor(); - if (v170) { - auto id170 = es.EntityId(v170.value()); - b.setVal170(id170); + auto v171 = e.TargetConstructor(); + if (v171) { + auto id171 = es.EntityId(v171.value()); + b.setVal171(id171); } else { - b.setVal170(mx::kInvalidEntityId); + b.setVal171(mx::kInvalidEntityId); } do { - auto v174 = e.Initializers(); - auto sv174 = b.initVal174(static_cast(v174.size())); - auto i174 = 0u; - for (const auto &e174 : v174) { - sv174.set(i174, es.EntityId(e174)); - ++i174; + auto v175 = e.Initializers(); + auto sv175 = b.initVal175(static_cast(v175.size())); + auto i175 = 0u; + for (const auto &e175 : v175) { + sv175.set(i175, es.EntityId(e175)); + ++i175; } } while (false); - b.setVal172(e.IsDefaultConstructor()); - b.setVal173(e.IsDelegatingConstructor()); - b.setVal175(e.IsExplicit()); - b.setVal176(e.IsInheritingConstructor()); - b.setVal177(e.IsSpecializationCopyingObject()); + b.setVal173(e.IsDefaultConstructor()); + b.setVal174(e.IsDelegatingConstructor()); + b.setVal176(e.IsExplicit()); + b.setVal177(e.IsInheritingConstructor()); + b.setVal178(e.IsSpecializationCopyingObject()); } void SerializeCXXDeductionGuideDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::CXXDeductionGuideDecl &e, const TokenTree *) { @@ -9989,16 +9991,16 @@ void SerializeCXXDeductionGuideDecl(const PendingFragment &pf, const EntityMappe (void) b; (void) e; SerializeFunctionDecl(pf, es, b, e, nullptr); - auto v154 = e.CorrespondingConstructor(); - if (v154) { - auto id154 = es.EntityId(v154.value()); - b.setVal154(id154); + auto v155 = e.CorrespondingConstructor(); + if (v155) { + auto id155 = es.EntityId(v155.value()); + b.setVal155(id155); } else { - b.setVal154(mx::kInvalidEntityId); + b.setVal155(mx::kInvalidEntityId); } - b.setVal155(es.EntityId(e.DeducedTemplate())); - b.setVal156(static_cast(mx::FromPasta(e.DeductionCandidateKind()))); - b.setVal158(e.IsExplicit()); + b.setVal156(es.EntityId(e.DeducedTemplate())); + b.setVal157(static_cast(mx::FromPasta(e.DeductionCandidateKind()))); + b.setVal159(e.IsExplicit()); } void SerializeFieldDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::FieldDecl &e, const TokenTree *) { @@ -10007,45 +10009,45 @@ void SerializeFieldDecl(const PendingFragment &pf, const EntityMapper &es, mx::a (void) b; (void) e; SerializeDeclaratorDecl(pf, es, b, e, nullptr); - auto v71 = e.BitWidth(); - if (v71) { - auto id71 = es.EntityId(v71.value()); - b.setVal71(id71); - } else { - b.setVal71(mx::kInvalidEntityId); - } - auto v73 = e.CapturedVLAType(); - if (v73) { - auto id73 = es.EntityId(v73.value()); - b.setVal73(id73); + auto v72 = e.BitWidth(); + if (v72) { + auto id72 = es.EntityId(v72.value()); + b.setVal72(id72); } else { - b.setVal73(mx::kInvalidEntityId); + b.setVal72(mx::kInvalidEntityId); } - b.setVal41(e.FieldIndex()); - b.setVal72(static_cast(mx::FromPasta(e.InClassInitializerStyle()))); - auto v74 = e.InClassInitializer(); + auto v74 = e.CapturedVLAType(); if (v74) { auto id74 = es.EntityId(v74.value()); b.setVal74(id74); } else { b.setVal74(mx::kInvalidEntityId); } - b.setVal68(e.HasCapturedVLAType()); - b.setVal69(e.HasInClassInitializer()); - b.setVal81(e.HasNonNullInClassInitializer()); - b.setVal82(e.IsAnonymousStructOrUnion()); - b.setVal83(e.IsBitField()); - b.setVal84(e.IsMutable()); - b.setVal85(e.IsPotentiallyOverlapping()); - b.setVal86(e.IsUnnamedBitfield()); - b.setVal87(e.IsZeroLengthBitField()); - b.setVal88(e.IsZeroSize()); - auto v75 = e.OffsetInBits(); + b.setVal42(e.FieldIndex()); + b.setVal73(static_cast(mx::FromPasta(e.InClassInitializerStyle()))); + auto v75 = e.InClassInitializer(); if (v75) { - b.setVal75(static_cast(v75.value())); - b.setVal89(true); + auto id75 = es.EntityId(v75.value()); + b.setVal75(id75); } else { - b.setVal89(false); + b.setVal75(mx::kInvalidEntityId); + } + b.setVal69(e.HasCapturedVLAType()); + b.setVal70(e.HasInClassInitializer()); + b.setVal82(e.HasNonNullInClassInitializer()); + b.setVal83(e.IsAnonymousStructOrUnion()); + b.setVal84(e.IsBitField()); + b.setVal85(e.IsMutable()); + b.setVal86(e.IsPotentiallyOverlapping()); + b.setVal87(e.IsUnnamedBitfield()); + b.setVal88(e.IsZeroLengthBitField()); + b.setVal89(e.IsZeroSize()); + auto v76 = e.OffsetInBits(); + if (v76) { + b.setVal76(static_cast(v76.value())); + b.setVal90(true); + } else { + b.setVal90(false); } } @@ -10055,11 +10057,11 @@ void SerializeObjCIvarDecl(const PendingFragment &pf, const EntityMapper &es, mx (void) b; (void) e; SerializeFieldDecl(pf, es, b, e, nullptr); - b.setVal76(static_cast(mx::FromPasta(e.AccessControl()))); - b.setVal77(static_cast(mx::FromPasta(e.CanonicalAccessControl()))); - b.setVal113(es.EntityId(e.ContainingInterface())); - b.setVal114(es.EntityId(e.NextInstanceVariable())); - b.setVal90(e.Synthesize()); + b.setVal77(static_cast(mx::FromPasta(e.AccessControl()))); + b.setVal78(static_cast(mx::FromPasta(e.CanonicalAccessControl()))); + b.setVal114(es.EntityId(e.ContainingInterface())); + b.setVal115(es.EntityId(e.NextInstanceVariable())); + b.setVal91(e.Synthesize()); } void SerializeObjCAtDefsFieldDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ObjCAtDefsFieldDecl &e, const TokenTree *) { @@ -10076,20 +10078,20 @@ void SerializeBindingDecl(const PendingFragment &pf, const EntityMapper &es, mx: (void) b; (void) e; SerializeValueDecl(pf, es, b, e, nullptr); - auto v50 = e.Binding(); - if (v50) { - auto id50 = es.EntityId(v50.value()); - b.setVal50(id50); + auto v51 = e.Binding(); + if (v51) { + auto id51 = es.EntityId(v51.value()); + b.setVal51(id51); } else { - b.setVal50(mx::kInvalidEntityId); + b.setVal51(mx::kInvalidEntityId); } - b.setVal58(es.EntityId(e.DecomposedDeclaration())); - auto v59 = e.HoldingVariable(); - if (v59) { - auto id59 = es.EntityId(v59.value()); - b.setVal59(id59); + b.setVal59(es.EntityId(e.DecomposedDeclaration())); + auto v60 = e.HoldingVariable(); + if (v60) { + auto id60 = es.EntityId(v60.value()); + b.setVal60(id60); } else { - b.setVal59(mx::kInvalidEntityId); + b.setVal60(mx::kInvalidEntityId); } } @@ -10107,7 +10109,7 @@ void SerializeOMPDeclareMapperDecl(const PendingFragment &pf, const EntityMapper (void) b; (void) e; SerializeOMPDeclarativeDirectiveValueDecl(pf, es, b, e, nullptr); - b.setVal50(es.EntityId(e.MapperVariableReference())); + b.setVal51(es.EntityId(e.MapperVariableReference())); } void SerializeUsingShadowDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::UsingShadowDecl &e, const TokenTree *) { @@ -10116,15 +10118,15 @@ void SerializeUsingShadowDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - b.setVal48(es.EntityId(e.Introducer())); - auto v49 = e.NextUsingShadowDeclaration(); - if (v49) { - auto id49 = es.EntityId(v49.value()); - b.setVal49(id49); + b.setVal49(es.EntityId(e.Introducer())); + auto v50 = e.NextUsingShadowDeclaration(); + if (v50) { + auto id50 = es.EntityId(v50.value()); + b.setVal50(id50); } else { - b.setVal49(mx::kInvalidEntityId); + b.setVal50(mx::kInvalidEntityId); } - b.setVal50(es.EntityId(e.TargetDeclaration())); + b.setVal51(es.EntityId(e.TargetDeclaration())); } void SerializeConstructorUsingShadowDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ConstructorUsingShadowDecl &e, const TokenTree *) { @@ -10133,22 +10135,22 @@ void SerializeConstructorUsingShadowDecl(const PendingFragment &pf, const Entity (void) b; (void) e; SerializeUsingShadowDecl(pf, es, b, e, nullptr); - b.setVal66(e.ConstructsVirtualBase()); - b.setVal58(es.EntityId(e.ConstructedBaseClass())); - auto v59 = e.ConstructedBaseClassShadowDeclaration(); - if (v59) { - auto id59 = es.EntityId(v59.value()); - b.setVal59(id59); + b.setVal67(e.ConstructsVirtualBase()); + b.setVal59(es.EntityId(e.ConstructedBaseClass())); + auto v60 = e.ConstructedBaseClassShadowDeclaration(); + if (v60) { + auto id60 = es.EntityId(v60.value()); + b.setVal60(id60); } else { - b.setVal59(mx::kInvalidEntityId); + b.setVal60(mx::kInvalidEntityId); } - b.setVal60(es.EntityId(e.NominatedBaseClass())); - auto v70 = e.NominatedBaseClassShadowDeclaration(); - if (v70) { - auto id70 = es.EntityId(v70.value()); - b.setVal70(id70); + b.setVal61(es.EntityId(e.NominatedBaseClass())); + auto v71 = e.NominatedBaseClassShadowDeclaration(); + if (v71) { + auto id71 = es.EntityId(v71.value()); + b.setVal71(id71); } else { - b.setVal70(mx::kInvalidEntityId); + b.setVal71(mx::kInvalidEntityId); } } @@ -10159,12 +10161,12 @@ void SerializeUsingPackDecl(const PendingFragment &pf, const EntityMapper &es, m (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); do { - auto v43 = e.Expansions(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.Expansions(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -10175,14 +10177,14 @@ void SerializeUsingDirectiveDecl(const PendingFragment &pf, const EntityMapper & (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto et48 = es.EntityId(e.IdentifierToken()); - b.setVal48(et48); - auto et49 = es.EntityId(e.NamespaceKeyToken()); + auto et49 = es.EntityId(e.IdentifierToken()); b.setVal49(et49); - b.setVal50(es.EntityId(e.NominatedNamespace())); - b.setVal58(es.EntityId(e.NominatedNamespaceAsWritten())); - auto et59 = es.EntityId(e.UsingToken()); - b.setVal59(et59); + auto et50 = es.EntityId(e.NamespaceKeyToken()); + b.setVal50(et50); + b.setVal51(es.EntityId(e.NominatedNamespace())); + b.setVal59(es.EntityId(e.NominatedNamespaceAsWritten())); + auto et60 = es.EntityId(e.UsingToken()); + b.setVal60(et60); } void SerializeUnresolvedUsingIfExistsDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::UnresolvedUsingIfExistsDecl &e, const TokenTree *) { @@ -10199,12 +10201,12 @@ void SerializeTypeDecl(const PendingFragment &pf, const EntityMapper &es, mx::as (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto v48 = e.TypeForDeclaration(); - if (v48) { - auto id48 = es.EntityId(v48.value()); - b.setVal48(id48); + auto v49 = e.TypeForDeclaration(); + if (v49) { + auto id49 = es.EntityId(v49.value()); + b.setVal49(id49); } else { - b.setVal48(mx::kInvalidEntityId); + b.setVal49(mx::kInvalidEntityId); } } @@ -10214,30 +10216,30 @@ void SerializeTemplateTypeParmDecl(const PendingFragment &pf, const EntityMapper (void) b; (void) e; SerializeTypeDecl(pf, es, b, e, nullptr); - b.setVal66(e.DefaultArgumentWasInherited()); - auto v49 = e.DefaultArgument(); - if (v49) { - auto id49 = es.EntityId(v49.value()); - b.setVal49(id49); - } else { - b.setVal49(mx::kInvalidEntityId); - } - auto v50 = e.DefaultArgumentInfo(); + b.setVal67(e.DefaultArgumentWasInherited()); + auto v50 = e.DefaultArgument(); if (v50) { auto id50 = es.EntityId(v50.value()); b.setVal50(id50); } else { b.setVal50(mx::kInvalidEntityId); } - auto et58 = es.EntityId(e.DefaultArgumentToken()); - b.setVal58(et58); - b.setVal41(e.Depth()); - b.setVal117(e.Index()); - b.setVal67(e.HasDefaultArgument()); - b.setVal68(e.HasTypeConstraint()); - b.setVal69(e.IsExpandedParameterPack()); - b.setVal81(e.IsPackExpansion()); - b.setVal82(e.WasDeclaredWithTypename()); + auto v51 = e.DefaultArgumentInfo(); + if (v51) { + auto id51 = es.EntityId(v51.value()); + b.setVal51(id51); + } else { + b.setVal51(mx::kInvalidEntityId); + } + auto et59 = es.EntityId(e.DefaultArgumentToken()); + b.setVal59(et59); + b.setVal42(e.Depth()); + b.setVal118(e.Index()); + b.setVal68(e.HasDefaultArgument()); + b.setVal69(e.HasTypeConstraint()); + b.setVal70(e.IsExpandedParameterPack()); + b.setVal82(e.IsPackExpansion()); + b.setVal83(e.WasDeclaredWithTypename()); } void SerializeTagDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::TagDecl &e, const TokenTree *) { @@ -10246,42 +10248,42 @@ void SerializeTagDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast (void) b; (void) e; SerializeTypeDecl(pf, es, b, e, nullptr); - auto p49 = es.EntityIds(e.BraceRange()); - b.setVal49(p49.first); - b.setVal50(p49.second); - auto et58 = es.EntityId(e.FirstInnerToken()); - b.setVal58(et58); - auto et59 = es.EntityId(e.FirstOuterToken()); + auto p50 = es.EntityIds(e.BraceRange()); + b.setVal50(p50.first); + b.setVal51(p50.second); + auto et59 = es.EntityId(e.FirstInnerToken()); b.setVal59(et59); - b.setVal72(static_cast(mx::FromPasta(e.TagKind()))); - auto v60 = e.TypedefNameForAnonymousDeclaration(); - if (v60) { - auto id60 = es.EntityId(v60.value()); - b.setVal60(id60); - } else { - b.setVal60(mx::kInvalidEntityId); - } - b.setVal66(e.HasNameForLinkage()); - b.setVal67(e.IsBeingDefined()); - b.setVal68(e.IsClass()); - b.setVal69(e.IsCompleteDefinition()); - b.setVal81(e.IsCompleteDefinitionRequired()); - b.setVal82(e.IsDependentType()); - b.setVal83(e.IsEnum()); - b.setVal84(e.IsFreeStanding()); - b.setVal85(e.IsInterface()); - b.setVal86(e.IsStruct()); - b.setVal87(e.IsThisDeclarationADefinition()); - b.setVal88(e.IsThisDeclarationADemotedDefinition()); - b.setVal89(e.IsUnion()); - b.setVal90(e.MayHaveOutOfDateDefinition()); + auto et60 = es.EntityId(e.FirstOuterToken()); + b.setVal60(et60); + b.setVal73(static_cast(mx::FromPasta(e.TagKind()))); + auto v61 = e.TypedefNameForAnonymousDeclaration(); + if (v61) { + auto id61 = es.EntityId(v61.value()); + b.setVal61(id61); + } else { + b.setVal61(mx::kInvalidEntityId); + } + b.setVal67(e.HasNameForLinkage()); + b.setVal68(e.IsBeingDefined()); + b.setVal69(e.IsClass()); + b.setVal70(e.IsCompleteDefinition()); + b.setVal82(e.IsCompleteDefinitionRequired()); + b.setVal83(e.IsDependentType()); + b.setVal84(e.IsEnum()); + b.setVal85(e.IsFreeStanding()); + b.setVal86(e.IsInterface()); + b.setVal87(e.IsStruct()); + b.setVal88(e.IsThisDeclarationADefinition()); + b.setVal89(e.IsThisDeclarationADemotedDefinition()); + b.setVal90(e.IsUnion()); + b.setVal91(e.MayHaveOutOfDateDefinition()); do { - auto v43 = e.TemplateParameterLists(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.TemplateParameterLists(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -10292,56 +10294,56 @@ void SerializeRecordDecl(const PendingFragment &pf, const EntityMapper &es, mx:: (void) b; (void) e; SerializeTagDecl(pf, es, b, e, nullptr); - b.setVal91(e.CanPassInRegisters()); + b.setVal92(e.CanPassInRegisters()); do { - auto v54 = e.Fields(); - auto sv54 = b.initVal54(static_cast(v54.size())); - auto i54 = 0u; - for (const auto &e54 : v54) { - sv54.set(i54, es.EntityId(e54)); - ++i54; + auto v55 = e.Fields(); + auto sv55 = b.initVal55(static_cast(v55.size())); + auto i55 = 0u; + for (const auto &e55 : v55) { + sv55.set(i55, es.EntityId(e55)); + ++i55; } } while (false); - b.setVal76(static_cast(mx::FromPasta(e.ArgumentPassingRestrictions()))); - b.setVal92(e.HasFlexibleArrayMember()); - b.setVal93(e.HasLoadedFieldsFromExternalStorage()); - b.setVal94(e.HasNonTrivialToPrimitiveCopyCUnion()); - b.setVal95(e.HasNonTrivialToPrimitiveDefaultInitializeCUnion()); - b.setVal96(e.HasNonTrivialToPrimitiveDestructCUnion()); - b.setVal97(e.HasObjectMember()); - b.setVal98(e.HasVolatileMember()); - b.setVal99(e.IsAnonymousStructOrUnion()); - b.setVal100(e.IsCapturedRecord()); - b.setVal101(e.IsInjectedClassName()); - b.setVal102(e.IsLambda()); - b.setVal103(e.IsMsStruct()); - b.setVal104(e.IsNonTrivialToPrimitiveCopy()); - b.setVal105(e.IsNonTrivialToPrimitiveDefaultInitialize()); - b.setVal106(e.IsNonTrivialToPrimitiveDestroy()); - b.setVal107(e.IsOrContainsUnion()); - b.setVal108(e.IsParameterDestroyedInCallee()); - b.setVal109(e.IsRandomized()); - b.setVal110(e.MayInsertExtraPadding()); - auto v70 = e.Size(); - if (v70) { - b.setVal70(static_cast(v70.value())); - b.setVal111(true); - } else { - b.setVal111(false); - } - auto v71 = e.Alignment(); + b.setVal77(static_cast(mx::FromPasta(e.ArgumentPassingRestrictions()))); + b.setVal93(e.HasFlexibleArrayMember()); + b.setVal94(e.HasLoadedFieldsFromExternalStorage()); + b.setVal95(e.HasNonTrivialToPrimitiveCopyCUnion()); + b.setVal96(e.HasNonTrivialToPrimitiveDefaultInitializeCUnion()); + b.setVal97(e.HasNonTrivialToPrimitiveDestructCUnion()); + b.setVal98(e.HasObjectMember()); + b.setVal99(e.HasVolatileMember()); + b.setVal100(e.IsAnonymousStructOrUnion()); + b.setVal101(e.IsCapturedRecord()); + b.setVal102(e.IsInjectedClassName()); + b.setVal103(e.IsLambda()); + b.setVal104(e.IsMsStruct()); + b.setVal105(e.IsNonTrivialToPrimitiveCopy()); + b.setVal106(e.IsNonTrivialToPrimitiveDefaultInitialize()); + b.setVal107(e.IsNonTrivialToPrimitiveDestroy()); + b.setVal108(e.IsOrContainsUnion()); + b.setVal109(e.IsParameterDestroyedInCallee()); + b.setVal110(e.IsRandomized()); + b.setVal111(e.MayInsertExtraPadding()); + auto v71 = e.Size(); if (v71) { b.setVal71(static_cast(v71.value())); b.setVal112(true); } else { b.setVal112(false); } - auto v73 = e.SizeWithoutTrailingPadding(); - if (v73) { - b.setVal73(static_cast(v73.value())); - b.setVal121(true); + auto v72 = e.Alignment(); + if (v72) { + b.setVal72(static_cast(v72.value())); + b.setVal113(true); + } else { + b.setVal113(false); + } + auto v74 = e.SizeWithoutTrailingPadding(); + if (v74) { + b.setVal74(static_cast(v74.value())); + b.setVal122(true); } else { - b.setVal121(false); + b.setVal122(false); } } @@ -10351,850 +10353,850 @@ void SerializeCXXRecordDecl(const PendingFragment &pf, const EntityMapper &es, m (void) b; (void) e; SerializeRecordDecl(pf, es, b, e, nullptr); - auto v122 = e.AllowConstDefaultInitializer(); - if (v122) { - b.setVal122(static_cast(v122.value())); - b.setVal123(true); + auto v123 = e.AllowConstDefaultInitializer(); + if (v123) { + b.setVal123(static_cast(v123.value())); + b.setVal124(true); } else { - b.setVal123(false); + b.setVal124(false); } do { - auto ov153 = e.Bases(); - if (!ov153) { - b.setVal124(false); + auto ov154 = e.Bases(); + if (!ov154) { + b.setVal125(false); break; } - b.setVal124(true); - auto v153 = std::move(*ov153); - auto sv153 = b.initVal153(static_cast(v153.size())); - auto i153 = 0u; - for (const auto &e153 : v153) { - sv153.set(i153, es.EntityId(e153)); - ++i153; + b.setVal125(true); + auto v154 = std::move(*ov154); + auto sv154 = b.initVal154(static_cast(v154.size())); + auto i154 = 0u; + for (const auto &e154 : v154) { + sv154.set(i154, es.EntityId(e154)); + ++i154; } } while (false); - auto v77 = e.CalculateInheritanceModel(); - if (v77) { - b.setVal77(static_cast(v77.value())); - b.setVal125(true); + auto v78 = e.CalculateInheritanceModel(); + if (v78) { + b.setVal78(static_cast(v78.value())); + b.setVal126(true); } else { - b.setVal125(false); + b.setVal126(false); } do { - auto v168 = e.Constructors(); - auto sv168 = b.initVal168(static_cast(v168.size())); - auto i168 = 0u; - for (const auto &e168 : v168) { - sv168.set(i168, es.EntityId(e168)); - ++i168; + auto v169 = e.Constructors(); + auto sv169 = b.initVal169(static_cast(v169.size())); + auto i169 = 0u; + for (const auto &e169 : v169) { + sv169.set(i169, es.EntityId(e169)); + ++i169; } } while (false); do { - auto ov174 = e.Friends(); - if (!ov174) { - b.setVal126(false); + auto ov175 = e.Friends(); + if (!ov175) { + b.setVal127(false); break; } - b.setVal126(true); - auto v174 = std::move(*ov174); - auto sv174 = b.initVal174(static_cast(v174.size())); - auto i174 = 0u; - for (const auto &e174 : v174) { - sv174.set(i174, es.EntityId(e174)); - ++i174; + b.setVal127(true); + auto v175 = std::move(*ov175); + auto sv175 = b.initVal175(static_cast(v175.size())); + auto i175 = 0u; + for (const auto &e175 : v175) { + sv175.set(i175, es.EntityId(e175)); + ++i175; } } while (false); - auto v74 = e.DependentLambdaCallOperator(); - if (v74) { - auto id74 = es.EntityId(v74.value()); - b.setVal74(id74); - } else { - b.setVal74(mx::kInvalidEntityId); - } - auto v75 = e.DescribedClassTemplate(); + auto v75 = e.DependentLambdaCallOperator(); if (v75) { auto id75 = es.EntityId(v75.value()); b.setVal75(id75); } else { b.setVal75(mx::kInvalidEntityId); } - auto v113 = e.Destructor(); - if (v113) { - auto id113 = es.EntityId(v113.value()); - b.setVal113(id113); + auto v76 = e.DescribedClassTemplate(); + if (v76) { + auto id76 = es.EntityId(v76.value()); + b.setVal76(id76); } else { - b.setVal113(mx::kInvalidEntityId); + b.setVal76(mx::kInvalidEntityId); } - auto v114 = e.GenericLambdaTemplateParameterList(); + auto v114 = e.Destructor(); if (v114) { auto id114 = es.EntityId(v114.value()); b.setVal114(id114); } else { b.setVal114(mx::kInvalidEntityId); } - auto v115 = e.InstantiatedFromMemberClass(); + auto v115 = e.GenericLambdaTemplateParameterList(); if (v115) { auto id115 = es.EntityId(v115.value()); b.setVal115(id115); } else { b.setVal115(mx::kInvalidEntityId); } - auto v116 = e.LambdaCallOperator(); + auto v116 = e.InstantiatedFromMemberClass(); if (v116) { auto id116 = es.EntityId(v116.value()); b.setVal116(id116); } else { b.setVal116(mx::kInvalidEntityId); } - auto v78 = e.LambdaCaptureDefault(); - if (v78) { - b.setVal78(static_cast(v78.value())); - b.setVal127(true); - } else { - b.setVal127(false); - } - auto v119 = e.LambdaContextDeclaration(); - if (v119) { - auto id119 = es.EntityId(v119.value()); - b.setVal119(id119); + auto v117 = e.LambdaCallOperator(); + if (v117) { + auto id117 = es.EntityId(v117.value()); + b.setVal117(id117); } else { - b.setVal119(mx::kInvalidEntityId); + b.setVal117(mx::kInvalidEntityId); } - b.setVal41(e.LambdaDependencyKind()); - do { - auto ov178 = e.LambdaExplicitTemplateParameters(); - if (!ov178) { - b.setVal128(false); - break; - } + auto v79 = e.LambdaCaptureDefault(); + if (v79) { + b.setVal79(static_cast(v79.value())); b.setVal128(true); - auto v178 = std::move(*ov178); - auto sv178 = b.initVal178(static_cast(v178.size())); - auto i178 = 0u; - for (const auto &e178 : v178) { - sv178.set(i178, es.EntityId(e178)); - ++i178; - } - } while (false); - auto v117 = e.LambdaManglingNumber(); - if (v117) { - b.setVal117(static_cast(v117.value())); - b.setVal131(true); } else { - b.setVal131(false); + b.setVal128(false); } - auto v120 = e.LambdaStaticInvoker(); + auto v120 = e.LambdaContextDeclaration(); if (v120) { auto id120 = es.EntityId(v120.value()); b.setVal120(id120); } else { b.setVal120(mx::kInvalidEntityId); } - auto v79 = e.MSInheritanceModel(); - if (v79) { - b.setVal79(static_cast(v79.value())); + b.setVal42(e.LambdaDependencyKind()); + do { + auto ov179 = e.LambdaExplicitTemplateParameters(); + if (!ov179) { + b.setVal129(false); + break; + } + b.setVal129(true); + auto v179 = std::move(*ov179); + auto sv179 = b.initVal179(static_cast(v179.size())); + auto i179 = 0u; + for (const auto &e179 : v179) { + sv179.set(i179, es.EntityId(e179)); + ++i179; + } + } while (false); + auto v118 = e.LambdaManglingNumber(); + if (v118) { + b.setVal118(static_cast(v118.value())); b.setVal132(true); } else { b.setVal132(false); } - b.setVal80(static_cast(mx::FromPasta(e.MSVtorDispMode()))); - auto v133 = e.HasAnyDependentBases(); - if (v133) { - b.setVal133(static_cast(v133.value())); - b.setVal134(true); + auto v121 = e.LambdaStaticInvoker(); + if (v121) { + auto id121 = es.EntityId(v121.value()); + b.setVal121(id121); } else { - b.setVal134(false); + b.setVal121(mx::kInvalidEntityId); } - auto v135 = e.HasConstexprDefaultConstructor(); - if (v135) { - b.setVal135(static_cast(v135.value())); - b.setVal136(true); + auto v80 = e.MSInheritanceModel(); + if (v80) { + b.setVal80(static_cast(v80.value())); + b.setVal133(true); } else { - b.setVal136(false); + b.setVal133(false); } - auto v137 = e.HasConstexprDestructor(); - if (v137) { - b.setVal137(static_cast(v137.value())); - b.setVal138(true); + b.setVal81(static_cast(mx::FromPasta(e.MSVtorDispMode()))); + auto v134 = e.HasAnyDependentBases(); + if (v134) { + b.setVal134(static_cast(v134.value())); + b.setVal135(true); } else { - b.setVal138(false); + b.setVal135(false); } - auto v139 = e.HasConstexprNonCopyMoveConstructor(); - if (v139) { - b.setVal139(static_cast(v139.value())); - b.setVal140(true); + auto v136 = e.HasConstexprDefaultConstructor(); + if (v136) { + b.setVal136(static_cast(v136.value())); + b.setVal137(true); } else { - b.setVal140(false); + b.setVal137(false); } - auto v141 = e.HasCopyAssignmentWithConstParameter(); - if (v141) { - b.setVal141(static_cast(v141.value())); - b.setVal142(true); + auto v138 = e.HasConstexprDestructor(); + if (v138) { + b.setVal138(static_cast(v138.value())); + b.setVal139(true); } else { - b.setVal142(false); + b.setVal139(false); } - auto v143 = e.HasCopyConstructorWithConstParameter(); - if (v143) { - b.setVal143(static_cast(v143.value())); - b.setVal144(true); + auto v140 = e.HasConstexprNonCopyMoveConstructor(); + if (v140) { + b.setVal140(static_cast(v140.value())); + b.setVal141(true); } else { - b.setVal144(false); + b.setVal141(false); } - auto v145 = e.HasDefaultConstructor(); - if (v145) { - b.setVal145(static_cast(v145.value())); - b.setVal146(true); + auto v142 = e.HasCopyAssignmentWithConstParameter(); + if (v142) { + b.setVal142(static_cast(v142.value())); + b.setVal143(true); } else { - b.setVal146(false); + b.setVal143(false); } - auto v147 = e.HasDefinition(); - if (v147) { - b.setVal147(static_cast(v147.value())); - b.setVal148(true); + auto v144 = e.HasCopyConstructorWithConstParameter(); + if (v144) { + b.setVal144(static_cast(v144.value())); + b.setVal145(true); } else { - b.setVal148(false); + b.setVal145(false); } - auto v149 = e.HasDirectFields(); - if (v149) { - b.setVal149(static_cast(v149.value())); - b.setVal150(true); + auto v146 = e.HasDefaultConstructor(); + if (v146) { + b.setVal146(static_cast(v146.value())); + b.setVal147(true); } else { - b.setVal150(false); + b.setVal147(false); } - auto v151 = e.HasFriends(); - if (v151) { - b.setVal151(static_cast(v151.value())); - b.setVal158(true); + auto v148 = e.HasDefinition(); + if (v148) { + b.setVal148(static_cast(v148.value())); + b.setVal149(true); } else { - b.setVal158(false); + b.setVal149(false); } - auto v159 = e.HasInClassInitializer(); - if (v159) { - b.setVal159(static_cast(v159.value())); - b.setVal160(true); + auto v150 = e.HasDirectFields(); + if (v150) { + b.setVal150(static_cast(v150.value())); + b.setVal151(true); } else { - b.setVal160(false); + b.setVal151(false); } - auto v161 = e.HasInheritedAssignment(); - if (v161) { - b.setVal161(static_cast(v161.value())); - b.setVal162(true); + auto v152 = e.HasFriends(); + if (v152) { + b.setVal152(static_cast(v152.value())); + b.setVal159(true); } else { - b.setVal162(false); + b.setVal159(false); } - auto v163 = e.HasInheritedConstructor(); - if (v163) { - b.setVal163(static_cast(v163.value())); - b.setVal164(true); + auto v160 = e.HasInClassInitializer(); + if (v160) { + b.setVal160(static_cast(v160.value())); + b.setVal161(true); } else { - b.setVal164(false); + b.setVal161(false); } - auto v165 = e.HasInitializerMethod(); - if (v165) { - b.setVal165(static_cast(v165.value())); - b.setVal166(true); + auto v162 = e.HasInheritedAssignment(); + if (v162) { + b.setVal162(static_cast(v162.value())); + b.setVal163(true); } else { - b.setVal166(false); + b.setVal163(false); } - auto v167 = e.HasIrrelevantDestructor(); - if (v167) { - b.setVal167(static_cast(v167.value())); - b.setVal172(true); + auto v164 = e.HasInheritedConstructor(); + if (v164) { + b.setVal164(static_cast(v164.value())); + b.setVal165(true); } else { - b.setVal172(false); + b.setVal165(false); } - auto v173 = e.HasKnownLambdaInternalLinkage(); - if (v173) { - b.setVal173(static_cast(v173.value())); - b.setVal175(true); + auto v166 = e.HasInitializerMethod(); + if (v166) { + b.setVal166(static_cast(v166.value())); + b.setVal167(true); } else { - b.setVal175(false); + b.setVal167(false); } - auto v176 = e.HasMoveAssignment(); - if (v176) { - b.setVal176(static_cast(v176.value())); - b.setVal177(true); + auto v168 = e.HasIrrelevantDestructor(); + if (v168) { + b.setVal168(static_cast(v168.value())); + b.setVal173(true); } else { - b.setVal177(false); + b.setVal173(false); } - auto v179 = e.HasMoveConstructor(); - if (v179) { - b.setVal179(static_cast(v179.value())); - b.setVal180(true); + auto v174 = e.HasKnownLambdaInternalLinkage(); + if (v174) { + b.setVal174(static_cast(v174.value())); + b.setVal176(true); } else { - b.setVal180(false); + b.setVal176(false); } - auto v181 = e.HasMutableFields(); - if (v181) { - b.setVal181(static_cast(v181.value())); - b.setVal182(true); + auto v177 = e.HasMoveAssignment(); + if (v177) { + b.setVal177(static_cast(v177.value())); + b.setVal178(true); } else { - b.setVal182(false); + b.setVal178(false); } - auto v183 = e.HasNonLiteralTypeFieldsOrBases(); - if (v183) { - b.setVal183(static_cast(v183.value())); - b.setVal184(true); + auto v180 = e.HasMoveConstructor(); + if (v180) { + b.setVal180(static_cast(v180.value())); + b.setVal181(true); } else { - b.setVal184(false); + b.setVal181(false); } - auto v185 = e.HasNonTrivialCopyAssignment(); - if (v185) { - b.setVal185(static_cast(v185.value())); - b.setVal186(true); + auto v182 = e.HasMutableFields(); + if (v182) { + b.setVal182(static_cast(v182.value())); + b.setVal183(true); } else { - b.setVal186(false); + b.setVal183(false); } - auto v187 = e.HasNonTrivialCopyConstructor(); - if (v187) { - b.setVal187(static_cast(v187.value())); - b.setVal188(true); + auto v184 = e.HasNonLiteralTypeFieldsOrBases(); + if (v184) { + b.setVal184(static_cast(v184.value())); + b.setVal185(true); } else { - b.setVal188(false); + b.setVal185(false); } - auto v189 = e.HasNonTrivialCopyConstructorForCall(); - if (v189) { - b.setVal189(static_cast(v189.value())); - b.setVal190(true); + auto v186 = e.HasNonTrivialCopyAssignment(); + if (v186) { + b.setVal186(static_cast(v186.value())); + b.setVal187(true); } else { - b.setVal190(false); + b.setVal187(false); } - auto v191 = e.HasNonTrivialDefaultConstructor(); - if (v191) { - b.setVal191(static_cast(v191.value())); - b.setVal192(true); + auto v188 = e.HasNonTrivialCopyConstructor(); + if (v188) { + b.setVal188(static_cast(v188.value())); + b.setVal189(true); } else { - b.setVal192(false); + b.setVal189(false); } - auto v193 = e.HasNonTrivialDestructor(); - if (v193) { - b.setVal193(static_cast(v193.value())); - b.setVal194(true); + auto v190 = e.HasNonTrivialCopyConstructorForCall(); + if (v190) { + b.setVal190(static_cast(v190.value())); + b.setVal191(true); } else { - b.setVal194(false); + b.setVal191(false); } - auto v195 = e.HasNonTrivialDestructorForCall(); - if (v195) { - b.setVal195(static_cast(v195.value())); - b.setVal196(true); + auto v192 = e.HasNonTrivialDefaultConstructor(); + if (v192) { + b.setVal192(static_cast(v192.value())); + b.setVal193(true); } else { - b.setVal196(false); + b.setVal193(false); } - auto v197 = e.HasNonTrivialMoveAssignment(); - if (v197) { - b.setVal197(static_cast(v197.value())); - b.setVal198(true); + auto v194 = e.HasNonTrivialDestructor(); + if (v194) { + b.setVal194(static_cast(v194.value())); + b.setVal195(true); } else { - b.setVal198(false); + b.setVal195(false); } - auto v199 = e.HasNonTrivialMoveConstructor(); - if (v199) { - b.setVal199(static_cast(v199.value())); - b.setVal200(true); + auto v196 = e.HasNonTrivialDestructorForCall(); + if (v196) { + b.setVal196(static_cast(v196.value())); + b.setVal197(true); } else { - b.setVal200(false); + b.setVal197(false); } - auto v201 = e.HasNonTrivialMoveConstructorForCall(); - if (v201) { - b.setVal201(static_cast(v201.value())); - b.setVal202(true); + auto v198 = e.HasNonTrivialMoveAssignment(); + if (v198) { + b.setVal198(static_cast(v198.value())); + b.setVal199(true); } else { - b.setVal202(false); + b.setVal199(false); } - auto v203 = e.HasPrivateFields(); - if (v203) { - b.setVal203(static_cast(v203.value())); - b.setVal204(true); + auto v200 = e.HasNonTrivialMoveConstructor(); + if (v200) { + b.setVal200(static_cast(v200.value())); + b.setVal201(true); } else { - b.setVal204(false); + b.setVal201(false); } - auto v205 = e.HasProtectedFields(); - if (v205) { - b.setVal205(static_cast(v205.value())); - b.setVal206(true); + auto v202 = e.HasNonTrivialMoveConstructorForCall(); + if (v202) { + b.setVal202(static_cast(v202.value())); + b.setVal203(true); } else { - b.setVal206(false); + b.setVal203(false); } - auto v207 = e.HasSimpleCopyAssignment(); - if (v207) { - b.setVal207(static_cast(v207.value())); - b.setVal208(true); + auto v204 = e.HasPrivateFields(); + if (v204) { + b.setVal204(static_cast(v204.value())); + b.setVal205(true); } else { - b.setVal208(false); + b.setVal205(false); } - auto v209 = e.HasSimpleCopyConstructor(); - if (v209) { - b.setVal209(static_cast(v209.value())); - b.setVal210(true); + auto v206 = e.HasProtectedFields(); + if (v206) { + b.setVal206(static_cast(v206.value())); + b.setVal207(true); } else { - b.setVal210(false); + b.setVal207(false); } - auto v211 = e.HasSimpleDestructor(); - if (v211) { - b.setVal211(static_cast(v211.value())); - b.setVal212(true); + auto v208 = e.HasSimpleCopyAssignment(); + if (v208) { + b.setVal208(static_cast(v208.value())); + b.setVal209(true); } else { - b.setVal212(false); + b.setVal209(false); } - auto v213 = e.HasSimpleMoveAssignment(); - if (v213) { - b.setVal213(static_cast(v213.value())); - b.setVal214(true); + auto v210 = e.HasSimpleCopyConstructor(); + if (v210) { + b.setVal210(static_cast(v210.value())); + b.setVal211(true); } else { - b.setVal214(false); + b.setVal211(false); } - auto v215 = e.HasSimpleMoveConstructor(); - if (v215) { - b.setVal215(static_cast(v215.value())); - b.setVal216(true); + auto v212 = e.HasSimpleDestructor(); + if (v212) { + b.setVal212(static_cast(v212.value())); + b.setVal213(true); } else { - b.setVal216(false); + b.setVal213(false); } - auto v217 = e.HasTrivialCopyAssignment(); - if (v217) { - b.setVal217(static_cast(v217.value())); - b.setVal218(true); + auto v214 = e.HasSimpleMoveAssignment(); + if (v214) { + b.setVal214(static_cast(v214.value())); + b.setVal215(true); } else { - b.setVal218(false); + b.setVal215(false); } - auto v219 = e.HasTrivialCopyConstructor(); - if (v219) { - b.setVal219(static_cast(v219.value())); - b.setVal220(true); + auto v216 = e.HasSimpleMoveConstructor(); + if (v216) { + b.setVal216(static_cast(v216.value())); + b.setVal217(true); } else { - b.setVal220(false); + b.setVal217(false); } - auto v221 = e.HasTrivialCopyConstructorForCall(); - if (v221) { - b.setVal221(static_cast(v221.value())); - b.setVal222(true); + auto v218 = e.HasTrivialCopyAssignment(); + if (v218) { + b.setVal218(static_cast(v218.value())); + b.setVal219(true); } else { - b.setVal222(false); + b.setVal219(false); } - auto v223 = e.HasTrivialDefaultConstructor(); - if (v223) { - b.setVal223(static_cast(v223.value())); - b.setVal224(true); + auto v220 = e.HasTrivialCopyConstructor(); + if (v220) { + b.setVal220(static_cast(v220.value())); + b.setVal221(true); } else { - b.setVal224(false); + b.setVal221(false); } - auto v225 = e.HasTrivialDestructor(); - if (v225) { - b.setVal225(static_cast(v225.value())); - b.setVal226(true); + auto v222 = e.HasTrivialCopyConstructorForCall(); + if (v222) { + b.setVal222(static_cast(v222.value())); + b.setVal223(true); } else { - b.setVal226(false); + b.setVal223(false); } - auto v227 = e.HasTrivialDestructorForCall(); - if (v227) { - b.setVal227(static_cast(v227.value())); - b.setVal228(true); + auto v224 = e.HasTrivialDefaultConstructor(); + if (v224) { + b.setVal224(static_cast(v224.value())); + b.setVal225(true); } else { - b.setVal228(false); + b.setVal225(false); } - auto v229 = e.HasTrivialMoveAssignment(); - if (v229) { - b.setVal229(static_cast(v229.value())); - b.setVal230(true); + auto v226 = e.HasTrivialDestructor(); + if (v226) { + b.setVal226(static_cast(v226.value())); + b.setVal227(true); } else { - b.setVal230(false); + b.setVal227(false); } - auto v231 = e.HasTrivialMoveConstructor(); - if (v231) { - b.setVal231(static_cast(v231.value())); - b.setVal232(true); + auto v228 = e.HasTrivialDestructorForCall(); + if (v228) { + b.setVal228(static_cast(v228.value())); + b.setVal229(true); } else { - b.setVal232(false); + b.setVal229(false); } - auto v233 = e.HasTrivialMoveConstructorForCall(); - if (v233) { - b.setVal233(static_cast(v233.value())); - b.setVal234(true); + auto v230 = e.HasTrivialMoveAssignment(); + if (v230) { + b.setVal230(static_cast(v230.value())); + b.setVal231(true); } else { - b.setVal234(false); + b.setVal231(false); } - auto v235 = e.HasUninitializedReferenceMember(); - if (v235) { - b.setVal235(static_cast(v235.value())); - b.setVal236(true); + auto v232 = e.HasTrivialMoveConstructor(); + if (v232) { + b.setVal232(static_cast(v232.value())); + b.setVal233(true); } else { - b.setVal236(false); + b.setVal233(false); } - auto v237 = e.HasUserDeclaredConstructor(); - if (v237) { - b.setVal237(static_cast(v237.value())); - b.setVal238(true); + auto v234 = e.HasTrivialMoveConstructorForCall(); + if (v234) { + b.setVal234(static_cast(v234.value())); + b.setVal235(true); } else { - b.setVal238(false); + b.setVal235(false); } - auto v239 = e.HasUserDeclaredCopyAssignment(); - if (v239) { - b.setVal239(static_cast(v239.value())); - b.setVal240(true); + auto v236 = e.HasUninitializedReferenceMember(); + if (v236) { + b.setVal236(static_cast(v236.value())); + b.setVal237(true); } else { - b.setVal240(false); + b.setVal237(false); } - auto v241 = e.HasUserDeclaredCopyConstructor(); - if (v241) { - b.setVal241(static_cast(v241.value())); - b.setVal242(true); + auto v238 = e.HasUserDeclaredConstructor(); + if (v238) { + b.setVal238(static_cast(v238.value())); + b.setVal239(true); } else { - b.setVal242(false); + b.setVal239(false); } - auto v243 = e.HasUserDeclaredDestructor(); - if (v243) { - b.setVal243(static_cast(v243.value())); - b.setVal244(true); + auto v240 = e.HasUserDeclaredCopyAssignment(); + if (v240) { + b.setVal240(static_cast(v240.value())); + b.setVal241(true); } else { - b.setVal244(false); + b.setVal241(false); } - auto v245 = e.HasUserDeclaredMoveAssignment(); - if (v245) { - b.setVal245(static_cast(v245.value())); - b.setVal246(true); + auto v242 = e.HasUserDeclaredCopyConstructor(); + if (v242) { + b.setVal242(static_cast(v242.value())); + b.setVal243(true); } else { - b.setVal246(false); + b.setVal243(false); } - auto v247 = e.HasUserDeclaredMoveConstructor(); - if (v247) { - b.setVal247(static_cast(v247.value())); - b.setVal248(true); + auto v244 = e.HasUserDeclaredDestructor(); + if (v244) { + b.setVal244(static_cast(v244.value())); + b.setVal245(true); } else { - b.setVal248(false); + b.setVal245(false); } - auto v249 = e.HasUserDeclaredMoveOperation(); - if (v249) { - b.setVal249(static_cast(v249.value())); - b.setVal250(true); + auto v246 = e.HasUserDeclaredMoveAssignment(); + if (v246) { + b.setVal246(static_cast(v246.value())); + b.setVal247(true); } else { - b.setVal250(false); + b.setVal247(false); } - auto v251 = e.HasUserProvidedDefaultConstructor(); - if (v251) { - b.setVal251(static_cast(v251.value())); - b.setVal252(true); + auto v248 = e.HasUserDeclaredMoveConstructor(); + if (v248) { + b.setVal248(static_cast(v248.value())); + b.setVal249(true); } else { - b.setVal252(false); + b.setVal249(false); } - auto v253 = e.HasVariantMembers(); - if (v253) { - b.setVal253(static_cast(v253.value())); - b.setVal254(true); + auto v250 = e.HasUserDeclaredMoveOperation(); + if (v250) { + b.setVal250(static_cast(v250.value())); + b.setVal251(true); } else { - b.setVal254(false); + b.setVal251(false); } - auto v255 = e.ImplicitCopyAssignmentHasConstParameter(); - if (v255) { - b.setVal255(static_cast(v255.value())); - b.setVal256(true); + auto v252 = e.HasUserProvidedDefaultConstructor(); + if (v252) { + b.setVal252(static_cast(v252.value())); + b.setVal253(true); } else { - b.setVal256(false); + b.setVal253(false); } - auto v257 = e.ImplicitCopyConstructorHasConstParameter(); - if (v257) { - b.setVal257(static_cast(v257.value())); - b.setVal258(true); + auto v254 = e.HasVariantMembers(); + if (v254) { + b.setVal254(static_cast(v254.value())); + b.setVal255(true); } else { - b.setVal258(false); + b.setVal255(false); } - auto v259 = e.IsAbstract(); - if (v259) { - b.setVal259(static_cast(v259.value())); - b.setVal260(true); + auto v256 = e.ImplicitCopyAssignmentHasConstParameter(); + if (v256) { + b.setVal256(static_cast(v256.value())); + b.setVal257(true); } else { - b.setVal260(false); + b.setVal257(false); } - auto v261 = e.IsAggregate(); - if (v261) { - b.setVal261(static_cast(v261.value())); - b.setVal262(true); + auto v258 = e.ImplicitCopyConstructorHasConstParameter(); + if (v258) { + b.setVal258(static_cast(v258.value())); + b.setVal259(true); } else { - b.setVal262(false); + b.setVal259(false); } - auto v263 = e.IsAnyDestructorNoReturn(); - if (v263) { - b.setVal263(static_cast(v263.value())); - b.setVal264(true); + auto v260 = e.IsAbstract(); + if (v260) { + b.setVal260(static_cast(v260.value())); + b.setVal261(true); } else { - b.setVal264(false); + b.setVal261(false); } - auto v265 = e.IsCLike(); - if (v265) { - b.setVal265(static_cast(v265.value())); - b.setVal266(true); + auto v262 = e.IsAggregate(); + if (v262) { + b.setVal262(static_cast(v262.value())); + b.setVal263(true); } else { - b.setVal266(false); + b.setVal263(false); } - auto v267 = e.IsCXX11StandardLayout(); - if (v267) { - b.setVal267(static_cast(v267.value())); - b.setVal268(true); + auto v264 = e.IsAnyDestructorNoReturn(); + if (v264) { + b.setVal264(static_cast(v264.value())); + b.setVal265(true); } else { - b.setVal268(false); + b.setVal265(false); } - b.setVal269(e.IsCapturelessLambda()); - b.setVal270(e.IsDependentLambda()); - auto v271 = e.IsDynamicClass(); - if (v271) { - b.setVal271(static_cast(v271.value())); - b.setVal272(true); + auto v266 = e.IsCLike(); + if (v266) { + b.setVal266(static_cast(v266.value())); + b.setVal267(true); } else { - b.setVal272(false); + b.setVal267(false); } - auto v273 = e.IsEffectivelyFinal(); - if (v273) { - b.setVal273(static_cast(v273.value())); - b.setVal274(true); + auto v268 = e.IsCXX11StandardLayout(); + if (v268) { + b.setVal268(static_cast(v268.value())); + b.setVal269(true); } else { - b.setVal274(false); + b.setVal269(false); } - auto v275 = e.IsEmpty(); - if (v275) { - b.setVal275(static_cast(v275.value())); - b.setVal276(true); + b.setVal270(e.IsCapturelessLambda()); + b.setVal271(e.IsDependentLambda()); + auto v272 = e.IsDynamicClass(); + if (v272) { + b.setVal272(static_cast(v272.value())); + b.setVal273(true); } else { - b.setVal276(false); + b.setVal273(false); } - b.setVal277(e.IsGenericLambda()); - auto v278 = e.IsInterfaceLike(); - if (v278) { - b.setVal278(static_cast(v278.value())); - b.setVal279(true); + auto v274 = e.IsEffectivelyFinal(); + if (v274) { + b.setVal274(static_cast(v274.value())); + b.setVal275(true); } else { - b.setVal279(false); + b.setVal275(false); } - auto v280 = e.IsLiteral(); - if (v280) { - b.setVal280(static_cast(v280.value())); - b.setVal281(true); + auto v276 = e.IsEmpty(); + if (v276) { + b.setVal276(static_cast(v276.value())); + b.setVal277(true); } else { - b.setVal281(false); + b.setVal277(false); } - auto v152 = e.IsLocalClass(); - if (v152) { - auto id152 = es.EntityId(v152.value()); - b.setVal152(id152); + b.setVal278(e.IsGenericLambda()); + auto v279 = e.IsInterfaceLike(); + if (v279) { + b.setVal279(static_cast(v279.value())); + b.setVal280(true); + } else { + b.setVal280(false); + } + auto v281 = e.IsLiteral(); + if (v281) { + b.setVal281(static_cast(v281.value())); + b.setVal282(true); + } else { + b.setVal282(false); + } + auto v153 = e.IsLocalClass(); + if (v153) { + auto id153 = es.EntityId(v153.value()); + b.setVal153(id153); } else { - b.setVal152(mx::kInvalidEntityId); + b.setVal153(mx::kInvalidEntityId); } - b.setVal282(e.IsNeverDependentLambda()); - auto v283 = e.IsPOD(); - if (v283) { - b.setVal283(static_cast(v283.value())); - b.setVal284(true); + b.setVal283(e.IsNeverDependentLambda()); + auto v284 = e.IsPOD(); + if (v284) { + b.setVal284(static_cast(v284.value())); + b.setVal285(true); } else { - b.setVal284(false); + b.setVal285(false); } - auto v285 = e.IsPolymorphic(); - if (v285) { - b.setVal285(static_cast(v285.value())); - b.setVal286(true); + auto v286 = e.IsPolymorphic(); + if (v286) { + b.setVal286(static_cast(v286.value())); + b.setVal287(true); } else { - b.setVal286(false); + b.setVal287(false); } - auto v287 = e.IsStandardLayout(); - if (v287) { - b.setVal287(static_cast(v287.value())); - b.setVal288(true); + auto v288 = e.IsStandardLayout(); + if (v288) { + b.setVal288(static_cast(v288.value())); + b.setVal289(true); } else { - b.setVal288(false); + b.setVal289(false); } - auto v289 = e.IsStructural(); - if (v289) { - b.setVal289(static_cast(v289.value())); - b.setVal290(true); + auto v290 = e.IsStructural(); + if (v290) { + b.setVal290(static_cast(v290.value())); + b.setVal291(true); } else { - b.setVal290(false); + b.setVal291(false); } - auto v291 = e.IsTrivial(); - if (v291) { - b.setVal291(static_cast(v291.value())); - b.setVal292(true); + auto v292 = e.IsTrivial(); + if (v292) { + b.setVal292(static_cast(v292.value())); + b.setVal293(true); } else { - b.setVal292(false); + b.setVal293(false); } - auto v293 = e.IsTriviallyCopyConstructible(); - if (v293) { - b.setVal293(static_cast(v293.value())); - b.setVal294(true); + auto v294 = e.IsTriviallyCopyConstructible(); + if (v294) { + b.setVal294(static_cast(v294.value())); + b.setVal295(true); } else { - b.setVal294(false); + b.setVal295(false); } - auto v295 = e.IsTriviallyCopyable(); - if (v295) { - b.setVal295(static_cast(v295.value())); - b.setVal296(true); + auto v296 = e.IsTriviallyCopyable(); + if (v296) { + b.setVal296(static_cast(v296.value())); + b.setVal297(true); } else { - b.setVal296(false); + b.setVal297(false); } - auto v297 = e.LambdaIsDefaultConstructibleAndAssignable(); - if (v297) { - b.setVal297(static_cast(v297.value())); - b.setVal298(true); + auto v298 = e.LambdaIsDefaultConstructibleAndAssignable(); + if (v298) { + b.setVal298(static_cast(v298.value())); + b.setVal299(true); } else { - b.setVal298(false); + b.setVal299(false); } - auto v299 = e.MayBeAbstract(); - if (v299) { - b.setVal299(static_cast(v299.value())); - b.setVal300(true); + auto v300 = e.MayBeAbstract(); + if (v300) { + b.setVal300(static_cast(v300.value())); + b.setVal301(true); } else { - b.setVal300(false); + b.setVal301(false); } - auto v301 = e.MayBeDynamicClass(); - if (v301) { - b.setVal301(static_cast(v301.value())); - b.setVal302(true); + auto v302 = e.MayBeDynamicClass(); + if (v302) { + b.setVal302(static_cast(v302.value())); + b.setVal303(true); } else { - b.setVal302(false); + b.setVal303(false); } - auto v303 = e.MayBeNonDynamicClass(); - if (v303) { - b.setVal303(static_cast(v303.value())); - b.setVal304(true); + auto v304 = e.MayBeNonDynamicClass(); + if (v304) { + b.setVal304(static_cast(v304.value())); + b.setVal305(true); } else { - b.setVal304(false); + b.setVal305(false); } - auto v305 = e.NeedsImplicitCopyAssignment(); - if (v305) { - b.setVal305(static_cast(v305.value())); - b.setVal306(true); + auto v306 = e.NeedsImplicitCopyAssignment(); + if (v306) { + b.setVal306(static_cast(v306.value())); + b.setVal307(true); } else { - b.setVal306(false); + b.setVal307(false); } - auto v307 = e.NeedsImplicitCopyConstructor(); - if (v307) { - b.setVal307(static_cast(v307.value())); - b.setVal308(true); + auto v308 = e.NeedsImplicitCopyConstructor(); + if (v308) { + b.setVal308(static_cast(v308.value())); + b.setVal309(true); } else { - b.setVal308(false); + b.setVal309(false); } - auto v309 = e.NeedsImplicitDefaultConstructor(); - if (v309) { - b.setVal309(static_cast(v309.value())); - b.setVal310(true); + auto v310 = e.NeedsImplicitDefaultConstructor(); + if (v310) { + b.setVal310(static_cast(v310.value())); + b.setVal311(true); } else { - b.setVal310(false); + b.setVal311(false); } - auto v311 = e.NeedsImplicitDestructor(); - if (v311) { - b.setVal311(static_cast(v311.value())); - b.setVal312(true); + auto v312 = e.NeedsImplicitDestructor(); + if (v312) { + b.setVal312(static_cast(v312.value())); + b.setVal313(true); } else { - b.setVal312(false); + b.setVal313(false); } - auto v313 = e.NeedsImplicitMoveAssignment(); - if (v313) { - b.setVal313(static_cast(v313.value())); - b.setVal314(true); + auto v314 = e.NeedsImplicitMoveAssignment(); + if (v314) { + b.setVal314(static_cast(v314.value())); + b.setVal315(true); } else { - b.setVal314(false); + b.setVal315(false); } - auto v315 = e.NeedsImplicitMoveConstructor(); - if (v315) { - b.setVal315(static_cast(v315.value())); - b.setVal316(true); + auto v316 = e.NeedsImplicitMoveConstructor(); + if (v316) { + b.setVal316(static_cast(v316.value())); + b.setVal317(true); } else { - b.setVal316(false); + b.setVal317(false); } - auto v317 = e.NeedsOverloadResolutionForCopyAssignment(); - if (v317) { - b.setVal317(static_cast(v317.value())); - b.setVal318(true); + auto v318 = e.NeedsOverloadResolutionForCopyAssignment(); + if (v318) { + b.setVal318(static_cast(v318.value())); + b.setVal319(true); } else { - b.setVal318(false); + b.setVal319(false); } - auto v319 = e.NeedsOverloadResolutionForCopyConstructor(); - if (v319) { - b.setVal319(static_cast(v319.value())); - b.setVal320(true); + auto v320 = e.NeedsOverloadResolutionForCopyConstructor(); + if (v320) { + b.setVal320(static_cast(v320.value())); + b.setVal321(true); } else { - b.setVal320(false); + b.setVal321(false); } - auto v321 = e.NeedsOverloadResolutionForDestructor(); - if (v321) { - b.setVal321(static_cast(v321.value())); - b.setVal322(true); + auto v322 = e.NeedsOverloadResolutionForDestructor(); + if (v322) { + b.setVal322(static_cast(v322.value())); + b.setVal323(true); } else { - b.setVal322(false); + b.setVal323(false); } - auto v323 = e.NeedsOverloadResolutionForMoveAssignment(); - if (v323) { - b.setVal323(static_cast(v323.value())); - b.setVal324(true); + auto v324 = e.NeedsOverloadResolutionForMoveAssignment(); + if (v324) { + b.setVal324(static_cast(v324.value())); + b.setVal325(true); } else { - b.setVal324(false); + b.setVal325(false); } - auto v325 = e.NeedsOverloadResolutionForMoveConstructor(); - if (v325) { - b.setVal325(static_cast(v325.value())); - b.setVal326(true); + auto v326 = e.NeedsOverloadResolutionForMoveConstructor(); + if (v326) { + b.setVal326(static_cast(v326.value())); + b.setVal327(true); } else { - b.setVal326(false); + b.setVal327(false); } - auto v327 = e.NullFieldOffsetIsZero(); - if (v327) { - b.setVal327(static_cast(v327.value())); - b.setVal328(true); + auto v328 = e.NullFieldOffsetIsZero(); + if (v328) { + b.setVal328(static_cast(v328.value())); + b.setVal329(true); } else { - b.setVal328(false); + b.setVal329(false); } do { - auto ov329 = e.VirtualBases(); - if (!ov329) { - b.setVal330(false); + auto ov330 = e.VirtualBases(); + if (!ov330) { + b.setVal331(false); break; } - b.setVal330(true); - auto v329 = std::move(*ov329); - auto sv329 = b.initVal329(static_cast(v329.size())); - auto i329 = 0u; - for (const auto &e329 : v329) { - sv329.set(i329, es.EntityId(e329)); - ++i329; + b.setVal331(true); + auto v330 = std::move(*ov330); + auto sv330 = b.initVal330(static_cast(v330.size())); + auto i330 = 0u; + for (const auto &e330 : v330) { + sv330.set(i330, es.EntityId(e330)); + ++i330; } } while (false); - auto v154 = e.SizeWithoutVirtualBases(); - if (v154) { - b.setVal154(static_cast(v154.value())); - b.setVal331(true); + auto v155 = e.SizeWithoutVirtualBases(); + if (v155) { + b.setVal155(static_cast(v155.value())); + b.setVal332(true); } else { - b.setVal331(false); + b.setVal332(false); } - auto v155 = e.PrimaryBase(); - if (v155) { - auto id155 = es.EntityId(v155.value()); - b.setVal155(id155); + auto v156 = e.PrimaryBase(); + if (v156) { + auto id156 = es.EntityId(v156.value()); + b.setVal156(id156); } else { - b.setVal155(mx::kInvalidEntityId); + b.setVal156(mx::kInvalidEntityId); } - auto v332 = e.HasOwnVirtualFunctionTablePointer(); - if (v332) { - b.setVal332(static_cast(v332.value())); - b.setVal333(true); + auto v333 = e.HasOwnVirtualFunctionTablePointer(); + if (v333) { + b.setVal333(static_cast(v333.value())); + b.setVal334(true); } else { - b.setVal333(false); + b.setVal334(false); } - auto v334 = e.HasExtendableVirtualFunctionTablePointer(); - if (v334) { - b.setVal334(static_cast(v334.value())); - b.setVal335(true); + auto v335 = e.HasExtendableVirtualFunctionTablePointer(); + if (v335) { + b.setVal335(static_cast(v335.value())); + b.setVal336(true); } else { - b.setVal335(false); + b.setVal336(false); } - auto v336 = e.HasVirtualBaseTablePointer(); - if (v336) { - b.setVal336(static_cast(v336.value())); - b.setVal337(true); + auto v337 = e.HasVirtualBaseTablePointer(); + if (v337) { + b.setVal337(static_cast(v337.value())); + b.setVal338(true); } else { - b.setVal337(false); + b.setVal338(false); } - auto v338 = e.HasOwnVirtualBaseTablePointer(); - if (v338) { - b.setVal338(static_cast(v338.value())); - b.setVal339(true); + auto v339 = e.HasOwnVirtualBaseTablePointer(); + if (v339) { + b.setVal339(static_cast(v339.value())); + b.setVal340(true); } else { - b.setVal339(false); + b.setVal340(false); } } @@ -11204,24 +11206,24 @@ void SerializeClassTemplateSpecializationDecl(const PendingFragment &pf, const E (void) b; (void) e; SerializeCXXRecordDecl(pf, es, b, e, nullptr); - auto et157 = es.EntityId(e.ExternToken()); - b.setVal157(et157); - b.setVal118(static_cast(mx::FromPasta(e.SpecializationKind()))); - b.setVal170(es.EntityId(e.SpecializedTemplate())); + auto et158 = es.EntityId(e.ExternToken()); + b.setVal158(et158); + b.setVal119(static_cast(mx::FromPasta(e.SpecializationKind()))); + b.setVal171(es.EntityId(e.SpecializedTemplate())); do { - auto v340 = e.TemplateArguments(); - auto sv340 = b.initVal340(static_cast(v340.size())); - auto i340 = 0u; - for (const auto &e340 : v340) { - sv340.set(i340, es.EntityId(e340)); - ++i340; + auto v341 = e.TemplateArguments(); + auto sv341 = b.initVal341(static_cast(v341.size())); + auto i341 = 0u; + for (const auto &e341 : v341) { + sv341.set(i341, es.EntityId(e341)); + ++i341; } } while (false); - auto et171 = es.EntityId(e.TemplateKeywordToken()); - b.setVal171(et171); - b.setVal341(e.IsClassScopeExplicitSpecialization()); - b.setVal342(e.IsExplicitInstantiationOrSpecialization()); - b.setVal343(e.IsExplicitSpecialization()); + auto et172 = es.EntityId(e.TemplateKeywordToken()); + b.setVal172(et172); + b.setVal342(e.IsClassScopeExplicitSpecialization()); + b.setVal343(e.IsExplicitInstantiationOrSpecialization()); + b.setVal344(e.IsExplicitSpecialization()); } void SerializeClassTemplatePartialSpecializationDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ClassTemplatePartialSpecializationDecl &e, const TokenTree *) { @@ -11230,9 +11232,9 @@ void SerializeClassTemplatePartialSpecializationDecl(const PendingFragment &pf, (void) b; (void) e; SerializeClassTemplateSpecializationDecl(pf, es, b, e, nullptr); - b.setVal344(es.EntityId(e.InjectedSpecializationType())); - b.setVal345(es.EntityId(e.TemplateParameters())); - b.setVal346(e.HasAssociatedConstraints()); + b.setVal345(es.EntityId(e.InjectedSpecializationType())); + b.setVal346(es.EntityId(e.TemplateParameters())); + b.setVal347(e.HasAssociatedConstraints()); } void SerializeEnumDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::EnumDecl &e, const TokenTree *) { @@ -11242,38 +11244,38 @@ void SerializeEnumDecl(const PendingFragment &pf, const EntityMapper &es, mx::as (void) e; SerializeTagDecl(pf, es, b, e, nullptr); do { - auto v54 = e.Enumerators(); - auto sv54 = b.initVal54(static_cast(v54.size())); - auto i54 = 0u; - for (const auto &e54 : v54) { - sv54.set(i54, es.EntityId(e54)); - ++i54; + auto v55 = e.Enumerators(); + auto sv55 = b.initVal55(static_cast(v55.size())); + auto i55 = 0u; + for (const auto &e55 : v55) { + sv55.set(i55, es.EntityId(e55)); + ++i55; } } while (false); - auto v70 = e.IntegerType(); - if (v70) { - auto id70 = es.EntityId(v70.value()); - b.setVal70(id70); + auto v71 = e.IntegerType(); + if (v71) { + auto id71 = es.EntityId(v71.value()); + b.setVal71(id71); } else { - b.setVal70(mx::kInvalidEntityId); + b.setVal71(mx::kInvalidEntityId); } - auto p71 = es.EntityIds(e.IntegerTypeRange()); - b.setVal71(p71.first); - b.setVal73(p71.second); - auto v74 = e.PromotionType(); - if (v74) { - auto id74 = es.EntityId(v74.value()); - b.setVal74(id74); + auto p72 = es.EntityIds(e.IntegerTypeRange()); + b.setVal72(p72.first); + b.setVal74(p72.second); + auto v75 = e.PromotionType(); + if (v75) { + auto id75 = es.EntityId(v75.value()); + b.setVal75(id75); } else { - b.setVal74(mx::kInvalidEntityId); + b.setVal75(mx::kInvalidEntityId); } - b.setVal91(e.IsClosed()); - b.setVal92(e.IsClosedFlag()); - b.setVal93(e.IsClosedNonFlag()); - b.setVal94(e.IsComplete()); - b.setVal95(e.IsFixed()); - b.setVal96(e.IsScoped()); - b.setVal97(e.IsScopedUsingClassTag()); + b.setVal92(e.IsClosed()); + b.setVal93(e.IsClosedFlag()); + b.setVal94(e.IsClosedNonFlag()); + b.setVal95(e.IsComplete()); + b.setVal96(e.IsFixed()); + b.setVal97(e.IsScoped()); + b.setVal98(e.IsScopedUsingClassTag()); } void SerializeUnresolvedUsingTypenameDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::UnresolvedUsingTypenameDecl &e, const TokenTree *) { @@ -11282,13 +11284,13 @@ void SerializeUnresolvedUsingTypenameDecl(const PendingFragment &pf, const Entit (void) b; (void) e; SerializeTypeDecl(pf, es, b, e, nullptr); - auto et49 = es.EntityId(e.EllipsisToken()); - b.setVal49(et49); - auto et50 = es.EntityId(e.TypenameToken()); + auto et50 = es.EntityId(e.EllipsisToken()); b.setVal50(et50); - auto et58 = es.EntityId(e.UsingToken()); - b.setVal58(et58); - b.setVal66(e.IsPackExpansion()); + auto et51 = es.EntityId(e.TypenameToken()); + b.setVal51(et51); + auto et59 = es.EntityId(e.UsingToken()); + b.setVal59(et59); + b.setVal67(e.IsPackExpansion()); } void SerializeTypedefNameDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::TypedefNameDecl &e, const TokenTree *) { @@ -11297,16 +11299,16 @@ void SerializeTypedefNameDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeTypeDecl(pf, es, b, e, nullptr); - auto v49 = e.AnonymousDeclarationWithTypedefName(); - if (v49) { - auto id49 = es.EntityId(v49.value()); - b.setVal49(id49); + auto v50 = e.AnonymousDeclarationWithTypedefName(); + if (v50) { + auto id50 = es.EntityId(v50.value()); + b.setVal50(id50); } else { - b.setVal49(mx::kInvalidEntityId); + b.setVal50(mx::kInvalidEntityId); } - b.setVal50(es.EntityId(e.UnderlyingType())); - b.setVal66(e.IsModed()); - b.setVal67(e.IsTransparentTag()); + b.setVal51(es.EntityId(e.UnderlyingType())); + b.setVal67(e.IsModed()); + b.setVal68(e.IsTransparentTag()); } void SerializeTypedefDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::TypedefDecl &e, const TokenTree *) { @@ -11323,12 +11325,12 @@ void SerializeTypeAliasDecl(const PendingFragment &pf, const EntityMapper &es, m (void) b; (void) e; SerializeTypedefNameDecl(pf, es, b, e, nullptr); - auto v58 = e.DescribedAliasTemplate(); - if (v58) { - auto id58 = es.EntityId(v58.value()); - b.setVal58(id58); + auto v59 = e.DescribedAliasTemplate(); + if (v59) { + auto id59 = es.EntityId(v59.value()); + b.setVal59(id59); } else { - b.setVal58(mx::kInvalidEntityId); + b.setVal59(mx::kInvalidEntityId); } } @@ -11338,13 +11340,13 @@ void SerializeObjCTypeParamDecl(const PendingFragment &pf, const EntityMapper &e (void) b; (void) e; SerializeTypedefNameDecl(pf, es, b, e, nullptr); - auto et58 = es.EntityId(e.ColonToken()); - b.setVal58(et58); - b.setVal41(e.Index()); - b.setVal72(static_cast(mx::FromPasta(e.Variance()))); - auto et59 = es.EntityId(e.VarianceToken()); + auto et59 = es.EntityId(e.ColonToken()); b.setVal59(et59); - b.setVal68(e.HasExplicitBound()); + b.setVal42(e.Index()); + b.setVal73(static_cast(mx::FromPasta(e.Variance()))); + auto et60 = es.EntityId(e.VarianceToken()); + b.setVal60(et60); + b.setVal69(e.HasExplicitBound()); } void SerializeTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::TemplateDecl &e, const TokenTree *) { @@ -11353,16 +11355,16 @@ void SerializeTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - b.setVal48(es.EntityId(e.TemplateParameters())); - auto v49 = e.TemplatedDeclaration(); - if (v49) { - auto id49 = es.EntityId(v49.value()); - b.setVal49(id49); + b.setVal49(es.EntityId(e.TemplateParameters())); + auto v50 = e.TemplatedDeclaration(); + if (v50) { + auto id50 = es.EntityId(v50.value()); + b.setVal50(id50); } else { - b.setVal49(mx::kInvalidEntityId); + b.setVal50(mx::kInvalidEntityId); } - b.setVal66(e.HasAssociatedConstraints()); - b.setVal67(e.IsTypeAlias()); + b.setVal67(e.HasAssociatedConstraints()); + b.setVal68(e.IsTypeAlias()); } void SerializeRedeclarableTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::RedeclarableTemplateDecl &e, const TokenTree *) { @@ -11371,7 +11373,7 @@ void SerializeRedeclarableTemplateDecl(const PendingFragment &pf, const EntityMa (void) b; (void) e; SerializeTemplateDecl(pf, es, b, e, nullptr); - b.setVal68(e.IsMemberSpecialization()); + b.setVal69(e.IsMemberSpecialization()); } void SerializeFunctionTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::FunctionTemplateDecl &e, const TokenTree *) { @@ -11380,8 +11382,8 @@ void SerializeFunctionTemplateDecl(const PendingFragment &pf, const EntityMapper (void) b; (void) e; SerializeRedeclarableTemplateDecl(pf, es, b, e, nullptr); - b.setVal69(e.IsAbbreviated()); - b.setVal81(e.IsThisDeclarationADefinition()); + b.setVal70(e.IsAbbreviated()); + b.setVal82(e.IsThisDeclarationADefinition()); } void SerializeClassTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ClassTemplateDecl &e, const TokenTree *) { @@ -11390,7 +11392,7 @@ void SerializeClassTemplateDecl(const PendingFragment &pf, const EntityMapper &e (void) b; (void) e; SerializeRedeclarableTemplateDecl(pf, es, b, e, nullptr); - b.setVal69(e.IsThisDeclarationADefinition()); + b.setVal70(e.IsThisDeclarationADefinition()); } void SerializeVarTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::VarTemplateDecl &e, const TokenTree *) { @@ -11399,7 +11401,7 @@ void SerializeVarTemplateDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeRedeclarableTemplateDecl(pf, es, b, e, nullptr); - b.setVal69(e.IsThisDeclarationADefinition()); + b.setVal70(e.IsThisDeclarationADefinition()); } void SerializeTypeAliasTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::TypeAliasTemplateDecl &e, const TokenTree *) { @@ -11416,8 +11418,8 @@ void SerializeConceptDecl(const PendingFragment &pf, const EntityMapper &es, mx: (void) b; (void) e; SerializeTemplateDecl(pf, es, b, e, nullptr); - b.setVal50(es.EntityId(e.ConstraintExpression())); - b.setVal68(e.IsTypeConcept()); + b.setVal51(es.EntityId(e.ConstraintExpression())); + b.setVal69(e.IsTypeConcept()); } void SerializeBuiltinTemplateDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::BuiltinTemplateDecl &e, const TokenTree *) { @@ -11434,12 +11436,12 @@ void SerializeTemplateTemplateParmDecl(const PendingFragment &pf, const EntityMa (void) b; (void) e; SerializeTemplateDecl(pf, es, b, e, nullptr); - b.setVal68(e.DefaultArgumentWasInherited()); - auto et50 = es.EntityId(e.DefaultArgumentToken()); - b.setVal50(et50); - b.setVal69(e.HasDefaultArgument()); - b.setVal81(e.IsExpandedParameterPack()); - b.setVal82(e.IsPackExpansion()); + b.setVal69(e.DefaultArgumentWasInherited()); + auto et51 = es.EntityId(e.DefaultArgumentToken()); + b.setVal51(et51); + b.setVal70(e.HasDefaultArgument()); + b.setVal82(e.IsExpandedParameterPack()); + b.setVal83(e.IsPackExpansion()); } void SerializeObjCPropertyDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ObjCPropertyDecl &e, const TokenTree *) { @@ -11448,28 +11450,28 @@ void SerializeObjCPropertyDecl(const PendingFragment &pf, const EntityMapper &es (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto et48 = es.EntityId(e.AtToken()); - b.setVal48(et48); - b.setVal49(es.EntityId(e.GetterMethodDeclaration())); - auto et50 = es.EntityId(e.GetterNameToken()); - b.setVal50(et50); - auto et58 = es.EntityId(e.LParenToken()); - b.setVal58(et58); - b.setVal72(static_cast(mx::FromPasta(e.PropertyImplementation()))); - b.setVal59(es.EntityId(e.PropertyInstanceVariableDeclaration())); - b.setVal76(static_cast(mx::FromPasta(e.QueryKind()))); - b.setVal77(static_cast(mx::FromPasta(e.SetterKind()))); - b.setVal60(es.EntityId(e.SetterMethodDeclaration())); - auto et70 = es.EntityId(e.SetterNameToken()); - b.setVal70(et70); - b.setVal71(es.EntityId(e.Type())); - b.setVal66(e.IsAtomic()); - b.setVal67(e.IsClassProperty()); - b.setVal68(e.IsDirectProperty()); - b.setVal69(e.IsInstanceProperty()); - b.setVal81(e.IsOptional()); - b.setVal82(e.IsReadOnly()); - b.setVal83(e.IsRetaining()); + auto et49 = es.EntityId(e.AtToken()); + b.setVal49(et49); + b.setVal50(es.EntityId(e.GetterMethodDeclaration())); + auto et51 = es.EntityId(e.GetterNameToken()); + b.setVal51(et51); + auto et59 = es.EntityId(e.LParenToken()); + b.setVal59(et59); + b.setVal73(static_cast(mx::FromPasta(e.PropertyImplementation()))); + b.setVal60(es.EntityId(e.PropertyInstanceVariableDeclaration())); + b.setVal77(static_cast(mx::FromPasta(e.QueryKind()))); + b.setVal78(static_cast(mx::FromPasta(e.SetterKind()))); + b.setVal61(es.EntityId(e.SetterMethodDeclaration())); + auto et71 = es.EntityId(e.SetterNameToken()); + b.setVal71(et71); + b.setVal72(es.EntityId(e.Type())); + b.setVal67(e.IsAtomic()); + b.setVal68(e.IsClassProperty()); + b.setVal69(e.IsDirectProperty()); + b.setVal70(e.IsInstanceProperty()); + b.setVal82(e.IsOptional()); + b.setVal83(e.IsReadOnly()); + b.setVal84(e.IsRetaining()); } void SerializeObjCMethodDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ObjCMethodDecl &e, const TokenTree *) { @@ -11478,50 +11480,41 @@ void SerializeObjCMethodDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - b.setVal66(e.DefinedInNSObject()); - b.setVal48(es.EntityId(e.FindPropertyDeclaration())); - b.setVal49(es.EntityId(e.ClassInterface())); - b.setVal50(es.EntityId(e.CommandDeclaration())); - auto et58 = es.EntityId(e.DeclaratorEndToken()); - b.setVal58(et58); - b.setVal72(static_cast(mx::FromPasta(e.ImplementationControl()))); - b.setVal76(static_cast(mx::FromPasta(e.MethodFamily()))); - b.setVal77(static_cast(mx::FromPasta(e.ObjCDeclQualifier()))); - b.setVal59(es.EntityId(e.ReturnType())); - auto p60 = es.EntityIds(e.ReturnTypeTokens()); - b.setVal60(p60.first); - b.setVal70(p60.second); - auto et71 = es.EntityId(e.SelectorStartToken()); - b.setVal71(et71); - b.setVal73(es.EntityId(e.SelfDeclaration())); - b.setVal67(e.HasParameterDestroyedInCallee()); - b.setVal68(e.HasRedeclaration()); - b.setVal69(e.HasRelatedResultType()); - b.setVal81(e.HasSkippedBody()); - b.setVal82(e.IsClassMethod()); - b.setVal83(e.IsDefined()); - b.setVal84(e.IsDesignatedInitializerForTheInterface()); - b.setVal85(e.IsDirectMethod()); - b.setVal86(e.IsInstanceMethod()); - b.setVal87(e.IsOptional()); - b.setVal88(e.IsOverriding()); - b.setVal89(e.IsPropertyAccessor()); - b.setVal90(e.IsRedeclaration()); - b.setVal91(e.IsSynthesizedAccessorStub()); - b.setVal92(e.IsThisDeclarationADefinition()); - b.setVal93(e.IsThisDeclarationADesignatedInitializer()); - b.setVal94(e.IsVariadic()); - do { - auto v43 = e.Parameters(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; - } - } while (false); + b.setVal67(e.DefinedInNSObject()); + b.setVal49(es.EntityId(e.FindPropertyDeclaration())); + b.setVal50(es.EntityId(e.ClassInterface())); + b.setVal51(es.EntityId(e.CommandDeclaration())); + auto et59 = es.EntityId(e.DeclaratorEndToken()); + b.setVal59(et59); + b.setVal73(static_cast(mx::FromPasta(e.ImplementationControl()))); + b.setVal77(static_cast(mx::FromPasta(e.MethodFamily()))); + b.setVal78(static_cast(mx::FromPasta(e.ObjCDeclQualifier()))); + b.setVal60(es.EntityId(e.ReturnType())); + auto p61 = es.EntityIds(e.ReturnTypeTokens()); + b.setVal61(p61.first); + b.setVal71(p61.second); + auto et72 = es.EntityId(e.SelectorStartToken()); + b.setVal72(et72); + b.setVal74(es.EntityId(e.SelfDeclaration())); + b.setVal68(e.HasParameterDestroyedInCallee()); + b.setVal69(e.HasRedeclaration()); + b.setVal70(e.HasRelatedResultType()); + b.setVal82(e.HasSkippedBody()); + b.setVal83(e.IsClassMethod()); + b.setVal84(e.IsDefined()); + b.setVal85(e.IsDesignatedInitializerForTheInterface()); + b.setVal86(e.IsDirectMethod()); + b.setVal87(e.IsInstanceMethod()); + b.setVal88(e.IsOptional()); + b.setVal89(e.IsOverriding()); + b.setVal90(e.IsPropertyAccessor()); + b.setVal91(e.IsRedeclaration()); + b.setVal92(e.IsSynthesizedAccessorStub()); + b.setVal93(e.IsThisDeclarationADefinition()); + b.setVal94(e.IsThisDeclarationADesignatedInitializer()); + b.setVal95(e.IsVariadic()); do { - auto v44 = e.SelectorTokens(); + auto v44 = e.Parameters(); auto sv44 = b.initVal44(static_cast(v44.size())); auto i44 = 0u; for (const auto &e44 : v44) { @@ -11529,6 +11522,15 @@ void SerializeObjCMethodDecl(const PendingFragment &pf, const EntityMapper &es, ++i44; } } while (false); + do { + auto v45 = e.SelectorTokens(); + auto sv45 = b.initVal45(static_cast(v45.size())); + auto i45 = 0u; + for (const auto &e45 : v45) { + sv45.set(i45, es.EntityId(e45)); + ++i45; + } + } while (false); } void SerializeObjCContainerDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ObjCContainerDecl &e, const TokenTree *) { @@ -11538,16 +11540,7 @@ void SerializeObjCContainerDecl(const PendingFragment &pf, const EntityMapper &e (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); do { - auto v43 = e.ClassMethods(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; - } - } while (false); - do { - auto v44 = e.ClassProperties(); + auto v44 = e.ClassMethods(); auto sv44 = b.initVal44(static_cast(v44.size())); auto i44 = 0u; for (const auto &e44 : v44) { @@ -11555,45 +11548,54 @@ void SerializeObjCContainerDecl(const PendingFragment &pf, const EntityMapper &e ++i44; } } while (false); - auto p48 = es.EntityIds(e.AtEndRange()); - b.setVal48(p48.first); - b.setVal49(p48.second); - auto et50 = es.EntityId(e.AtStartToken()); - b.setVal50(et50); do { - auto v54 = e.InstanceMethods(); - auto sv54 = b.initVal54(static_cast(v54.size())); - auto i54 = 0u; - for (const auto &e54 : v54) { - sv54.set(i54, es.EntityId(e54)); - ++i54; + auto v45 = e.ClassProperties(); + auto sv45 = b.initVal45(static_cast(v45.size())); + auto i45 = 0u; + for (const auto &e45 : v45) { + sv45.set(i45, es.EntityId(e45)); + ++i45; + } + } while (false); + auto p49 = es.EntityIds(e.AtEndRange()); + b.setVal49(p49.first); + b.setVal50(p49.second); + auto et51 = es.EntityId(e.AtStartToken()); + b.setVal51(et51); + do { + auto v55 = e.InstanceMethods(); + auto sv55 = b.initVal55(static_cast(v55.size())); + auto i55 = 0u; + for (const auto &e55 : v55) { + sv55.set(i55, es.EntityId(e55)); + ++i55; } } while (false); do { - auto v153 = e.InstanceProperties(); - auto sv153 = b.initVal153(static_cast(v153.size())); - auto i153 = 0u; - for (const auto &e153 : v153) { - sv153.set(i153, es.EntityId(e153)); - ++i153; + auto v154 = e.InstanceProperties(); + auto sv154 = b.initVal154(static_cast(v154.size())); + auto i154 = 0u; + for (const auto &e154 : v154) { + sv154.set(i154, es.EntityId(e154)); + ++i154; } } while (false); do { - auto v168 = e.Methods(); - auto sv168 = b.initVal168(static_cast(v168.size())); - auto i168 = 0u; - for (const auto &e168 : v168) { - sv168.set(i168, es.EntityId(e168)); - ++i168; + auto v169 = e.Methods(); + auto sv169 = b.initVal169(static_cast(v169.size())); + auto i169 = 0u; + for (const auto &e169 : v169) { + sv169.set(i169, es.EntityId(e169)); + ++i169; } } while (false); do { - auto v174 = e.Properties(); - auto sv174 = b.initVal174(static_cast(v174.size())); - auto i174 = 0u; - for (const auto &e174 : v174) { - sv174.set(i174, es.EntityId(e174)); - ++i174; + auto v175 = e.Properties(); + auto sv175 = b.initVal175(static_cast(v175.size())); + auto i175 = 0u; + for (const auto &e175 : v175) { + sv175.set(i175, es.EntityId(e175)); + ++i175; } } while (false); } @@ -11604,41 +11606,41 @@ void SerializeObjCCategoryDecl(const PendingFragment &pf, const EntityMapper &es (void) b; (void) e; SerializeObjCContainerDecl(pf, es, b, e, nullptr); - b.setVal66(e.IsClassExtension()); - auto et58 = es.EntityId(e.CategoryNameToken()); - b.setVal58(et58); - b.setVal59(es.EntityId(e.ClassInterface())); - b.setVal60(es.EntityId(e.Implementation())); - auto et70 = es.EntityId(e.InstanceVariableLBraceToken()); - b.setVal70(et70); - auto et71 = es.EntityId(e.InstanceVariableRBraceToken()); + b.setVal67(e.IsClassExtension()); + auto et59 = es.EntityId(e.CategoryNameToken()); + b.setVal59(et59); + b.setVal60(es.EntityId(e.ClassInterface())); + b.setVal61(es.EntityId(e.Implementation())); + auto et71 = es.EntityId(e.InstanceVariableLBraceToken()); b.setVal71(et71); - b.setVal73(es.EntityId(e.NextClassCategory())); + auto et72 = es.EntityId(e.InstanceVariableRBraceToken()); + b.setVal72(et72); + b.setVal74(es.EntityId(e.NextClassCategory())); do { - auto v329 = e.InstanceVariables(); - auto sv329 = b.initVal329(static_cast(v329.size())); - auto i329 = 0u; - for (const auto &e329 : v329) { - sv329.set(i329, es.EntityId(e329)); - ++i329; + auto v330 = e.InstanceVariables(); + auto sv330 = b.initVal330(static_cast(v330.size())); + auto i330 = 0u; + for (const auto &e330 : v330) { + sv330.set(i330, es.EntityId(e330)); + ++i330; } } while (false); do { - auto v340 = e.ProtocolTokens(); - auto sv340 = b.initVal340(static_cast(v340.size())); - auto i340 = 0u; - for (const auto &e340 : v340) { - sv340.set(i340, es.EntityId(e340)); - ++i340; + auto v341 = e.ProtocolTokens(); + auto sv341 = b.initVal341(static_cast(v341.size())); + auto i341 = 0u; + for (const auto &e341 : v341) { + sv341.set(i341, es.EntityId(e341)); + ++i341; } } while (false); do { - auto v347 = e.Protocols(); - auto sv347 = b.initVal347(static_cast(v347.size())); - auto i347 = 0u; - for (const auto &e347 : v347) { - sv347.set(i347, es.EntityId(e347)); - ++i347; + auto v348 = e.Protocols(); + auto sv348 = b.initVal348(static_cast(v348.size())); + auto i348 = 0u; + for (const auto &e348 : v348) { + sv348.set(i348, es.EntityId(e348)); + ++i348; } } while (false); } @@ -11649,28 +11651,28 @@ void SerializeObjCProtocolDecl(const PendingFragment &pf, const EntityMapper &es (void) b; (void) e; SerializeObjCContainerDecl(pf, es, b, e, nullptr); - auto v56 = e.ObjCRuntimeNameAsString(); - std::string s56(v56.data(), v56.size()); - b.setVal56(s56); - b.setVal66(e.HasDefinition()); - b.setVal67(e.IsNonRuntimeProtocol()); - b.setVal68(e.IsThisDeclarationADefinition()); + auto v57 = e.ObjCRuntimeNameAsString(); + std::string s57(v57.data(), v57.size()); + b.setVal57(s57); + b.setVal67(e.HasDefinition()); + b.setVal68(e.IsNonRuntimeProtocol()); + b.setVal69(e.IsThisDeclarationADefinition()); do { - auto v329 = e.ProtocolTokens(); - auto sv329 = b.initVal329(static_cast(v329.size())); - auto i329 = 0u; - for (const auto &e329 : v329) { - sv329.set(i329, es.EntityId(e329)); - ++i329; + auto v330 = e.ProtocolTokens(); + auto sv330 = b.initVal330(static_cast(v330.size())); + auto i330 = 0u; + for (const auto &e330 : v330) { + sv330.set(i330, es.EntityId(e330)); + ++i330; } } while (false); do { - auto v340 = e.Protocols(); - auto sv340 = b.initVal340(static_cast(v340.size())); - auto i340 = 0u; - for (const auto &e340 : v340) { - sv340.set(i340, es.EntityId(e340)); - ++i340; + auto v341 = e.Protocols(); + auto sv341 = b.initVal341(static_cast(v341.size())); + auto i341 = 0u; + for (const auto &e341 : v341) { + sv341.set(i341, es.EntityId(e341)); + ++i341; } } while (false); } @@ -11682,64 +11684,55 @@ void SerializeObjCInterfaceDecl(const PendingFragment &pf, const EntityMapper &e (void) e; SerializeObjCContainerDecl(pf, es, b, e, nullptr); do { - auto v329 = e.AllReferencedProtocols(); - auto sv329 = b.initVal329(static_cast(v329.size())); - auto i329 = 0u; - for (const auto &e329 : v329) { - sv329.set(i329, es.EntityId(e329)); - ++i329; + auto v330 = e.AllReferencedProtocols(); + auto sv330 = b.initVal330(static_cast(v330.size())); + auto i330 = 0u; + for (const auto &e330 : v330) { + sv330.set(i330, es.EntityId(e330)); + ++i330; } } while (false); - b.setVal66(e.DeclaresOrInheritsDesignatedInitializers()); - auto et58 = es.EntityId(e.EndOfDefinitionToken()); - b.setVal58(et58); - b.setVal59(es.EntityId(e.Implementation())); - auto v56 = e.ObjCRuntimeNameAsString(); - std::string s56(v56.data(), v56.size()); - b.setVal56(s56); - auto v60 = e.SuperClass(); - if (v60) { - auto id60 = es.EntityId(v60.value()); - b.setVal60(id60); - } else { - b.setVal60(mx::kInvalidEntityId); - } - auto et70 = es.EntityId(e.SuperClassToken()); - b.setVal70(et70); - auto v71 = e.SuperClassTypeInfo(); - if (v71) { - auto id71 = es.EntityId(v71.value()); - b.setVal71(id71); + b.setVal67(e.DeclaresOrInheritsDesignatedInitializers()); + auto et59 = es.EntityId(e.EndOfDefinitionToken()); + b.setVal59(et59); + b.setVal60(es.EntityId(e.Implementation())); + auto v57 = e.ObjCRuntimeNameAsString(); + std::string s57(v57.data(), v57.size()); + b.setVal57(s57); + auto v61 = e.SuperClass(); + if (v61) { + auto id61 = es.EntityId(v61.value()); + b.setVal61(id61); } else { - b.setVal71(mx::kInvalidEntityId); + b.setVal61(mx::kInvalidEntityId); } - b.setVal73(es.EntityId(e.TypeForDeclaration())); - b.setVal67(e.HasDefinition()); - b.setVal68(e.HasDesignatedInitializers()); - b.setVal69(e.IsArcWeakrefUnavailable()); - b.setVal81(e.IsImplicitInterfaceDeclaration()); - b.setVal74(es.EntityId(e.IsObjCRequiresPropertyDefinitions())); - b.setVal82(e.IsThisDeclarationADefinition()); - do { - auto v340 = e.InstanceVariables(); - auto sv340 = b.initVal340(static_cast(v340.size())); - auto i340 = 0u; - for (const auto &e340 : v340) { - sv340.set(i340, es.EntityId(e340)); - ++i340; - } - } while (false); + auto et71 = es.EntityId(e.SuperClassToken()); + b.setVal71(et71); + auto v72 = e.SuperClassTypeInfo(); + if (v72) { + auto id72 = es.EntityId(v72.value()); + b.setVal72(id72); + } else { + b.setVal72(mx::kInvalidEntityId); + } + b.setVal74(es.EntityId(e.TypeForDeclaration())); + b.setVal68(e.HasDefinition()); + b.setVal69(e.HasDesignatedInitializers()); + b.setVal70(e.IsArcWeakrefUnavailable()); + b.setVal82(e.IsImplicitInterfaceDeclaration()); + b.setVal75(es.EntityId(e.IsObjCRequiresPropertyDefinitions())); + b.setVal83(e.IsThisDeclarationADefinition()); do { - auto v347 = e.KnownCategories(); - auto sv347 = b.initVal347(static_cast(v347.size())); - auto i347 = 0u; - for (const auto &e347 : v347) { - sv347.set(i347, es.EntityId(e347)); - ++i347; + auto v341 = e.InstanceVariables(); + auto sv341 = b.initVal341(static_cast(v341.size())); + auto i341 = 0u; + for (const auto &e341 : v341) { + sv341.set(i341, es.EntityId(e341)); + ++i341; } } while (false); do { - auto v348 = e.KnownExtensions(); + auto v348 = e.KnownCategories(); auto sv348 = b.initVal348(static_cast(v348.size())); auto i348 = 0u; for (const auto &e348 : v348) { @@ -11748,7 +11741,7 @@ void SerializeObjCInterfaceDecl(const PendingFragment &pf, const EntityMapper &e } } while (false); do { - auto v349 = e.ProtocolTokens(); + auto v349 = e.KnownExtensions(); auto sv349 = b.initVal349(static_cast(v349.size())); auto i349 = 0u; for (const auto &e349 : v349) { @@ -11757,7 +11750,7 @@ void SerializeObjCInterfaceDecl(const PendingFragment &pf, const EntityMapper &e } } while (false); do { - auto v350 = e.Protocols(); + auto v350 = e.ProtocolTokens(); auto sv350 = b.initVal350(static_cast(v350.size())); auto i350 = 0u; for (const auto &e350 : v350) { @@ -11766,7 +11759,7 @@ void SerializeObjCInterfaceDecl(const PendingFragment &pf, const EntityMapper &e } } while (false); do { - auto v351 = e.VisibleCategories(); + auto v351 = e.Protocols(); auto sv351 = b.initVal351(static_cast(v351.size())); auto i351 = 0u; for (const auto &e351 : v351) { @@ -11775,7 +11768,7 @@ void SerializeObjCInterfaceDecl(const PendingFragment &pf, const EntityMapper &e } } while (false); do { - auto v352 = e.VisibleExtensions(); + auto v352 = e.VisibleCategories(); auto sv352 = b.initVal352(static_cast(v352.size())); auto i352 = 0u; for (const auto &e352 : v352) { @@ -11783,6 +11776,15 @@ void SerializeObjCInterfaceDecl(const PendingFragment &pf, const EntityMapper &e ++i352; } } while (false); + do { + auto v353 = e.VisibleExtensions(); + auto sv353 = b.initVal353(static_cast(v353.size())); + auto i353 = 0u; + for (const auto &e353 : v353) { + sv353.set(i353, es.EntityId(e353)); + ++i353; + } + } while (false); } void SerializeObjCImplDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ObjCImplDecl &e, const TokenTree *) { @@ -11791,14 +11793,14 @@ void SerializeObjCImplDecl(const PendingFragment &pf, const EntityMapper &es, mx (void) b; (void) e; SerializeObjCContainerDecl(pf, es, b, e, nullptr); - b.setVal58(es.EntityId(e.ClassInterface())); + b.setVal59(es.EntityId(e.ClassInterface())); do { - auto v329 = e.PropertyImplementations(); - auto sv329 = b.initVal329(static_cast(v329.size())); - auto i329 = 0u; - for (const auto &e329 : v329) { - sv329.set(i329, es.EntityId(e329)); - ++i329; + auto v330 = e.PropertyImplementations(); + auto sv330 = b.initVal330(static_cast(v330.size())); + auto i330 = 0u; + for (const auto &e330 : v330) { + sv330.set(i330, es.EntityId(e330)); + ++i330; } } while (false); } @@ -11809,9 +11811,9 @@ void SerializeObjCCategoryImplDecl(const PendingFragment &pf, const EntityMapper (void) b; (void) e; SerializeObjCImplDecl(pf, es, b, e, nullptr); - b.setVal59(es.EntityId(e.CategoryDeclaration())); - auto et60 = es.EntityId(e.CategoryNameToken()); - b.setVal60(et60); + b.setVal60(es.EntityId(e.CategoryDeclaration())); + auto et61 = es.EntityId(e.CategoryNameToken()); + b.setVal61(et61); } void SerializeObjCImplementationDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ObjCImplementationDecl &e, const TokenTree *) { @@ -11820,34 +11822,34 @@ void SerializeObjCImplementationDecl(const PendingFragment &pf, const EntityMapp (void) b; (void) e; SerializeObjCImplDecl(pf, es, b, e, nullptr); - auto et59 = es.EntityId(e.InstanceVariableLBraceToken()); - b.setVal59(et59); - auto et60 = es.EntityId(e.InstanceVariableRBraceToken()); + auto et60 = es.EntityId(e.InstanceVariableLBraceToken()); b.setVal60(et60); - auto v56 = e.ObjCRuntimeNameAsString(); - std::string s56(v56.data(), v56.size()); - b.setVal56(s56); - b.setVal70(es.EntityId(e.SuperClass())); - auto et71 = es.EntityId(e.SuperClassToken()); - b.setVal71(et71); - b.setVal66(e.HasDestructors()); - b.setVal67(e.HasNonZeroConstructors()); + auto et61 = es.EntityId(e.InstanceVariableRBraceToken()); + b.setVal61(et61); + auto v57 = e.ObjCRuntimeNameAsString(); + std::string s57(v57.data(), v57.size()); + b.setVal57(s57); + b.setVal71(es.EntityId(e.SuperClass())); + auto et72 = es.EntityId(e.SuperClassToken()); + b.setVal72(et72); + b.setVal67(e.HasDestructors()); + b.setVal68(e.HasNonZeroConstructors()); do { - auto v340 = e.Initializers(); - auto sv340 = b.initVal340(static_cast(v340.size())); - auto i340 = 0u; - for (const auto &e340 : v340) { - sv340.set(i340, es.EntityId(e340)); - ++i340; + auto v341 = e.Initializers(); + auto sv341 = b.initVal341(static_cast(v341.size())); + auto i341 = 0u; + for (const auto &e341 : v341) { + sv341.set(i341, es.EntityId(e341)); + ++i341; } } while (false); do { - auto v347 = e.InstanceVariables(); - auto sv347 = b.initVal347(static_cast(v347.size())); - auto i347 = 0u; - for (const auto &e347 : v347) { - sv347.set(i347, es.EntityId(e347)); - ++i347; + auto v348 = e.InstanceVariables(); + auto sv348 = b.initVal348(static_cast(v348.size())); + auto i348 = 0u; + for (const auto &e348 : v348) { + sv348.set(i348, es.EntityId(e348)); + ++i348; } } while (false); } @@ -11858,7 +11860,7 @@ void SerializeObjCCompatibleAliasDecl(const PendingFragment &pf, const EntityMap (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - b.setVal48(es.EntityId(e.ClassInterface())); + b.setVal49(es.EntityId(e.ClassInterface())); } void SerializeNamespaceDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::NamespaceDecl &e, const TokenTree *) { @@ -11867,11 +11869,11 @@ void SerializeNamespaceDecl(const PendingFragment &pf, const EntityMapper &es, m (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto et48 = es.EntityId(e.RBraceToken()); - b.setVal48(et48); - b.setVal66(e.IsAnonymousNamespace()); - b.setVal67(e.IsInline()); - b.setVal68(e.IsNested()); + auto et49 = es.EntityId(e.RBraceToken()); + b.setVal49(et49); + b.setVal67(e.IsAnonymousNamespace()); + b.setVal68(e.IsInline()); + b.setVal69(e.IsNested()); } void SerializeNamespaceAliasDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::NamespaceAliasDecl &e, const TokenTree *) { @@ -11880,14 +11882,14 @@ void SerializeNamespaceAliasDecl(const PendingFragment &pf, const EntityMapper & (void) b; (void) e; SerializeNamedDecl(pf, es, b, e, nullptr); - auto et48 = es.EntityId(e.AliasToken()); - b.setVal48(et48); - b.setVal49(es.EntityId(e.AliasedNamespace())); - b.setVal50(es.EntityId(e.Namespace())); - auto et58 = es.EntityId(e.NamespaceToken()); - b.setVal58(et58); - auto et59 = es.EntityId(e.TargetNameToken()); + auto et49 = es.EntityId(e.AliasToken()); + b.setVal49(et49); + b.setVal50(es.EntityId(e.AliasedNamespace())); + b.setVal51(es.EntityId(e.Namespace())); + auto et59 = es.EntityId(e.NamespaceToken()); b.setVal59(et59); + auto et60 = es.EntityId(e.TargetNameToken()); + b.setVal60(et60); } void SerializeLinkageSpecDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::LinkageSpecDecl &e, const TokenTree *) { @@ -11896,12 +11898,12 @@ void SerializeLinkageSpecDecl(const PendingFragment &pf, const EntityMapper &es, (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - auto et40 = es.EntityId(e.ExternToken()); - b.setVal40(et40); - b.setVal57(static_cast(mx::FromPasta(e.Language()))); - auto et48 = es.EntityId(e.RBraceToken()); - b.setVal48(et48); - b.setVal42(e.HasBraces()); + auto et41 = es.EntityId(e.ExternToken()); + b.setVal41(et41); + b.setVal58(static_cast(mx::FromPasta(e.Language()))); + auto et49 = es.EntityId(e.RBraceToken()); + b.setVal49(et49); + b.setVal43(e.HasBraces()); } void SerializeLifetimeExtendedTemporaryDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::LifetimeExtendedTemporaryDecl &e, const TokenTree *) { @@ -11911,18 +11913,18 @@ void SerializeLifetimeExtendedTemporaryDecl(const PendingFragment &pf, const Ent (void) e; SerializeDecl(pf, es, b, e, nullptr); do { - auto v43 = e.Children(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.Children(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); - b.setVal40(es.EntityId(e.ExtendingDeclaration())); - b.setVal41(e.ManglingNumber()); - b.setVal57(static_cast(mx::FromPasta(e.StorageDuration()))); - b.setVal48(es.EntityId(e.TemporaryExpression())); + b.setVal41(es.EntityId(e.ExtendingDeclaration())); + b.setVal42(e.ManglingNumber()); + b.setVal58(static_cast(mx::FromPasta(e.StorageDuration()))); + b.setVal49(es.EntityId(e.TemporaryExpression())); } void SerializeImportDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ImportDecl &e, const TokenTree *) { @@ -11932,12 +11934,12 @@ void SerializeImportDecl(const PendingFragment &pf, const EntityMapper &es, mx:: (void) e; SerializeDecl(pf, es, b, e, nullptr); do { - auto v43 = e.IdentifierTokens(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.IdentifierTokens(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -11949,12 +11951,12 @@ void SerializeImplicitConceptSpecializationDecl(const PendingFragment &pf, const (void) e; SerializeDecl(pf, es, b, e, nullptr); do { - auto v43 = e.TemplateArguments(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.TemplateArguments(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -11965,17 +11967,17 @@ void SerializeFriendTemplateDecl(const PendingFragment &pf, const EntityMapper & (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - b.setVal40(es.EntityId(e.FriendDeclaration())); - auto et48 = es.EntityId(e.FriendToken()); - b.setVal48(et48); - b.setVal49(es.EntityId(e.FriendType())); + b.setVal41(es.EntityId(e.FriendDeclaration())); + auto et49 = es.EntityId(e.FriendToken()); + b.setVal49(et49); + b.setVal50(es.EntityId(e.FriendType())); do { - auto v43 = e.TemplateParameterLists(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.TemplateParameterLists(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -11986,31 +11988,31 @@ void SerializeFriendDecl(const PendingFragment &pf, const EntityMapper &es, mx:: (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - auto v40 = e.FriendDeclaration(); - if (v40) { - auto id40 = es.EntityId(v40.value()); - b.setVal40(id40); + auto v41 = e.FriendDeclaration(); + if (v41) { + auto id41 = es.EntityId(v41.value()); + b.setVal41(id41); } else { - b.setVal40(mx::kInvalidEntityId); + b.setVal41(mx::kInvalidEntityId); } - auto et48 = es.EntityId(e.FriendToken()); - b.setVal48(et48); - auto v49 = e.FriendType(); - if (v49) { - auto id49 = es.EntityId(v49.value()); - b.setVal49(id49); + auto et49 = es.EntityId(e.FriendToken()); + b.setVal49(et49); + auto v50 = e.FriendType(); + if (v50) { + auto id50 = es.EntityId(v50.value()); + b.setVal50(id50); } else { - b.setVal49(mx::kInvalidEntityId); + b.setVal50(mx::kInvalidEntityId); } - b.setVal41(e.FriendTypeNumTemplateParameterLists()); - b.setVal42(e.IsUnsupportedFriend()); + b.setVal42(e.FriendTypeNumTemplateParameterLists()); + b.setVal43(e.IsUnsupportedFriend()); do { - auto v43 = e.FriendTypeTemplateParameterLists(); - auto sv43 = b.initVal43(static_cast(v43.size())); - auto i43 = 0u; - for (const auto &e43 : v43) { - sv43.set(i43, es.EntityId(e43)); - ++i43; + auto v44 = e.FriendTypeTemplateParameterLists(); + auto sv44 = b.initVal44(static_cast(v44.size())); + auto i44 = 0u; + for (const auto &e44 : v44) { + sv44.set(i44, es.EntityId(e44)); + ++i44; } } while (false); } @@ -12021,11 +12023,11 @@ void SerializeFileScopeAsmDecl(const PendingFragment &pf, const EntityMapper &es (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - auto et40 = es.EntityId(e.AssemblyToken()); - b.setVal40(et40); - b.setVal48(es.EntityId(e.AssemblyString())); - auto et49 = es.EntityId(e.RParenToken()); - b.setVal49(et49); + auto et41 = es.EntityId(e.AssemblyToken()); + b.setVal41(et41); + b.setVal49(es.EntityId(e.AssemblyString())); + auto et50 = es.EntityId(e.RParenToken()); + b.setVal50(et50); } void SerializeExternCContextDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::ExternCContextDecl &e, const TokenTree *) { @@ -12042,11 +12044,11 @@ void SerializeExportDecl(const PendingFragment &pf, const EntityMapper &es, mx:: (void) b; (void) e; SerializeDecl(pf, es, b, e, nullptr); - auto et40 = es.EntityId(e.ExportToken()); - b.setVal40(et40); - auto et48 = es.EntityId(e.RBraceToken()); - b.setVal48(et48); - b.setVal42(e.HasBraces()); + auto et41 = es.EntityId(e.ExportToken()); + b.setVal41(et41); + auto et49 = es.EntityId(e.RBraceToken()); + b.setVal49(et49); + b.setVal43(e.HasBraces()); } void SerializeEmptyDecl(const PendingFragment &pf, const EntityMapper &es, mx::ast::Decl::Builder b, const pasta::EmptyDecl &e, const TokenTree *) { diff --git a/bin/Index/SerializeIR.cpp b/bin/Index/SerializeIR.cpp new file mode 100644 index 000000000..a3475aa2a --- /dev/null +++ b/bin/Index/SerializeIR.cpp @@ -0,0 +1,718 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include "SerializeIR.h" +#include "IRGen.h" +#include "EntityMapper.h" +#include "PendingFragment.h" +#include "ProgressBar.h" + +#include +#include +#include + +#include + +namespace indexer { +namespace { + +using mx::RawEntityId; +using mx::kInvalidEntityId; + +// Helpers to construct entity IDs with embedded kind/opcode. +static RawEntityId MakeBlockEid( + const ir::FunctionIR &func, RawEntityId fragment_id, + uint32_t ir_block_base_offset, uint32_t local_block_idx) { + CHECK(local_block_idx < func.blocks.size()) + << "MakeBlockEid: local_block_idx=" << local_block_idx + << " >= blocks.size()=" << func.blocks.size(); + auto bk = func.blocks[local_block_idx].kind; + mx::IRBlockId bid{fragment_id, ir_block_base_offset + local_block_idx, bk}; + return mx::EntityId(bid).Pack(); +} + +static RawEntityId MakeInstEid( + const ir::FunctionIR &func, RawEntityId fragment_id, + uint32_t ir_inst_base_offset, uint32_t local_inst_idx) { + auto op = func.instructions[local_inst_idx].opcode; + mx::IRInstructionId iid{fragment_id, ir_inst_base_offset + local_inst_idx, op}; + return mx::EntityId(iid).Pack(); +} + +static RawEntityId MakeObjEid(RawEntityId fragment_id, + uint32_t ir_obj_base_offset, + uint32_t local_obj_idx) { + mx::IRObjectId oid{fragment_id, ir_obj_base_offset + local_obj_idx}; + return mx::EntityId(oid).Pack(); +} + +static RawEntityId MakeStructureEid( + const ir::FunctionIR &func, RawEntityId fragment_id, + uint32_t ir_struct_base_offset, uint32_t local_struct_idx) { + auto sk = func.structures[local_struct_idx].kind; + mx::IRStructureId sid{fragment_id, ir_struct_base_offset + local_struct_idx, sk}; + return mx::EntityId(sid).Pack(); +} + +// Pool builder: accumulates entity IDs and int values, returns offsets. +struct PoolBuilder { + std::vector entities; + std::vector ints; + + uint32_t AddEntity(uint64_t eid) { + uint32_t offset = static_cast(entities.size()); + entities.push_back(eid); + return offset; + } + + uint32_t EntitySize() const { + return static_cast(entities.size()); + } + + uint32_t AddInt(int64_t val) { + uint32_t offset = static_cast(ints.size()); + ints.push_back(val); + return offset; + } + + uint32_t IntSize() const { + return static_cast(ints.size()); + } +}; + +// Determine number of extra entity pool entries after operands, based on opcode. +static void EmitInstructionExtras( + PoolBuilder &pool, + const ir::InstructionIR &inst, + const ir::FunctionIR &func, + RawEntityId fragment_id, + uint32_t obj_base, uint32_t block_base, uint32_t inst_base, + uint32_t struct_base) { + + using OC = mx::ir::OpCode; + + switch (inst.opcode) { + case OC::CALL: + pool.AddEntity(inst.target_entity_id); + // Return alloca instruction ID (kInvalidEntityId for void calls). + if (inst.return_alloca_index != UINT32_MAX) { + pool.AddEntity(MakeInstEid(func, fragment_id, inst_base, + inst.return_alloca_index)); + } else { + pool.AddEntity(mx::kInvalidEntityId); + } + break; + + case OC::GEP_FIELD_32: case OC::GEP_FIELD_64: + pool.AddEntity(inst.target_entity_id); + pool.AddEntity(inst.type_entity_id); + break; + + case OC::PTR_ADD_32: case OC::PTR_ADD_64: + pool.AddEntity(inst.type_entity_id); + break; + + case OC::CAST: + pool.AddEntity(inst.type_entity_id); + break; + + case OC::ALLOCA: + pool.AddEntity(MakeObjEid(fragment_id, obj_base, inst.object_index)); + break; + + case OC::PARAM_PTR_32: case OC::PARAM_PTR_64: + break; + + case OC::GLOBAL_PTR_32: case OC::GLOBAL_PTR_64: + case OC::THREAD_LOCAL_PTR_32: case OC::THREAD_LOCAL_PTR_64: + case OC::FUNC_PTR_32: case OC::FUNC_PTR_64: + pool.AddEntity(inst.target_entity_id); + break; + + case OC::COND_BRANCH: + for (auto &bt : inst.branch_targets) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_base, + bt.block_index)); + } + break; + + case OC::GOTO: case OC::IMPLICIT_GOTO: + case OC::BREAK: case OC::CONTINUE: + case OC::FALLTHROUGH: case OC::IMPLICIT_FALLTHROUGH: + for (auto &bt : inst.branch_targets) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_base, + bt.block_index)); + } + break; + + case OC::SWITCH: + // Extras: [caseType, switchCase0_eid, switchCase1_eid, ...] + // Placeholders for case entity IDs -- filled in second pass. + pool.AddEntity(inst.type_entity_id); // case integral type + for (size_t i = 0; i < inst.switch_cases.size(); ++i) { + pool.AddEntity(0); // placeholder + } + break; + + case OC::ENTER_SCOPE: + case OC::EXIT_SCOPE: + if (inst.structure_index != UINT32_MAX) { + pool.AddEntity(MakeStructureEid(func, fragment_id, struct_base, + inst.structure_index)); + } else { + pool.AddEntity(0); + } + break; + + default: + break; + } +} + +static uint32_t EmitInstructionConsts( + PoolBuilder &pool, + const ir::InstructionIR &inst) { + + using OC = mx::ir::OpCode; + uint32_t offset = pool.IntSize(); + + switch (inst.opcode) { + case OC::CONST: { + pool.AddInt(static_cast(inst.const_op)); // ConstOp sub-opcode + auto cop = static_cast(inst.const_op); + if (cop == mx::ir::ConstOp::FLOAT32 || cop == mx::ir::ConstOp::FLOAT64 || + cop == mx::ir::ConstOp::FLOAT16) { + int64_t bits; + static_assert(sizeof(double) == sizeof(int64_t)); + memcpy(&bits, &inst.float_value, sizeof(bits)); + pool.AddInt(bits); + pool.AddInt(0); // placeholder for unsigned_value slot + } else { + pool.AddInt(inst.int_value); + pool.AddInt(static_cast(inst.uint_value)); + } + break; + } + + case OC::ALLOCA: + pool.AddInt(static_cast(inst.alloca_kind)); // AllocaKind sub-opcode + break; + + case OC::CAST: + pool.AddInt(static_cast(inst.cast_op)); // CastOp sub-opcode + break; + + case OC::SWITCH: + // Case values are now in SwitchCase entities, not the int pool. + break; + + case OC::GEP_FIELD_32: case OC::GEP_FIELD_64: + pool.AddInt(static_cast(inst.size_bytes)); // byte offset + break; + + case OC::PTR_ADD_32: case OC::PTR_ADD_64: + case OC::PTR_DIFF_32: case OC::PTR_DIFF_64: + pool.AddInt(static_cast(inst.size_bytes)); // element size + break; + + case OC::READ_MODIFY_WRITE: + pool.AddInt(static_cast(inst.compound_op)); // underlying opcode + pool.AddInt(static_cast(inst.size_bytes)); // element size + pool.AddInt(static_cast(inst.is_big_endian ? 1 : 0)); // endianness + break; + + case OC::PARAM_PTR_32: case OC::PARAM_PTR_64: + pool.AddInt(inst.int_value); // parameter index + break; + + case OC::BITWISE_8: case OC::BITWISE_16: + case OC::BITWISE_32: case OC::BITWISE_64: + pool.AddInt(static_cast(inst.bitwise_op)); // BitwiseOp sub-opcode + break; + + case OC::MEMORY: + pool.AddInt(static_cast(inst.mem_op)); // MemOp sub-opcode + // BIT_READ/BIT_WRITE store bit_offset and bit_width in int pool. + if (inst.mem_op == static_cast(mx::ir::MemOp::BIT_READ_LE) || + inst.mem_op == static_cast(mx::ir::MemOp::BIT_READ_BE) || + inst.mem_op == static_cast(mx::ir::MemOp::BIT_WRITE_LE) || + inst.mem_op == static_cast(mx::ir::MemOp::BIT_WRITE_BE)) { + pool.AddInt(static_cast(inst.bit_offset)); + pool.AddInt(static_cast(inst.bit_width)); + } + break; + + case OC::FLOAT: + pool.AddInt(static_cast(inst.float_op)); // FloatOp sub-opcode + break; + + default: + return offset; // no constants + } + + return offset; +} + +} // namespace + +std::vector GenerateIR( + const pasta::AST &ast, + const PendingFragment &pf, + EntityMapper &em, + const std::unique_ptr &progress) { + + std::vector ir_functions; + RawEntityId fragment_id = pf.fragment_id.Unpack().fragment_id; + + uint32_t inst_offset = 0; + + for (const auto &decl : pf.top_level_decls) { + auto func = pasta::FunctionDecl::From(decl); + if (!func || !func->Body()) continue; + + ProgressBarWork ir_tracker(progress); + ir::IRGenerator gen(ast, em); + auto ir = gen.Generate(*func); + if (!ir) { + DCHECK(false) << "IR generation returned nullopt for function with body"; + continue; + } + + // Map FunctionDecl → IRFunction. + auto func_eid = em.EntityId(RawEntity(*func)); + if (func_eid != mx::kInvalidEntityId) { + auto ir_func_eid = mx::EntityId(mx::IRFunctionId{ + fragment_id, + static_cast(ir_functions.size())}).Pack(); + em.ir_for_entity[func_eid] = ir_func_eid; + } + + for (uint32_t i = 0; i < ir->instructions.size(); ++i) { + auto &inst = ir->instructions[i]; + if (inst.source_entity_id != mx::kInvalidEntityId) { + auto ir_eid = mx::EntityId(mx::IRInstructionId{ + fragment_id, inst_offset + i, + inst.opcode}).Pack(); + em.ir_for_entity[inst.source_entity_id] = ir_eid; + } + } + + inst_offset += static_cast(ir->instructions.size()); + ir_functions.push_back(std::move(*ir)); + } + + // Generate IR for global variables with initializers, including static locals. + // Collect all global-storage VarDecls: top-level globals + static locals. + std::vector global_vars; + for (const auto &decl : pf.top_level_decls) { + auto var = pasta::VarDecl::From(decl); + if (var && var->Initializer() && var->HasGlobalStorage()) { + global_vars.push_back(*var); + } + // Scan function bodies for static locals. + if (auto func = pasta::FunctionDecl::From(decl)) { + if (auto body = func->Body()) { + std::function find_statics; + find_statics = [&](const pasta::Stmt &s) { + if (auto ds = pasta::DeclStmt::From(s)) { + for (const auto &d : ds->Declarations()) { + auto vd = pasta::VarDecl::From(d); + if (vd && vd->Initializer() && vd->HasGlobalStorage()) { + global_vars.push_back(*vd); + } + } + } + for (const auto &child : s.Children()) { + find_statics(child); + } + }; + find_statics(*body); + } + } + } + + for (const auto &var : global_vars) { + + ProgressBarWork ir_tracker(progress); + ir::IRGenerator gen(ast, em); + auto ir = gen.GenerateGlobalInit(var); + if (!ir) continue; + + // Map VarDecl → IRFunction (GLOBAL_INITIALIZER). + auto var_eid = em.EntityId(RawEntity(var)); + if (var_eid != mx::kInvalidEntityId) { + auto ir_func_eid = mx::EntityId(mx::IRFunctionId{ + fragment_id, + static_cast(ir_functions.size())}).Pack(); + em.ir_for_entity[var_eid] = ir_func_eid; + } + + for (uint32_t i = 0; i < ir->instructions.size(); ++i) { + auto &inst = ir->instructions[i]; + if (inst.source_entity_id != mx::kInvalidEntityId) { + auto ir_eid = mx::EntityId(mx::IRInstructionId{ + fragment_id, inst_offset + i, + inst.opcode}).Pack(); + // Don't overwrite existing mappings (the VarDecl already maps + // to its IRFunction). + em.ir_for_entity.emplace(inst.source_entity_id, ir_eid); + } + } + + inst_offset += static_cast(ir->instructions.size()); + ir_functions.push_back(std::move(*ir)); + } + + return ir_functions; +} + +void SerializeIR( + const std::vector &ir_functions, + const PendingFragment &pf, + EntityMapper &em, + mx::rpc::Fragment::Builder &fb) { + + if (ir_functions.empty()) return; + + RawEntityId fragment_id = pf.fragment_id.Unpack().fragment_id; + + // Count totals. + uint32_t total_blocks = 0; + uint32_t total_instructions = 0; + uint32_t total_objects = 0; + uint32_t total_structures = 0; + for (const auto &func : ir_functions) { + total_blocks += static_cast(func.blocks.size()); + total_instructions += static_cast(func.instructions.size()); + total_objects += static_cast(func.objects.size()); + total_structures += static_cast(func.structures.size()); + } + + // Build the pools. + PoolBuilder pool; + + // Pre-allocate output lists. + auto frag_funcs = fb.initIrFunctions(ir_functions.size()); + auto frag_blocks = fb.initIrBlocks(total_blocks); + auto frag_insts = fb.initIrInstructions(total_instructions); + auto frag_objs = fb.initIrObjects(total_objects); + auto frag_structs = fb.initIrStructures(total_structures); + + uint32_t block_offset = 0; + uint32_t inst_offset = 0; + uint32_t obj_offset = 0; + uint32_t struct_offset = 0; + + for (size_t fi = 0; fi < ir_functions.size(); ++fi) { + const auto &func = ir_functions[fi]; + + // Serialize objects. + for (size_t oi = 0; oi < func.objects.size(); ++oi) { + auto &src = func.objects[oi]; + auto ob = frag_objs[obj_offset + oi]; + ob.setSourceDeclId(src.source_decl_id); + ob.setTypeEntityId(src.type_entity_id); + ob.setSizeBytes(src.size_bytes); + ob.setAlignBytes(src.align_bytes); + ob.setKind(static_cast(src.kind)); + } + + // No reverse map needed: each instruction stores parent_block_index. + + // Serialize instructions. + for (size_t ii = 0; ii < func.instructions.size(); ++ii) { + const auto &src = func.instructions[ii]; + auto ib = frag_insts[inst_offset + ii]; + + // Entity pool: [parentBlockOrInst, sourceEntityId, (type?), op0..opN, ...extras] + uint32_t ent_start = pool.EntitySize(); + + // Position 0: parent (block for roots, instruction for sub-exprs). + if (src.parent_instruction_index == UINT32_MAX) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, + src.parent_block_index)); + } else { + pool.AddEntity(MakeInstEid(func, fragment_id, inst_offset, + src.parent_instruction_index)); + } + + // Position 1: source entity ID. + pool.AddEntity(src.source_entity_id); + + // Position 2 (value-producing only): result type. + { + bool has_type = !mx::ir::IsTerminator(src.opcode) && + src.opcode != mx::ir::OpCode::VA_START && + src.opcode != mx::ir::OpCode::VA_END && + src.opcode != mx::ir::OpCode::VA_COPY && + src.opcode != mx::ir::OpCode::UNKNOWN; + // MEMORY direct stores don't produce a value. + if (has_type && src.opcode == mx::ir::OpCode::MEMORY) { + auto mop = static_cast(src.mem_op); + if (mx::ir::IsDirectLoadStore(mop) && mx::ir::IsAnyStore(mop)) + has_type = false; + } + if (has_type) pool.AddEntity(src.type_entity_id); + } + + // Operands. + for (auto op_idx : src.operand_indices) { + pool.AddEntity(MakeInstEid(func, fragment_id, inst_offset, op_idx)); + } + + // Opcode-specific extras. + EmitInstructionExtras(pool, src, func, fragment_id, + obj_offset, block_offset, inst_offset, + struct_offset); + + // Int pool. + uint32_t const_start = EmitInstructionConsts(pool, src); + + ib.setEntityOffset(ent_start); + ib.setConstOffset(const_start); + // Operand count fits in uint8_t: most instructions have 0-3 operands. + // CALL has one per argument; 255 args is the practical limit. Variadic + // calls with more would need a wider field in the capnp schema. + DCHECK(src.operand_indices.size() <= 255) + << "Instruction has " << src.operand_indices.size() + << " operands, exceeding uint8_t capacity"; + ib.setNumOperands(static_cast(src.operand_indices.size())); + // OpCode is uint8_t (max value 250 = ATOMIC_EXCHANGE_64). If we + // ever exceed 255 opcodes, the capnp schema and this cast must + // be widened to UInt16. + DCHECK(static_cast(src.opcode) <= 255) + << "OpCode " << static_cast(src.opcode) + << " exceeds uint8_t capacity"; + ib.setOpcode(static_cast(src.opcode)); + ib.setConstWidth(src.width); + ib.setFlags(src.flags); + } + + // Serialize blocks. + for (size_t bi = 0; bi < func.blocks.size(); ++bi) { + const auto &src = func.blocks[bi]; + auto bb = frag_blocks[block_offset + bi]; + + uint32_t ent_start = pool.EntitySize(); + + // Instructions. + for (auto idx : src.instruction_indices) { + pool.AddEntity(MakeInstEid(func, fragment_id, inst_offset, idx)); + } + + // Successors. + for (auto idx : src.successor_indices) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, idx)); + } + + // Predecessors. + for (auto idx : src.predecessor_indices) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, idx)); + } + + // Dominators (first = immediate dominator). + if (src.immediate_dominator != UINT32_MAX) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, + src.immediate_dominator)); + } + for (auto idx : src.dominator_indices) { + if (idx != src.immediate_dominator) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, idx)); + } + } + + // Post-dominators (first = immediate post-dominator). + if (src.immediate_post_dominator != UINT32_MAX) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, + src.immediate_post_dominator)); + } + for (auto idx : src.post_dominator_indices) { + if (idx != src.immediate_post_dominator) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, idx)); + } + } + + uint16_t num_doms = (src.immediate_dominator != UINT32_MAX ? 1 : 0) + + static_cast(src.dominator_indices.size() + - (src.immediate_dominator != UINT32_MAX ? 1 : 0)); + uint16_t num_pdoms = (src.immediate_post_dominator != UINT32_MAX ? 1 : 0) + + static_cast(src.post_dominator_indices.size() + - (src.immediate_post_dominator != UINT32_MAX ? 1 : 0)); + + bb.setEntityOffset(ent_start); + bb.setNumInstructions(static_cast(src.instruction_indices.size())); + bb.setNumSuccessors(static_cast(src.successor_indices.size())); + bb.setNumPredecessors(static_cast(src.predecessor_indices.size())); + bb.setNumDominators(num_doms); + bb.setNumPostDominators(num_pdoms); + bb.setKind(static_cast(src.kind)); + + // Set parent structure ID. + if (src.parent_structure_index != UINT32_MAX) { + bb.setParentStructureId(MakeStructureEid(func, fragment_id, + struct_offset, + src.parent_structure_index)); + } + } + + // Serialize function. + { + auto ffb = frag_funcs[fi]; + ffb.setSourceDeclEntityId(func.func_decl_entity_id); + ffb.setKind(static_cast(func.kind)); + ffb.setEntryBlockId(MakeBlockEid(func, fragment_id, block_offset, + func.entry_block_index)); + if (func.body_scope_index != UINT32_MAX) { + ffb.setBodyScopeId(MakeStructureEid(func, fragment_id, struct_offset, + func.body_scope_index)); + } + + // Function's block and object lists go into the entity pool. + uint32_t func_ent_start = pool.EntitySize(); + for (auto idx : func.rpo_block_order) { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, idx)); + } + for (uint32_t oi = 0; oi < func.objects.size(); ++oi) { + pool.AddEntity(MakeObjEid(fragment_id, obj_offset, oi)); + } + ffb.setEntityOffset(func_ent_start); + ffb.setNumBlocks(static_cast(func.rpo_block_order.size())); + ffb.setNumObjects(static_cast(func.objects.size())); + } + + // Serialize structures. + for (uint32_t si = 0; si < func.structures.size(); ++si) { + const auto &src = func.structures[si]; + auto sb = frag_structs[struct_offset + si]; + + sb.setKind(static_cast(src.kind)); + sb.setSourceEntityId(src.source_entity_id); + + // Parent: structure or function. + if (src.parent_structure_index != UINT32_MAX) { + sb.setParentId(MakeStructureEid(func, fragment_id, struct_offset, + src.parent_structure_index)); + } else { + // Parent is the function itself. + mx::IRFunctionId fid{fragment_id, static_cast(fi)}; + sb.setParentId(mx::EntityId(fid).Pack()); + } + + // Children: structures and blocks interleaved. + uint32_t ent_start = pool.EntitySize(); + for (const auto &child : src.children) { + if (child.is_structure) { + pool.AddEntity(MakeStructureEid(func, fragment_id, struct_offset, + child.index)); + } else { + pool.AddEntity(MakeBlockEid(func, fragment_id, block_offset, + child.index)); + } + } + // Objects (for scope kinds). + for (auto oi : src.object_indices) { + pool.AddEntity(MakeObjEid(fragment_id, obj_offset, oi)); + } + + sb.setEntityOffset(ent_start); + sb.setNumChildren(static_cast(src.children.size())); + sb.setNumObjects(static_cast(src.object_indices.size())); + + // SWITCH_CASE data. + if (src.kind == mx::ir::StructureKind::SWITCH_CASE) { + sb.setCaseLow(src.case_low); + sb.setCaseHigh(src.case_high); + sb.setIsDefault(src.is_default); + } + } + + block_offset += static_cast(func.blocks.size()); + inst_offset += static_cast(func.instructions.size()); + obj_offset += static_cast(func.objects.size()); + struct_offset += static_cast(func.structures.size()); + } + + // Fill in switch instruction placeholder pool entries with IRStructureId + // references to the SWITCH_CASE structures. + { + uint32_t func_inst_base = 0; + uint32_t func_struct_base = 0; + + for (const auto &func : ir_functions) { + for (uint32_t ii = 0; ii < func.instructions.size(); ++ii) { + const auto &inst = func.instructions[ii]; + if (inst.opcode != mx::ir::OpCode::SWITCH) continue; + + // Find the placeholder offset: extras start at + // entityOffset + 2(parent+source) + numOperands + // SWITCH is a terminator so has no type slot. + // extras[0] = caseType, extras[1..] = case entity IDs. + auto r = frag_insts[func_inst_base + ii]; + uint32_t placeholder_base = r.getEntityOffset() + 2 + + r.getNumOperands() + 1; // +1 for caseType at extras[0] + + for (size_t sci = 0; sci < inst.switch_cases.size(); ++sci) { + const auto &sc = inst.switch_cases[sci]; + + // Overwrite the placeholder with an IRStructureId for the + // SWITCH_CASE structure. + CHECK(sc.structure_index != UINT32_MAX) + << "Switch case " << sci << " has no structure_index"; + auto sc_eid = MakeStructureEid(func, fragment_id, + func_struct_base, + sc.structure_index); + pool.entities[placeholder_base + sci] = sc_eid; + + // Map CaseStmt/DefaultStmt -> IRStructure (SWITCH_CASE). + if (sc.source_entity_id != mx::kInvalidEntityId) { + em.ir_for_entity[sc.source_entity_id] = sc_eid; + } + } + } + func_inst_base += static_cast(func.instructions.size()); + func_struct_base += static_cast(func.structures.size()); + } + } + + // Compute use-def chains and write per-instruction users lists. + { + std::vector opcodes(total_instructions); + std::vector> users(total_instructions); + { + uint32_t gi = 0; + for (const auto &func : ir_functions) { + for (uint32_t ii = 0; ii < func.instructions.size(); ++ii) { + opcodes[gi + ii] = static_cast(func.instructions[ii].opcode); + for (auto op_idx : func.instructions[ii].operand_indices) { + users[gi + op_idx].push_back(gi + ii); + } + } + gi += static_cast(func.instructions.size()); + } + } + + for (uint32_t gi = 0; gi < total_instructions; ++gi) { + auto &u = users[gi]; + auto user_list = frag_insts[gi].initUsers(u.size()); + for (size_t j = 0; j < u.size(); ++j) { + mx::IRInstructionId iid{fragment_id, u[j], static_cast(opcodes[u[j]])}; + user_list.set(j, mx::EntityId(iid).Pack()); + } + } + } + + // Write the pools into the fragment. + auto ep = fb.initIrEntityPool(pool.entities.size()); + for (size_t i = 0; i < pool.entities.size(); ++i) { + ep.set(i, pool.entities[i]); + } + + auto ip = fb.initIrIntPool(pool.ints.size()); + for (size_t i = 0; i < pool.ints.size(); ++i) { + ip.set(i, pool.ints[i]); + } +} + +} // namespace indexer diff --git a/bin/Index/SerializeIR.h b/bin/Index/SerializeIR.h new file mode 100644 index 000000000..5fb3299f0 --- /dev/null +++ b/bin/Index/SerializeIR.h @@ -0,0 +1,42 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include +#include +#include + +#include "IRGen.h" + +namespace pasta { +class AST; +} // namespace pasta + +namespace indexer { + +class EntityMapper; +class PendingFragment; +class ProgressBar; + +// Step 1: Generate IR for all function bodies in the fragment. +// Returns the generated IR functions. Also populates the reverse map +// on the EntityMapper (AST entity ID → IR instruction entity ID). +std::vector GenerateIR( + const pasta::AST &ast, + const PendingFragment &pf, + EntityMapper &em, + const std::unique_ptr &progress); + +// Step 2: Serialize previously-generated IR into the fragment proto. +// Also populates remaining reverse mappings (e.g. CaseStmt -> IRStructure). +void SerializeIR( + const std::vector &ir_functions, + const PendingFragment &pf, + EntityMapper &em, + mx::rpc::Fragment::Builder &fb); + +} // namespace indexer diff --git a/bin/InterpretIR/CMakeLists.txt b/bin/InterpretIR/CMakeLists.txt new file mode 100644 index 000000000..06b28a6e2 --- /dev/null +++ b/bin/InterpretIR/CMakeLists.txt @@ -0,0 +1,40 @@ +# +# Copyright (c) 2024-present, Trail of Bits, Inc. +# +# This source code is licensed in accordance with the terms specified in +# the LICENSE file found in the root directory of this source tree. +# + +add_executable("mx-interpret-ir" + "InterpretIR.cpp" +) + +target_link_libraries("mx-interpret-ir" + PRIVATE + "mx-example-index" +) + +set_target_properties("mx-interpret-ir" + PROPERTIES + LINKER_LANGUAGE + CXX + RUNTIME_OUTPUT_DIRECTORY + "${PROJECT_BINARY_DIR}/${MX_INSTALL_BIN_DIR}" +) + +target_include_directories("mx-interpret-ir" + PRIVATE + "${CMAKE_CURRENT_SOURCE_DIR}/../Examples" +) + +if(MX_ENABLE_INSTALL AND NOT MX_ENABLE_BOOTSTRAP) + install( + TARGETS + "mx-interpret-ir" + EXPORT + "${PROJECT_NAME}Targets" + RUNTIME + DESTINATION + "${CMAKE_INSTALL_BINDIR}" + ) +endif() diff --git a/bin/InterpretIR/InterpretIR.cpp b/bin/InterpretIR/InterpretIR.cpp new file mode 100644 index 000000000..66e71decb --- /dev/null +++ b/bin/InterpretIR/InterpretIR.cpp @@ -0,0 +1,3588 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// A concrete interpreter for the Multiplier IR. Walks the CFG, evaluates +// instructions, and tracks memory state. Designed as testing infrastructure +// to shake out IR generation bugs and validate the API surface. +// +// Usage: mx-interpret-ir --db /path/to/index.db --entity_name "function_name" +// +// Critique notes (embedded for future reference): +// - The IR API requires downcasting to get result_type() from most instructions. +// A base-class result_type() would simplify the interpreter significantly. +// - STRING_PTR returns a pointer to interpreter-managed storage populated +// from StringLiteral::bytes(). Each STRING_PTR instruction gets a unique +// address keyed by its entity ID. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Index.h" +#include +#include +#include +#include + +DEFINE_uint64(entity_id, mx::kInvalidEntityId, "ID of the entity to interpret"); +DEFINE_string(entity_name, "", "Name of the function to interpret"); +DEFINE_bool(trace, false, "Print each instruction as it executes"); +DEFINE_uint64(max_steps, 100000, "Maximum instruction steps before aborting"); + +namespace { + +// --------------------------------------------------------------------------- +// Value representation +// --------------------------------------------------------------------------- + +// A value is either an integer, a float, or a pointer (object + byte offset). +struct Pointer { + mx::RawEntityId object_id{mx::kInvalidEntityId}; + int64_t offset{0}; + + bool operator==(const Pointer &o) const { + return object_id == o.object_id && offset == o.offset; + } +}; + +struct Value { + enum Kind { UNDEFINED, INTEGER, FLOATING, POINTER } kind{UNDEFINED}; + int64_t ival{0}; + double fval{0.0}; + Pointer ptr{}; + + static Value Int(int64_t v) { return {INTEGER, v, 0.0, {}}; } + static Value Float(double v) { return {FLOATING, 0, v, {}}; } + static Value Ptr(mx::RawEntityId obj, int64_t off = 0) { + return {POINTER, 0, 0.0, {obj, off}}; + } + static Value Undef() { return {}; } + + bool is_truthy() const { + switch (kind) { + case INTEGER: return ival != 0; + case FLOATING: return fval != 0.0; + case POINTER: return ptr.object_id != mx::kInvalidEntityId; + default: return false; + } + } + + int64_t as_int() const { return ival; } + uint64_t as_uint() const { return static_cast(ival); } + double as_float() const { return fval; } +}; + +// --------------------------------------------------------------------------- +// Memory model +// --------------------------------------------------------------------------- + +struct MemoryObject { + std::vector bytes; + bool allocated{false}; + bool poisoned{false}; // Set when scope exits +}; + +// --------------------------------------------------------------------------- +// Interpreter state +// --------------------------------------------------------------------------- + +class Interpreter { + public: + Interpreter(const mx::IRFunction &func, bool trace) + : func_(func), trace_(trace) {} + + // Run the interpreter. Returns the return value (or UNDEFINED for void). + Value Run(const std::vector &args); + + private: + const mx::IRFunction &func_; + bool trace_; + + // Instruction ID → computed value. + std::unordered_map values_; + + // Object ID → memory. + std::unordered_map memory_; + + // Block ID → IRBlock (for CFG navigation). + std::unordered_map block_map_; + + // Parameter values passed to the function. + std::vector params_; + + // Pointers to parameter storage (allocated during setup, populated from params_). + // PARAM_PTR(n) returns param_ptrs_[n]. + std::vector param_ptrs_; + + // Pointer to return value storage. RETURN_PTR returns this. + Value return_ptr_ = Value::Undef(); + + // Counter for interpreter-allocated objects (return storage, etc.). + // The memory_ map uses uint64_t keys. Real entity IDs use packed + // formats with category/fragment/offset bits. We use small integers + // (1, 2, 3...) which can't collide with packed entity IDs since those + // always have category bits set in the high word. + uint64_t next_interp_object_id_{1}; + + uint64_t steps_{0}; + + // Evaluate a single instruction, storing result in values_. + void Eval(const mx::IRInstruction &inst); + + // Recursively evaluate all sub-expressions of an instruction. + void EvalSubExpressions(const mx::IRInstruction &inst); + + // Get the value of an instruction (must have been evaluated already). + Value GetValue(const mx::IRInstruction &inst); + + // Memory operations. + void MemWrite(const Pointer &ptr, const void *data, size_t len); + void MemRead(const Pointer &ptr, void *data, size_t len); + void MemWriteValue(const Pointer &ptr, const Value &val, size_t size); + Value MemReadValue(const Pointer &ptr, size_t size, bool is_float); + + // Pointer shadow map: tracks which memory locations hold pointer values. + // Key = (object_id << 32) | offset. When a pointer is written, it's + // recorded here. When loading pointer-sized values, check here first. + std::unordered_map pointer_shadow_; + + // Allocate memory for an object. + void AllocateObject(const mx::IRObject &obj); + + // Trace output. + void Trace(const mx::IRInstruction &inst, const Value &result); +}; + +// --------------------------------------------------------------------------- +// Memory implementation +// --------------------------------------------------------------------------- + +void Interpreter::AllocateObject(const mx::IRObject &obj) { + auto eid = mx::EntityId(obj.id()).Pack(); + auto &mem = memory_[eid]; + uint32_t size = obj.size_bytes(); + if (size == 0) size = 8; // Default for unknown-size objects. + mem.bytes.resize(size, 0); + mem.allocated = true; + mem.poisoned = false; +} + +void Interpreter::MemWrite(const Pointer &ptr, const void *data, size_t len) { + auto it = memory_.find(ptr.object_id); + if (it == memory_.end()) { + LOG(WARNING) << "Write to unallocated object " << ptr.object_id; + return; + } + auto &mem = it->second; + if (mem.poisoned) { + LOG(WARNING) << "Write to poisoned (out-of-scope) object " << ptr.object_id; + } + size_t start = static_cast(ptr.offset); + if (start + len > mem.bytes.size()) { + // Auto-grow for VLA-like objects (compile-time size unknown). + mem.bytes.resize(start + len, 0); + } + std::memcpy(mem.bytes.data() + start, data, len); +} + +void Interpreter::MemRead(const Pointer &ptr, void *data, size_t len) { + auto it = memory_.find(ptr.object_id); + if (it == memory_.end()) { + LOG(WARNING) << "Read from unallocated object " << ptr.object_id; + std::memset(data, 0, len); + return; + } + auto &mem = it->second; + if (mem.poisoned) { + LOG(WARNING) << "Read from poisoned (out-of-scope) object " << ptr.object_id; + } + size_t start = static_cast(ptr.offset); + if (start + len > mem.bytes.size()) { + // Auto-grow for VLA-like objects. + mem.bytes.resize(start + len, 0); + } + std::memcpy(data, mem.bytes.data() + start, len); +} + +void Interpreter::MemWriteValue(const Pointer &ptr, const Value &val, + size_t size) { + uint64_t shadow_key = (static_cast(ptr.object_id) << 32) | + (static_cast(ptr.offset) & 0xFFFFFFFF); + if (val.kind == Value::POINTER) { + // Record pointer in shadow map for later loads. + pointer_shadow_[shadow_key] = val.ptr; + // Also write a sentinel to memory bytes (not meaningful, just fills space). + int64_t sentinel = 0; + MemWrite(ptr, &sentinel, std::min(size, sizeof(sentinel))); + return; + } + // Non-pointer write: clear pointer shadow at this location. + pointer_shadow_.erase(shadow_key); + if (val.kind == Value::FLOATING) { + if (size == 4) { + float f = static_cast(val.fval); + MemWrite(ptr, &f, 4); + } else { + MemWrite(ptr, &val.fval, 8); + } + } else { + // Integer or undefined — write as int. + MemWrite(ptr, &val.ival, std::min(size, sizeof(val.ival))); + } +} + +Value Interpreter::MemReadValue(const Pointer &ptr, size_t size, + bool is_float) { + // Check pointer shadow map first. + uint64_t shadow_key = (static_cast(ptr.object_id) << 32) | + (static_cast(ptr.offset) & 0xFFFFFFFF); + auto pit = pointer_shadow_.find(shadow_key); + if (pit != pointer_shadow_.end()) { + return Value::Ptr(pit->second.object_id, pit->second.offset); + } + if (is_float) { + if (size == 4) { + float f = 0; + MemRead(ptr, &f, 4); + return Value::Float(static_cast(f)); + } + double d = 0; + MemRead(ptr, &d, 8); + return Value::Float(d); + } + // Read integer and sign-extend to int64 to match CONST representation. + // Everything is int64 internally. Sign extension ensures -10 stored in + // 4 bytes reads back as int64(-10), matching CONST(INT32, -10). + int64_t v = 0; + MemRead(ptr, &v, std::min(size, sizeof(v))); + switch (size) { + case 1: v = static_cast(static_cast(v)); break; + case 2: v = static_cast(static_cast(v)); break; + case 4: v = static_cast(static_cast(v)); break; + default: break; + } + return Value::Int(v); +} + +// --------------------------------------------------------------------------- +// Value access +// --------------------------------------------------------------------------- + +Value Interpreter::GetValue(const mx::IRInstruction &inst) { + auto op = inst.opcode(); + auto eid = mx::EntityId(inst.id()).Pack(); + + // Use cached result if available. + auto it = values_.find(eid); + if (it != values_.end()) return it->second; + + // Lazy evaluation for sub-expressions not yet computed. + if (!mx::ir::IsTerminator(op)) { + Eval(inst); + it = values_.find(eid); + if (it != values_.end()) return it->second; + } + return Value::Undef(); +} + +// --------------------------------------------------------------------------- +// Trace +// --------------------------------------------------------------------------- + +void Interpreter::Trace(const mx::IRInstruction &inst, const Value &result) { + if (!trace_) return; + std::cerr << " [" << steps_ << "] " + << static_cast(inst.opcode()); + switch (result.kind) { + case Value::INTEGER: + std::cerr << " → " << result.ival; + break; + case Value::FLOATING: + std::cerr << " → " << result.fval; + break; + case Value::POINTER: + std::cerr << " → ptr(" << result.ptr.object_id + << "+" << result.ptr.offset << ")"; + break; + default: + std::cerr << " → undef"; + break; + } + std::cerr << "\n"; +} + +// --------------------------------------------------------------------------- +// Instruction evaluation +// --------------------------------------------------------------------------- + +void Interpreter::Eval(const mx::IRInstruction &inst) { + auto op = inst.opcode(); + auto eid = mx::EntityId(inst.id()).Pack(); + Value result = Value::Undef(); + + switch (op) { + + // --- Constants --- + case mx::ir::OpCode::CONST: { + if (auto ci = mx::ConstInst::from(inst)) { + auto sub = ci->sub_opcode(); + if (sub == mx::ir::ConstOp::NULL_PTR) { + result = Value::Ptr(mx::kInvalidEntityId, 0); + } else if (sub == mx::ir::ConstOp::FLOAT32 || + sub == mx::ir::ConstOp::FLOAT64 || + sub == mx::ir::ConstOp::FLOAT16) { + result = Value::Float(ci->float_value()); + } else if (sub == mx::ir::ConstOp::UINT64) { + // UINT64: use unsigned value directly (no sign extension needed). + result = Value::Int(static_cast(ci->unsigned_value())); + } else if (sub == mx::ir::ConstOp::UINT32) { + // UINT32: sign-extend to match LOAD_LE_32 sign-extension. + result = Value::Int(static_cast( + static_cast(static_cast(ci->unsigned_value())))); + } else if (sub == mx::ir::ConstOp::UINT16) { + result = Value::Int(static_cast( + static_cast(static_cast(ci->unsigned_value())))); + } else if (sub == mx::ir::ConstOp::UINT8) { + result = Value::Int(static_cast( + static_cast(static_cast(ci->unsigned_value())))); + } else { + result = Value::Int(ci->signed_value()); + } + } + break; + } + + // --- Memory --- + case mx::ir::OpCode::ALLOCA: { + if (auto ai = mx::AllocaInst::from(inst)) { + auto obj = ai->object(); + auto obj_eid = mx::EntityId(obj.id()).Pack(); + if (memory_.find(obj_eid) == memory_.end()) { + // For DYNAMIC allocas (VLAs), use the runtime size operand. + if (auto da = mx::DynamicAllocaInst::from(inst)) { + Value sz_val = GetValue(da->size()); + uint32_t runtime_sz = static_cast(sz_val.as_int()); + if (runtime_sz > 0) { + auto &mem = memory_[obj_eid]; + mem.bytes.resize(runtime_sz, 0); + mem.allocated = true; + mem.poisoned = false; + } else { + AllocateObject(obj); + } + } else { + AllocateObject(obj); + } + } + result = Value::Ptr(obj_eid, 0); + } + break; + } + + // STRING_PTR: pointer to a string literal. The interpreter allocates + // storage keyed by the instruction's entity ID and populates it from + // StringLiteral::bytes(). Subsequent evaluations return the same pointer. + case mx::ir::OpCode::STRING_PTR_32: + case mx::ir::OpCode::STRING_PTR_64: { + auto inst_eid = mx::EntityId(inst.id()).Pack(); + if (memory_.find(inst_eid) == memory_.end()) { + if (auto src = inst.source_statement()) { + if (auto sl = mx::StringLiteral::from(*src)) { + auto bytes = sl->bytes(); + uint32_t char_width = sl->character_byte_width(); + uint32_t total = sl->byte_length() + char_width; + auto &mem = memory_[inst_eid]; + mem.bytes.resize(total, 0); + mem.allocated = true; + mem.poisoned = false; + size_t copy_len = std::min(bytes.size(), total); + std::memcpy(mem.bytes.data(), bytes.data(), copy_len); + } + } + } + result = Value::Ptr(inst_eid, 0); + break; + } + case mx::ir::OpCode::MEMORY: { + if (auto mi = mx::MemoryInst::from(inst)) { + auto sub = mi->sub_opcode(); + if (mx::ir::IsDirectLoadStore(sub)) { + unsigned sz = mx::ir::AccessSize(sub); + bool is_float = mx::ir::IsFloatLoad(sub); + if (mx::ir::IsAnyLoad(sub)) { + Value addr = GetValue(mi->address()); + if (addr.kind == Value::POINTER) { + result = MemReadValue(addr.ptr, sz, is_float); + } else { + LOG(WARNING) << "MEMORY load from non-pointer value"; + } + } else { + // Store. + Value addr = GetValue(mi->address()); + Value val = GetValue(mi->stored_value()); + if (addr.kind == Value::POINTER) { + MemWriteValue(addr.ptr, val, sz); + } else { + LOG(WARNING) << "MEMORY store to non-pointer value"; + } + } + } else { + // Bulk memory/string operations. + auto ops_gen = inst.operands(); + std::vector ops; + for (auto op_inst : ops_gen) { + ops.push_back(GetValue(op_inst)); + } + using MO = mx::ir::MemOp; + switch (sub) { + case MO::MEMSET: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER && ops[2].as_int() > 0) { + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + size_t start = static_cast(ops[0].ptr.offset); + size_t len = static_cast(ops[2].as_int()); + size_t end = std::min(start + len, it->second.bytes.size()); + std::memset(it->second.bytes.data() + start, + static_cast(ops[1].as_int()), end - start); + } + } + result = ops.empty() ? Value::Undef() : ops[0]; + break; + } + case MO::MEMCPY: + case MO::MEMMOVE: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER && ops[2].as_int() > 0) { + size_t len = static_cast(ops[2].as_int()); + std::vector tmp(len); + MemRead(ops[1].ptr, tmp.data(), len); + MemWrite(ops[0].ptr, tmp.data(), len); + } + result = ops.empty() ? Value::Undef() : ops[0]; + break; + } + case MO::BZERO: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER && ops[1].as_int() > 0) { + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + size_t start = static_cast(ops[0].ptr.offset); + size_t len = static_cast(ops[1].as_int()); + size_t end = std::min(start + len, it->second.bytes.size()); + std::memset(it->second.bytes.data() + start, 0, end - start); + } + } + result = ops.empty() ? Value::Undef() : ops[0]; + break; + } + case MO::STRLEN: { + if (ops.size() >= 1 && ops[0].kind == Value::POINTER) { + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + size_t start = static_cast(ops[0].ptr.offset); + size_t len = 0; + while (start + len < it->second.bytes.size() && + it->second.bytes[start + len] != 0) ++len; + result = Value::Int(static_cast(len)); + } + } + break; + } + case MO::STRCMP: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + auto it0 = memory_.find(ops[0].ptr.object_id); + auto it1 = memory_.find(ops[1].ptr.object_id); + if (it0 != memory_.end() && it1 != memory_.end()) { + size_t s0 = static_cast(ops[0].ptr.offset); + size_t s1 = static_cast(ops[1].ptr.offset); + int cmp = 0; + while (true) { + uint8_t c0 = (s0 < it0->second.bytes.size()) ? it0->second.bytes[s0] : 0; + uint8_t c1 = (s1 < it1->second.bytes.size()) ? it1->second.bytes[s1] : 0; + if (c0 != c1) { cmp = (c0 < c1) ? -1 : 1; break; } + if (c0 == 0) break; + ++s0; ++s1; + } + result = Value::Int(cmp); + } + } + break; + } + case MO::MEMCMP: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + size_t len = static_cast(ops[2].as_int()); + std::vector buf0(len, 0), buf1(len, 0); + MemRead(ops[0].ptr, buf0.data(), len); + MemRead(ops[1].ptr, buf1.data(), len); + result = Value::Int(std::memcmp(buf0.data(), buf1.data(), len)); + } + break; + } + case MO::MEMCHR: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER) { + size_t len = static_cast(ops[2].as_int()); + uint8_t needle = static_cast(ops[1].as_int()); + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + size_t start = static_cast(ops[0].ptr.offset); + for (size_t i = 0; i < len && start + i < it->second.bytes.size(); ++i) { + if (it->second.bytes[start + i] == needle) { + result = Value::Ptr(ops[0].ptr.object_id, + ops[0].ptr.offset + static_cast(i)); + break; + } + } + } + } + break; + } + case MO::STRCHR: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER) { + uint8_t needle = static_cast(ops[1].as_int()); + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + size_t start = static_cast(ops[0].ptr.offset); + bool found = false; + for (size_t i = start; i < it->second.bytes.size(); ++i) { + if (it->second.bytes[i] == needle) { + result = Value::Ptr(ops[0].ptr.object_id, + static_cast(i)); + found = true; + break; + } + if (it->second.bytes[i] == 0) break; + } + if (!found) { + // If searching for null terminator, point to it. + if (needle == 0) { + for (size_t i = start; i < it->second.bytes.size(); ++i) { + if (it->second.bytes[i] == 0) { + result = Value::Ptr(ops[0].ptr.object_id, + static_cast(i)); + found = true; + break; + } + } + } + if (!found) { + result = Value::Ptr(mx::kInvalidEntityId, 0); // NULL + } + } + } + } + break; + } + case MO::STRNLEN: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER) { + int64_t maxlen = ops[1].as_int(); + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + size_t start = static_cast(ops[0].ptr.offset); + size_t len = 0; + while (len < static_cast(maxlen) && + start + len < it->second.bytes.size() && + it->second.bytes[start + len] != 0) ++len; + result = Value::Int(static_cast(len)); + } + } + break; + } + case MO::STRNCMP: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + size_t n = static_cast(ops[2].as_int()); + auto it0 = memory_.find(ops[0].ptr.object_id); + auto it1 = memory_.find(ops[1].ptr.object_id); + if (it0 != memory_.end() && it1 != memory_.end()) { + size_t s0 = static_cast(ops[0].ptr.offset); + size_t s1 = static_cast(ops[1].ptr.offset); + int cmp = 0; + for (size_t i = 0; i < n; ++i) { + uint8_t c0 = (s0 + i < it0->second.bytes.size()) ? it0->second.bytes[s0 + i] : 0; + uint8_t c1 = (s1 + i < it1->second.bytes.size()) ? it1->second.bytes[s1 + i] : 0; + if (c0 != c1) { cmp = (c0 < c1) ? -1 : 1; break; } + if (c0 == 0) break; + } + result = Value::Int(cmp); + } + } + break; + } + case MO::STRRCHR: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER) { + uint8_t needle = static_cast(ops[1].as_int()); + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + size_t start = static_cast(ops[0].ptr.offset); + int64_t last_pos = -1; + for (size_t i = start; i < it->second.bytes.size(); ++i) { + if (it->second.bytes[i] == needle) { + last_pos = static_cast(i); + } + if (it->second.bytes[i] == 0) break; + } + if (last_pos >= 0) { + result = Value::Ptr(ops[0].ptr.object_id, last_pos); + } else { + result = Value::Ptr(mx::kInvalidEntityId, 0); // NULL + } + } + } + break; + } + case MO::STRSTR: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + auto it0 = memory_.find(ops[0].ptr.object_id); + auto it1 = memory_.find(ops[1].ptr.object_id); + if (it0 != memory_.end() && it1 != memory_.end()) { + // Read haystack string. + size_t hs = static_cast(ops[0].ptr.offset); + size_t hlen = 0; + while (hs + hlen < it0->second.bytes.size() && + it0->second.bytes[hs + hlen] != 0) ++hlen; + // Read needle string. + size_t ns = static_cast(ops[1].ptr.offset); + size_t nlen = 0; + while (ns + nlen < it1->second.bytes.size() && + it1->second.bytes[ns + nlen] != 0) ++nlen; + if (nlen == 0) { + result = ops[0]; // Empty needle: return haystack. + } else { + bool found = false; + for (size_t i = 0; i + nlen <= hlen; ++i) { + if (std::memcmp(it0->second.bytes.data() + hs + i, + it1->second.bytes.data() + ns, nlen) == 0) { + result = Value::Ptr(ops[0].ptr.object_id, + ops[0].ptr.offset + static_cast(i)); + found = true; + break; + } + } + if (!found) { + result = Value::Ptr(mx::kInvalidEntityId, 0); // NULL + } + } + } + } + break; + } + case MO::STRCPY: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + auto it_src = memory_.find(ops[1].ptr.object_id); + if (it_src != memory_.end()) { + size_t ss = static_cast(ops[1].ptr.offset); + size_t ds = static_cast(ops[0].ptr.offset); + Pointer dp = ops[0].ptr; + for (size_t i = 0; ; ++i) { + uint8_t c = (ss + i < it_src->second.bytes.size()) ? it_src->second.bytes[ss + i] : 0; + dp.offset = ops[0].ptr.offset + static_cast(i); + MemWrite(dp, &c, 1); + if (c == 0) break; + } + } + result = ops[0]; // Return dest. + } + break; + } + case MO::STRNCPY: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + size_t n = static_cast(ops[2].as_int()); + auto it_src = memory_.find(ops[1].ptr.object_id); + if (it_src != memory_.end()) { + size_t ss = static_cast(ops[1].ptr.offset); + Pointer dp = ops[0].ptr; + bool hit_null = false; + for (size_t i = 0; i < n; ++i) { + uint8_t c = 0; + if (!hit_null && ss + i < it_src->second.bytes.size()) { + c = it_src->second.bytes[ss + i]; + if (c == 0) hit_null = true; + } + dp.offset = ops[0].ptr.offset + static_cast(i); + MemWrite(dp, &c, 1); + } + } + result = ops[0]; // Return dest. + } + break; + } + case MO::STRCAT: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + // Find end of dest string. + auto it_dst = memory_.find(ops[0].ptr.object_id); + auto it_src = memory_.find(ops[1].ptr.object_id); + if (it_dst != memory_.end() && it_src != memory_.end()) { + size_t ds = static_cast(ops[0].ptr.offset); + size_t dlen = 0; + while (ds + dlen < it_dst->second.bytes.size() && + it_dst->second.bytes[ds + dlen] != 0) ++dlen; + // Copy src after dest's null. + size_t ss = static_cast(ops[1].ptr.offset); + Pointer dp = {ops[0].ptr.object_id, + ops[0].ptr.offset + static_cast(dlen)}; + for (size_t i = 0; ; ++i) { + uint8_t c = (ss + i < it_src->second.bytes.size()) ? it_src->second.bytes[ss + i] : 0; + dp.offset = ops[0].ptr.offset + static_cast(dlen + i); + MemWrite(dp, &c, 1); + if (c == 0) break; + } + } + result = ops[0]; // Return dest. + } + break; + } + case MO::STRNCAT: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + size_t n = static_cast(ops[2].as_int()); + auto it_dst = memory_.find(ops[0].ptr.object_id); + auto it_src = memory_.find(ops[1].ptr.object_id); + if (it_dst != memory_.end() && it_src != memory_.end()) { + size_t ds = static_cast(ops[0].ptr.offset); + size_t dlen = 0; + while (ds + dlen < it_dst->second.bytes.size() && + it_dst->second.bytes[ds + dlen] != 0) ++dlen; + size_t ss = static_cast(ops[1].ptr.offset); + Pointer dp = {ops[0].ptr.object_id, 0}; + size_t i = 0; + for (; i < n; ++i) { + uint8_t c = (ss + i < it_src->second.bytes.size()) ? it_src->second.bytes[ss + i] : 0; + if (c == 0) break; + dp.offset = ops[0].ptr.offset + static_cast(dlen + i); + MemWrite(dp, &c, 1); + } + // Write null terminator. + uint8_t nul = 0; + dp.offset = ops[0].ptr.offset + static_cast(dlen + i); + MemWrite(dp, &nul, 1); + } + result = ops[0]; // Return dest. + } + break; + } + case MO::STPCPY: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + auto it_src = memory_.find(ops[1].ptr.object_id); + if (it_src != memory_.end()) { + size_t ss = static_cast(ops[1].ptr.offset); + Pointer dp = ops[0].ptr; + size_t i = 0; + for (; ; ++i) { + uint8_t c = (ss + i < it_src->second.bytes.size()) ? it_src->second.bytes[ss + i] : 0; + dp.offset = ops[0].ptr.offset + static_cast(i); + MemWrite(dp, &c, 1); + if (c == 0) break; + } + // Return pointer to the null terminator in dest. + result = Value::Ptr(ops[0].ptr.object_id, + ops[0].ptr.offset + static_cast(i)); + } + } + break; + } + case MO::STPNCPY: { + if (ops.size() >= 3 && ops[0].kind == Value::POINTER + && ops[1].kind == Value::POINTER) { + size_t n = static_cast(ops[2].as_int()); + auto it_src = memory_.find(ops[1].ptr.object_id); + if (it_src != memory_.end()) { + size_t ss = static_cast(ops[1].ptr.offset); + Pointer dp = ops[0].ptr; + bool hit_null = false; + size_t null_pos = n; // default: dest+n + for (size_t i = 0; i < n; ++i) { + uint8_t c = 0; + if (!hit_null && ss + i < it_src->second.bytes.size()) { + c = it_src->second.bytes[ss + i]; + if (c == 0) { hit_null = true; null_pos = i; } + } else if (!hit_null) { + hit_null = true; + null_pos = i; + } + dp.offset = ops[0].ptr.offset + static_cast(i); + MemWrite(dp, &c, 1); + } + // Return pointer to null terminator or dest+n. + result = Value::Ptr(ops[0].ptr.object_id, + ops[0].ptr.offset + static_cast(null_pos)); + } + } + break; + } + case MO::STRTOI32: case MO::STRTOI64: + case MO::STRTOU32: case MO::STRTOU64: + case MO::STRTOF32: case MO::STRTOF64: { + if (ops.size() >= 1 && ops[0].kind == Value::POINTER) { + auto it = memory_.find(ops[0].ptr.object_id); + if (it != memory_.end()) { + // Read string bytes into a null-terminated buffer. + size_t start = static_cast(ops[0].ptr.offset); + std::string str; + for (size_t i = start; i < it->second.bytes.size(); ++i) { + if (it->second.bytes[i] == 0) break; + str.push_back(static_cast(it->second.bytes[i])); + } + switch (sub) { + case MO::STRTOI32: + result = Value::Int(static_cast( + std::strtol(str.c_str(), nullptr, 10))); + break; + case MO::STRTOI64: + result = Value::Int(static_cast( + std::strtoll(str.c_str(), nullptr, 10))); + break; + case MO::STRTOU32: + result = Value::Int(static_cast( + std::strtoul(str.c_str(), nullptr, 10))); + break; + case MO::STRTOU64: + result = Value::Int(static_cast( + std::strtoull(str.c_str(), nullptr, 10))); + break; + case MO::STRTOF32: + result = Value::Float(static_cast( + std::strtof(str.c_str(), nullptr))); + break; + case MO::STRTOF64: + result = Value::Float( + std::strtod(str.c_str(), nullptr)); + break; + default: + break; + } + } + } + break; + } + case MO::BIT_READ_LE: case MO::BIT_READ_BE: { + if (ops.size() >= 1 && ops[0].kind == Value::POINTER) { + uint32_t bo = mi->bit_offset(); + uint32_t bw = mi->bit_width(); + // Compute which bytes to read. + uint32_t first_byte = bo / 8; + uint32_t last_byte = (bo + bw - 1) / 8; + uint32_t num_bytes = last_byte - first_byte + 1; + std::vector buf(num_bytes, 0); + Pointer rp = ops[0].ptr; + rp.offset += first_byte; + MemRead(rp, buf.data(), num_bytes); + uint64_t raw = 0; + if (sub == MO::BIT_READ_LE) { + // LE: bit 0 = LSB of byte 0. + for (uint32_t i = 0; i < num_bytes; ++i) { + raw |= static_cast(buf[i]) << (i * 8); + } + // Shift right to remove bits below bit_offset within the + // fetched bytes. + raw >>= (bo % 8); + } else { + // BE: bit 0 = MSB of byte 0. Read bytes MSB-first. + for (uint32_t i = 0; i < num_bytes; ++i) { + raw = (raw << 8) | buf[i]; + } + // Bits are numbered from MSB. The field starts at + // bit bo within the full object. Within the fetched + // window, the field starts at (bo % 8) from the MSB + // of the first byte. + uint32_t top_bits = num_bytes * 8; + uint32_t shift = top_bits - (bo % 8) - bw; + raw >>= shift; + } + // Mask to bit_width. + uint64_t mask = (bw >= 64) ? ~uint64_t{0} : ((uint64_t{1} << bw) - 1); + raw &= mask; + result = Value::Int(static_cast(raw)); + } + break; + } + case MO::BIT_WRITE_LE: case MO::BIT_WRITE_BE: { + if (ops.size() >= 2 && ops[0].kind == Value::POINTER) { + uint32_t bo = mi->bit_offset(); + uint32_t bw = mi->bit_width(); + uint64_t val = static_cast(ops[1].as_int()); + uint64_t mask = (bw >= 64) ? ~uint64_t{0} : ((uint64_t{1} << bw) - 1); + val &= mask; + uint32_t first_byte = bo / 8; + uint32_t last_byte = (bo + bw - 1) / 8; + uint32_t num_bytes = last_byte - first_byte + 1; + std::vector buf(num_bytes, 0); + Pointer rp = ops[0].ptr; + rp.offset += first_byte; + MemRead(rp, buf.data(), num_bytes); + if (sub == MO::BIT_WRITE_LE) { + // LE: assemble bytes as little-endian integer. + uint64_t raw = 0; + for (uint32_t i = 0; i < num_bytes; ++i) { + raw |= static_cast(buf[i]) << (i * 8); + } + uint32_t shift = bo % 8; + raw &= ~(mask << shift); + raw |= (val << shift); + for (uint32_t i = 0; i < num_bytes; ++i) { + buf[i] = static_cast(raw >> (i * 8)); + } + } else { + // BE: assemble bytes as big-endian integer. + uint64_t raw = 0; + for (uint32_t i = 0; i < num_bytes; ++i) { + raw = (raw << 8) | buf[i]; + } + uint32_t top_bits = num_bytes * 8; + uint32_t shift = top_bits - (bo % 8) - bw; + raw &= ~(mask << shift); + raw |= (val << shift); + for (uint32_t i = 0; i < num_bytes; ++i) { + buf[num_bytes - 1 - i] = static_cast(raw >> (i * 8)); + } + } + MemWrite(rp, buf.data(), num_bytes); + } + break; + } + default: + if (mx::ir::IsCmpxchg(sub)) { + // Simplified: return undef (complex semantics). + result = Value::Undef(); + } + break; + } + } + } + break; + } + case mx::ir::OpCode::GEP_FIELD_32: + case mx::ir::OpCode::GEP_FIELD_64: { + if (auto gep = mx::GEPFieldInst::from(inst)) { + Value base = GetValue(gep->base()); + int64_t off = gep->byte_offset(); + if (base.kind == Value::POINTER) { + result = Value::Ptr(base.ptr.object_id, base.ptr.offset + off); + } + } + break; + } + case mx::ir::OpCode::PTR_ADD_32: + case mx::ir::OpCode::PTR_ADD_64: { + if (auto pa = mx::PtrAddInst::from(inst)) { + Value base = GetValue(pa->base()); + Value idx = GetValue(pa->index()); + int64_t elem_size = pa->element_size(); + if (base.kind == Value::POINTER) { + result = Value::Ptr(base.ptr.object_id, + base.ptr.offset + idx.as_int() * elem_size); + } + } + break; + } + + // --- Integer binary arithmetic (width-correct) --- + case mx::ir::OpCode::ADD_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) + static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::ADD_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) + static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::ADD_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) + static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::ADD_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() + GetValue(bin->rhs()).as_int()); + break; + } + case mx::ir::OpCode::SUB_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) - static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::SUB_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) - static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::SUB_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) - static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::SUB_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() - GetValue(bin->rhs()).as_int()); + break; + } + case mx::ir::OpCode::MUL_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) * static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::MUL_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) * static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::MUL_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) * static_cast(GetValue(bin->rhs()).as_int()))); + break; + } + case mx::ir::OpCode::MUL_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() * GetValue(bin->rhs()).as_int()); + break; + } + case mx::ir::OpCode::DIV_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int8_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(r ? static_cast(static_cast(GetValue(bin->lhs()).as_int()) / r) : 0); + } + break; + } + case mx::ir::OpCode::DIV_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int16_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(r ? static_cast(static_cast(GetValue(bin->lhs()).as_int()) / r) : 0); + } + break; + } + case mx::ir::OpCode::DIV_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int32_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(r ? static_cast(static_cast(GetValue(bin->lhs()).as_int()) / r) : 0); + } + break; + } + case mx::ir::OpCode::DIV_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int64_t r = GetValue(bin->rhs()).as_int(); + result = Value::Int(r != 0 ? GetValue(bin->lhs()).as_int() / r : 0); + } + break; + } + case mx::ir::OpCode::REM_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int8_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(r ? static_cast(static_cast(GetValue(bin->lhs()).as_int()) % r) : 0); + } + break; + } + case mx::ir::OpCode::REM_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int16_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(r ? static_cast(static_cast(GetValue(bin->lhs()).as_int()) % r) : 0); + } + break; + } + case mx::ir::OpCode::REM_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int32_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(r ? static_cast(static_cast(GetValue(bin->lhs()).as_int()) % r) : 0); + } + break; + } + case mx::ir::OpCode::REM_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + int64_t r = GetValue(bin->rhs()).as_int(); + result = Value::Int(r != 0 ? GetValue(bin->lhs()).as_int() % r : 0); + } + break; + } + + // --- Float binary arithmetic --- + case mx::ir::OpCode::FADD_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(static_cast(GetValue(bin->lhs()).as_float()) + static_cast(GetValue(bin->rhs()).as_float())); + break; + } + case mx::ir::OpCode::FADD_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(GetValue(bin->lhs()).as_float() + GetValue(bin->rhs()).as_float()); + break; + } + case mx::ir::OpCode::FSUB_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(static_cast(GetValue(bin->lhs()).as_float()) - static_cast(GetValue(bin->rhs()).as_float())); + break; + } + case mx::ir::OpCode::FSUB_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(GetValue(bin->lhs()).as_float() - GetValue(bin->rhs()).as_float()); + break; + } + case mx::ir::OpCode::FMUL_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(static_cast(GetValue(bin->lhs()).as_float()) * static_cast(GetValue(bin->rhs()).as_float())); + break; + } + case mx::ir::OpCode::FMUL_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(GetValue(bin->lhs()).as_float() * GetValue(bin->rhs()).as_float()); + break; + } + case mx::ir::OpCode::FDIV_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(static_cast(GetValue(bin->lhs()).as_float()) / static_cast(GetValue(bin->rhs()).as_float())); + break; + } + case mx::ir::OpCode::FDIV_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(GetValue(bin->lhs()).as_float() / GetValue(bin->rhs()).as_float()); + break; + } + case mx::ir::OpCode::FREM_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(std::fmodf(static_cast(GetValue(bin->lhs()).as_float()), static_cast(GetValue(bin->rhs()).as_float()))); + break; + } + case mx::ir::OpCode::FREM_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Float(std::fmod(GetValue(bin->lhs()).as_float(), GetValue(bin->rhs()).as_float())); + break; + } + case mx::ir::OpCode::BIT_AND_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() & GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_AND_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() & GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_AND_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() & GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_AND_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() & GetValue(bin->rhs()).as_int()); + break; + } + case mx::ir::OpCode::BIT_OR_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() | GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_OR_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() | GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_OR_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() | GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_OR_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() | GetValue(bin->rhs()).as_int()); + break; + } + case mx::ir::OpCode::BIT_XOR_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() ^ GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_XOR_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() ^ GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_XOR_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int() ^ GetValue(bin->rhs()).as_int())); + break; + } + case mx::ir::OpCode::BIT_XOR_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() ^ GetValue(bin->rhs()).as_int()); + break; + } + case mx::ir::OpCode::SHL_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) << (GetValue(bin->rhs()).as_int() & 7))); + break; + } + case mx::ir::OpCode::SHL_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) << (GetValue(bin->rhs()).as_int() & 15))); + break; + } + case mx::ir::OpCode::SHL_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) << (GetValue(bin->rhs()).as_int() & 31))); + break; + } + case mx::ir::OpCode::SHL_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() << (GetValue(bin->rhs()).as_int() & 63)); + break; + } + case mx::ir::OpCode::SHR_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int()) >> (GetValue(bin->rhs()).as_int() & 7)); + break; + } + case mx::ir::OpCode::SHR_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int()) >> (GetValue(bin->rhs()).as_int() & 15)); + break; + } + case mx::ir::OpCode::SHR_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(GetValue(bin->lhs()).as_int()) >> (GetValue(bin->rhs()).as_int() & 31)); + break; + } + case mx::ir::OpCode::SHR_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(GetValue(bin->lhs()).as_int() >> (GetValue(bin->rhs()).as_int() & 63)); + break; + } + // Unsigned arithmetic: per-width cases. + case mx::ir::OpCode::UDIV_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint8_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint8_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l / r : 0)); + } + break; + } + case mx::ir::OpCode::UDIV_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint16_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint16_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l / r : 0)); + } + break; + } + case mx::ir::OpCode::UDIV_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint32_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint32_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l / r : 0)); + } + break; + } + case mx::ir::OpCode::UDIV_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint64_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint64_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l / r : 0)); + } + break; + } + case mx::ir::OpCode::UREM_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint8_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint8_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l % r : 0)); + } + break; + } + case mx::ir::OpCode::UREM_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint16_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint16_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l % r : 0)); + } + break; + } + case mx::ir::OpCode::UREM_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint32_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint32_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l % r : 0)); + } + break; + } + case mx::ir::OpCode::UREM_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + uint64_t l = static_cast(GetValue(bin->lhs()).as_int()); + uint64_t r = static_cast(GetValue(bin->rhs()).as_int()); + result = Value::Int(static_cast(r ? l % r : 0)); + } + break; + } + case mx::ir::OpCode::USHR_8: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) >> (GetValue(bin->rhs()).as_int() & 7))); + break; + } + case mx::ir::OpCode::USHR_16: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) >> (GetValue(bin->rhs()).as_int() & 15))); + break; + } + case mx::ir::OpCode::USHR_32: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) >> (GetValue(bin->rhs()).as_int() & 31))); + break; + } + case mx::ir::OpCode::USHR_64: { + auto bin = mx::BinaryInst::from(inst); + if (bin) result = Value::Int(static_cast(static_cast(GetValue(bin->lhs()).as_int()) >> (GetValue(bin->rhs()).as_int() & 63))); + break; + } + case mx::ir::OpCode::LOGICAL_AND: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + // Short-circuit: IR keeps both sides evaluated in the tree. + // The conditionally-executed flag handles the real short-circuit. + bool l = GetValue(bin->lhs()).is_truthy(); + bool r = GetValue(bin->rhs()).is_truthy(); + result = Value::Int(l && r ? 1 : 0); + } + break; + } + case mx::ir::OpCode::LOGICAL_OR: { + auto bin = mx::BinaryInst::from(inst); + if (bin) { + bool l = GetValue(bin->lhs()).is_truthy(); + bool r = GetValue(bin->rhs()).is_truthy(); + result = Value::Int(l || r ? 1 : 0); + } + break; + } + case mx::ir::OpCode::PTR_DIFF_32: + case mx::ir::OpCode::PTR_DIFF_64: { + auto pd = mx::PtrDiffInst::from(inst); + if (pd) { + Value l = GetValue(pd->lhs()), r = GetValue(pd->rhs()); + if (l.kind == Value::POINTER && r.kind == Value::POINTER) { + int64_t byte_diff = l.ptr.offset - r.ptr.offset; + int64_t elem_size = pd->element_size(); + if (elem_size <= 0) elem_size = 1; + result = Value::Int(byte_diff / elem_size); + } + } + break; + } + + // --- Signed equality (width-correct) --- + case mx::ir::OpCode::CMP_EQ_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id == rp.object_id && lp.offset == rp.offset) ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) == static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_EQ_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id == rp.object_id && lp.offset == rp.offset) ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) == static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_EQ_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id == rp.object_id && lp.offset == rp.offset) ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) == static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_EQ_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id == rp.object_id && lp.offset == rp.offset) ? 1 : 0); + } else { + result = Value::Int(l.as_int() == r.as_int() ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_NE_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id != rp.object_id || lp.offset != rp.offset) ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) != static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_NE_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id != rp.object_id || lp.offset != rp.offset) ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) != static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_NE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id != rp.object_id || lp.offset != rp.offset) ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) != static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_NE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + result = Value::Int((lp.object_id != rp.object_id || lp.offset != rp.offset) ? 1 : 0); + } else { + result = Value::Int(l.as_int() != r.as_int() ? 1 : 0); + } + } + break; + } + // --- Signed ordering (width-correct) --- + case mx::ir::OpCode::CMP_LT_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) < static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_LT_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) < static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_LT_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) < static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_LT_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(l.as_int() < r.as_int() ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_LE_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) <= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_LE_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) <= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_LE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) <= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_LE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(l.as_int() <= r.as_int() ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GT_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) > static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GT_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) > static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GT_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) > static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GT_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(l.as_int() > r.as_int() ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GE_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) >= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GE_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) >= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) >= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::CMP_GE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(l.as_int() >= r.as_int() ? 1 : 0); + } + } + break; + } + // --- Unsigned ordering (width-correct) --- + case mx::ir::OpCode::UCMP_LT_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) < static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_LT_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) < static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_LT_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) < static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_LT_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval < rval ? 1 : 0); + } else { + result = Value::Int(l.as_uint() < r.as_uint() ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_LE_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) <= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_LE_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) <= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_LE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) <= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_LE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval <= rval ? 1 : 0); + } else { + result = Value::Int(l.as_uint() <= r.as_uint() ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GT_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) > static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GT_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) > static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GT_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) > static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GT_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval > rval ? 1 : 0); + } else { + result = Value::Int(l.as_uint() > r.as_uint() ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GE_8: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) >= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GE_16: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) >= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(static_cast(l.as_int()) >= static_cast(r.as_int()) ? 1 : 0); + } + } + break; + } + case mx::ir::OpCode::UCMP_GE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) { + Value l = GetValue(cmp->lhs()), r = GetValue(cmp->rhs()); + if (l.kind == Value::POINTER || r.kind == Value::POINTER) { + auto lp = l.kind == Value::POINTER ? l.ptr : Pointer{0, l.as_int()}; + auto rp = r.kind == Value::POINTER ? r.ptr : Pointer{0, r.as_int()}; + auto lval = (lp.object_id == rp.object_id) ? lp.offset : static_cast(lp.object_id); + auto rval = (lp.object_id == rp.object_id) ? rp.offset : static_cast(rp.object_id); + result = Value::Int(lval >= rval ? 1 : 0); + } else { + result = Value::Int(l.as_uint() >= r.as_uint() ? 1 : 0); + } + } + break; + } + // --- Float comparisons --- + case mx::ir::OpCode::FCMP_EQ_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(static_cast(GetValue(cmp->lhs()).as_float()) == static_cast(GetValue(cmp->rhs()).as_float()) ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_EQ_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(GetValue(cmp->lhs()).as_float() == GetValue(cmp->rhs()).as_float() ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_NE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(static_cast(GetValue(cmp->lhs()).as_float()) != static_cast(GetValue(cmp->rhs()).as_float()) ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_NE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(GetValue(cmp->lhs()).as_float() != GetValue(cmp->rhs()).as_float() ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_LT_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(static_cast(GetValue(cmp->lhs()).as_float()) < static_cast(GetValue(cmp->rhs()).as_float()) ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_LT_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(GetValue(cmp->lhs()).as_float() < GetValue(cmp->rhs()).as_float() ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_LE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(static_cast(GetValue(cmp->lhs()).as_float()) <= static_cast(GetValue(cmp->rhs()).as_float()) ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_LE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(GetValue(cmp->lhs()).as_float() <= GetValue(cmp->rhs()).as_float() ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_GT_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(static_cast(GetValue(cmp->lhs()).as_float()) > static_cast(GetValue(cmp->rhs()).as_float()) ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_GT_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(GetValue(cmp->lhs()).as_float() > GetValue(cmp->rhs()).as_float() ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_GE_32: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(static_cast(GetValue(cmp->lhs()).as_float()) >= static_cast(GetValue(cmp->rhs()).as_float()) ? 1 : 0); + break; + } + case mx::ir::OpCode::FCMP_GE_64: { + auto cmp = mx::ComparisonInst::from(inst); + if (cmp) result = Value::Int(GetValue(cmp->lhs()).as_float() >= GetValue(cmp->rhs()).as_float() ? 1 : 0); + break; + } + + // --- Unary --- + case mx::ir::OpCode::NEG_8: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(static_cast(-static_cast(GetValue(u->operand()).as_int()))); + break; + } + case mx::ir::OpCode::NEG_16: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(static_cast(-static_cast(GetValue(u->operand()).as_int()))); + break; + } + case mx::ir::OpCode::NEG_32: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(static_cast(-static_cast(GetValue(u->operand()).as_int()))); + break; + } + case mx::ir::OpCode::NEG_64: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(-GetValue(u->operand()).as_int()); + break; + } + case mx::ir::OpCode::FNEG_32: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Float(-static_cast(GetValue(u->operand()).as_float())); + break; + } + case mx::ir::OpCode::FNEG_64: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Float(-GetValue(u->operand()).as_float()); + break; + } + case mx::ir::OpCode::BIT_NOT_8: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(static_cast(~static_cast(GetValue(u->operand()).as_int()))); + break; + } + case mx::ir::OpCode::BIT_NOT_16: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(static_cast(~static_cast(GetValue(u->operand()).as_int()))); + break; + } + case mx::ir::OpCode::BIT_NOT_32: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(static_cast(~static_cast(GetValue(u->operand()).as_int()))); + break; + } + case mx::ir::OpCode::BIT_NOT_64: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(~GetValue(u->operand()).as_int()); + break; + } + case mx::ir::OpCode::LOGICAL_NOT: { + auto u = mx::UnaryInst::from(inst); + if (u) result = Value::Int(GetValue(u->operand()).is_truthy() ? 0 : 1); + break; + } + + // --- Casts --- + case mx::ir::OpCode::CAST: { + auto c = mx::CastInst::from(inst); + if (c) { + auto sub = c->sub_opcode(); + Value v = GetValue(c->operand()); + if (sub == mx::ir::CastOp::IDENTITY) { + result = v; + } else if (sub == mx::ir::CastOp::BITCAST) { + // Reinterpret bits: float↔int of same size. + if (v.kind == Value::FLOATING) { + // float/double bits → int + int64_t bits; + std::memcpy(&bits, &v.fval, sizeof(bits)); + result = Value::Int(bits); + } else if (v.kind == Value::INTEGER) { + // int bits → float/double + double fv; + std::memcpy(&fv, &v.ival, sizeof(fv)); + result = Value::Float(fv); + } else { + result = v; + } + } else if (sub == mx::ir::CastOp::PTR_TO_I32) { + int64_t iv = v.kind == Value::POINTER ? v.ptr.offset : v.ival; + result = Value::Int(static_cast(iv)); + } else if (sub == mx::ir::CastOp::PTR_TO_I64) { + result = Value::Int(v.kind == Value::POINTER ? v.ptr.offset : v.ival); + } else if (sub == mx::ir::CastOp::I32_TO_PTR) { + result = Value::Ptr(mx::kInvalidEntityId, static_cast(v.as_int())); + } else if (sub == mx::ir::CastOp::I64_TO_PTR) { + result = Value::Ptr(mx::kInvalidEntityId, v.as_int()); + } else if (mx::ir::IsFloatToInt(sub)) { + double fv; + if (v.kind == Value::FLOATING) { + fv = v.fval; + } else { + uint64_t bits = static_cast(v.ival); + std::memcpy(&fv, &bits, sizeof(fv)); + } + // Use float precision for F32_TO_* sources. + if (sub >= mx::ir::CastOp::F32_TO_SI8 && + sub <= mx::ir::CastOp::F32_TO_SI64) { + fv = static_cast(fv); + } else if (sub >= mx::ir::CastOp::F32_TO_UI8 && + sub <= mx::ir::CastOp::F32_TO_UI64) { + fv = static_cast(fv); + } + switch (sub) { + case mx::ir::CastOp::F32_TO_SI8: case mx::ir::CastOp::F64_TO_SI8: + result = Value::Int(static_cast(fv)); break; + case mx::ir::CastOp::F32_TO_SI16: case mx::ir::CastOp::F64_TO_SI16: + result = Value::Int(static_cast(fv)); break; + case mx::ir::CastOp::F32_TO_SI32: case mx::ir::CastOp::F64_TO_SI32: + result = Value::Int(static_cast(fv)); break; + case mx::ir::CastOp::F32_TO_SI64: case mx::ir::CastOp::F64_TO_SI64: + result = Value::Int(static_cast(fv)); break; + case mx::ir::CastOp::F32_TO_UI8: case mx::ir::CastOp::F64_TO_UI8: + result = Value::Int(static_cast(static_cast(fv))); break; + case mx::ir::CastOp::F32_TO_UI16: case mx::ir::CastOp::F64_TO_UI16: + result = Value::Int(static_cast(static_cast(fv))); break; + case mx::ir::CastOp::F32_TO_UI32: case mx::ir::CastOp::F64_TO_UI32: + result = Value::Int(static_cast(static_cast(fv))); break; + case mx::ir::CastOp::F32_TO_UI64: case mx::ir::CastOp::F64_TO_UI64: + result = Value::Int(static_cast(static_cast(fv))); break; + default: + result = Value::Int(static_cast(fv)); break; + } + } else if (mx::ir::IsIntToFloat(sub)) { + // Width-correct int→float: cast to source width, then to float/double. + switch (sub) { + case mx::ir::CastOp::SI8_TO_F32: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::SI8_TO_F64: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::SI16_TO_F32: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::SI16_TO_F64: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::SI32_TO_F32: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::SI32_TO_F64: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::SI64_TO_F32: + result = Value::Float(static_cast(v.as_int())); break; + case mx::ir::CastOp::SI64_TO_F64: + result = Value::Float(static_cast(v.as_int())); break; + case mx::ir::CastOp::UI8_TO_F32: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::UI8_TO_F64: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::UI16_TO_F32: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::UI16_TO_F64: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::UI32_TO_F32: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::UI32_TO_F64: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::UI64_TO_F32: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + case mx::ir::CastOp::UI64_TO_F64: + result = Value::Float(static_cast(static_cast(v.as_int()))); break; + default: + result = Value::Float(static_cast(v.as_int())); break; + } + } else if (sub == mx::ir::CastOp::F64_TO_F32) { + double fv; + if (v.kind == Value::FLOATING) { + fv = v.fval; + } else { + uint64_t bits = static_cast(v.ival); + std::memcpy(&fv, &bits, sizeof(fv)); + } + result = Value::Float(static_cast(fv)); + } else if (sub == mx::ir::CastOp::F32_TO_F64) { + if (v.kind == Value::FLOATING) { + result = Value::Float(v.fval); // already double internally + } else { + float fv; + uint32_t bits = static_cast(v.ival); + std::memcpy(&fv, &bits, sizeof(fv)); + result = Value::Float(static_cast(fv)); + } + } else if (mx::ir::IsSignExtend(sub)) { + // Sign-extend: cast to source signed type to get correct sign. + int64_t iv = v.as_int(); + switch (sub) { + case mx::ir::CastOp::SEXT_I8_I16: + case mx::ir::CastOp::SEXT_I8_I32: + case mx::ir::CastOp::SEXT_I8_I64: + iv = static_cast(iv); + break; + case mx::ir::CastOp::SEXT_I16_I32: + case mx::ir::CastOp::SEXT_I16_I64: + iv = static_cast(iv); + break; + case mx::ir::CastOp::SEXT_I32_I64: + iv = static_cast(iv); + break; + default: break; + } + result = Value::Int(iv); + } else if (mx::ir::IsZeroExtend(sub)) { + // Zero-extend: mask to source width (undoing sign-extension from LOAD). + int64_t iv = v.as_int(); + switch (sub) { + case mx::ir::CastOp::ZEXT_I8_I16: + case mx::ir::CastOp::ZEXT_I8_I32: + case mx::ir::CastOp::ZEXT_I8_I64: + iv = iv & 0xFF; + break; + case mx::ir::CastOp::ZEXT_I16_I32: + case mx::ir::CastOp::ZEXT_I16_I64: + iv = iv & 0xFFFF; + break; + case mx::ir::CastOp::ZEXT_I32_I64: + iv = iv & 0xFFFFFFFF; + break; + default: break; + } + result = Value::Int(iv); + } else if (mx::ir::IsTruncate(sub)) { + int64_t iv = v.as_int(); + switch (sub) { + case mx::ir::CastOp::TRUNC_I16_I8: + case mx::ir::CastOp::TRUNC_I32_I8: + case mx::ir::CastOp::TRUNC_I64_I8: + iv = static_cast(iv); + break; + case mx::ir::CastOp::TRUNC_I32_I16: + case mx::ir::CastOp::TRUNC_I64_I16: + iv = static_cast(iv); + break; + case mx::ir::CastOp::TRUNC_I64_I32: + iv = static_cast(iv); + break; + default: break; + } + result = Value::Int(iv); + } else { + // Other int-to-int casts. + result = Value::Int(v.as_int()); + } + } + break; + } + + // --- Read-modify-write (inc/dec, compound assign) --- + case mx::ir::OpCode::READ_MODIFY_WRITE: { + if (auto rmw = mx::ReadModifyWriteInst::from(inst)) { + Value addr = GetValue(rmw->address()); + if (addr.kind == Value::POINTER) { + // Determine access size from the object. + size_t access_sz = 8; + auto it = memory_.find(addr.ptr.object_id); + if (it != memory_.end() && it->second.bytes.size() <= 8) { + access_sz = it->second.bytes.size(); + } + // Determine if the underlying op is float to read correctly. + auto underlying = rmw->underlying_op(); + bool rmw_is_float = mx::ir::IsFloatArithmetic(underlying); + Value old_val = MemReadValue(addr.ptr, access_sz, rmw_is_float); + // Collect RHS operands (typically one value). + Value rhs = Value::Int(0); + for (auto rhs_op : rmw->rhs_operands()) { + rhs = GetValue(rhs_op); + break; // Use first RHS operand. + } + Value new_val; + switch (underlying) { + case mx::ir::OpCode::ADD_8: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) + static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ADD_16: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) + static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ADD_32: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) + static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ADD_64: + new_val = Value::Int(old_val.as_int() + rhs.as_int()); break; + case mx::ir::OpCode::SUB_8: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) - static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::SUB_16: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) - static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::SUB_32: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) - static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::SUB_64: + new_val = Value::Int(old_val.as_int() - rhs.as_int()); break; + case mx::ir::OpCode::MUL_8: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) * static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::MUL_16: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) * static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::MUL_32: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) * static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::MUL_64: + new_val = Value::Int(old_val.as_int() * rhs.as_int()); break; + case mx::ir::OpCode::DIV_8: { + int8_t r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? static_cast(static_cast(old_val.as_int()) / r) : 0); break; + } + case mx::ir::OpCode::DIV_16: { + int16_t r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? static_cast(static_cast(old_val.as_int()) / r) : 0); break; + } + case mx::ir::OpCode::DIV_32: { + int32_t r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? static_cast(static_cast(old_val.as_int()) / r) : 0); break; + } + case mx::ir::OpCode::DIV_64: + new_val = Value::Int(rhs.as_int() ? old_val.as_int() / rhs.as_int() : 0); break; + case mx::ir::OpCode::REM_8: { + int8_t r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? static_cast(static_cast(old_val.as_int()) % r) : 0); break; + } + case mx::ir::OpCode::REM_16: { + int16_t r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? static_cast(static_cast(old_val.as_int()) % r) : 0); break; + } + case mx::ir::OpCode::REM_32: { + int32_t r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? static_cast(static_cast(old_val.as_int()) % r) : 0); break; + } + case mx::ir::OpCode::REM_64: + new_val = Value::Int(rhs.as_int() ? old_val.as_int() % rhs.as_int() : 0); break; + case mx::ir::OpCode::BIT_AND_8: + new_val = Value::Int(static_cast(old_val.as_int() & rhs.as_int())); break; + case mx::ir::OpCode::BIT_AND_16: + new_val = Value::Int(static_cast(old_val.as_int() & rhs.as_int())); break; + case mx::ir::OpCode::BIT_AND_32: + new_val = Value::Int(static_cast(old_val.as_int() & rhs.as_int())); break; + case mx::ir::OpCode::BIT_AND_64: + new_val = Value::Int(old_val.as_int() & rhs.as_int()); break; + case mx::ir::OpCode::BIT_OR_8: + new_val = Value::Int(static_cast(old_val.as_int() | rhs.as_int())); break; + case mx::ir::OpCode::BIT_OR_16: + new_val = Value::Int(static_cast(old_val.as_int() | rhs.as_int())); break; + case mx::ir::OpCode::BIT_OR_32: + new_val = Value::Int(static_cast(old_val.as_int() | rhs.as_int())); break; + case mx::ir::OpCode::BIT_OR_64: + new_val = Value::Int(old_val.as_int() | rhs.as_int()); break; + case mx::ir::OpCode::BIT_XOR_8: + new_val = Value::Int(static_cast(old_val.as_int() ^ rhs.as_int())); break; + case mx::ir::OpCode::BIT_XOR_16: + new_val = Value::Int(static_cast(old_val.as_int() ^ rhs.as_int())); break; + case mx::ir::OpCode::BIT_XOR_32: + new_val = Value::Int(static_cast(old_val.as_int() ^ rhs.as_int())); break; + case mx::ir::OpCode::BIT_XOR_64: + new_val = Value::Int(old_val.as_int() ^ rhs.as_int()); break; + case mx::ir::OpCode::SHL_8: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) << (rhs.as_int() & 7))); break; + case mx::ir::OpCode::SHL_16: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) << (rhs.as_int() & 15))); break; + case mx::ir::OpCode::SHL_32: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) << (rhs.as_int() & 31))); break; + case mx::ir::OpCode::SHL_64: + new_val = Value::Int(old_val.as_int() << (rhs.as_int() & 63)); break; + case mx::ir::OpCode::SHR_8: + new_val = Value::Int(static_cast(old_val.as_int()) >> (rhs.as_int() & 7)); break; + case mx::ir::OpCode::SHR_16: + new_val = Value::Int(static_cast(old_val.as_int()) >> (rhs.as_int() & 15)); break; + case mx::ir::OpCode::SHR_32: + new_val = Value::Int(static_cast(old_val.as_int()) >> (rhs.as_int() & 31)); break; + case mx::ir::OpCode::SHR_64: + new_val = Value::Int(old_val.as_int() >> (rhs.as_int() & 63)); break; + case mx::ir::OpCode::UDIV_8: { + uint8_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? l / r : 0); break; + } + case mx::ir::OpCode::UDIV_16: { + uint16_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? l / r : 0); break; + } + case mx::ir::OpCode::UDIV_32: { + uint32_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? l / r : 0); break; + } + case mx::ir::OpCode::UDIV_64: { + uint64_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(static_cast(r ? l / r : 0)); break; + } + case mx::ir::OpCode::UREM_8: { + uint8_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? l % r : 0); break; + } + case mx::ir::OpCode::UREM_16: { + uint16_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? l % r : 0); break; + } + case mx::ir::OpCode::UREM_32: { + uint32_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(r ? l % r : 0); break; + } + case mx::ir::OpCode::UREM_64: { + uint64_t l = static_cast(old_val.as_int()), r = static_cast(rhs.as_int()); + new_val = Value::Int(static_cast(r ? l % r : 0)); break; + } + case mx::ir::OpCode::USHR_8: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) >> (rhs.as_int() & 7))); break; + case mx::ir::OpCode::USHR_16: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) >> (rhs.as_int() & 15))); break; + case mx::ir::OpCode::USHR_32: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) >> (rhs.as_int() & 31))); break; + case mx::ir::OpCode::USHR_64: + new_val = Value::Int(static_cast( + static_cast(old_val.as_int()) >> (rhs.as_int() & 63))); break; + case mx::ir::OpCode::ATOMIC_ADD_8: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) + static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_ADD_16: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) + static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_ADD_32: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) + static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_ADD_64: + new_val = Value::Int(old_val.as_int() + rhs.as_int()); break; + case mx::ir::OpCode::ATOMIC_SUB_8: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) - static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_SUB_16: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) - static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_SUB_32: + new_val = Value::Int(static_cast(static_cast(old_val.as_int()) - static_cast(rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_SUB_64: + new_val = Value::Int(old_val.as_int() - rhs.as_int()); break; + case mx::ir::OpCode::ATOMIC_AND_8: + new_val = Value::Int(static_cast(old_val.as_int() & rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_AND_16: + new_val = Value::Int(static_cast(old_val.as_int() & rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_AND_32: + new_val = Value::Int(static_cast(old_val.as_int() & rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_AND_64: + new_val = Value::Int(old_val.as_int() & rhs.as_int()); break; + case mx::ir::OpCode::ATOMIC_OR_8: + new_val = Value::Int(static_cast(old_val.as_int() | rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_OR_16: + new_val = Value::Int(static_cast(old_val.as_int() | rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_OR_32: + new_val = Value::Int(static_cast(old_val.as_int() | rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_OR_64: + new_val = Value::Int(old_val.as_int() | rhs.as_int()); break; + case mx::ir::OpCode::ATOMIC_XOR_8: + new_val = Value::Int(static_cast(old_val.as_int() ^ rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_XOR_16: + new_val = Value::Int(static_cast(old_val.as_int() ^ rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_XOR_32: + new_val = Value::Int(static_cast(old_val.as_int() ^ rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_XOR_64: + new_val = Value::Int(old_val.as_int() ^ rhs.as_int()); break; + case mx::ir::OpCode::ATOMIC_NAND_8: + new_val = Value::Int(static_cast(~(old_val.as_int() & rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_NAND_16: + new_val = Value::Int(static_cast(~(old_val.as_int() & rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_NAND_32: + new_val = Value::Int(static_cast(~(old_val.as_int() & rhs.as_int()))); break; + case mx::ir::OpCode::ATOMIC_NAND_64: + new_val = Value::Int(~(old_val.as_int() & rhs.as_int())); break; + case mx::ir::OpCode::ATOMIC_EXCHANGE_8: case mx::ir::OpCode::ATOMIC_EXCHANGE_16: + case mx::ir::OpCode::ATOMIC_EXCHANGE_32: case mx::ir::OpCode::ATOMIC_EXCHANGE_64: + new_val = rhs; break; + // Float compound assign (+=, -=, *=, /=, %=). + case mx::ir::OpCode::FADD_32: + new_val = Value::Float(static_cast(old_val.as_float()) + static_cast(rhs.as_float())); break; + case mx::ir::OpCode::FADD_64: + new_val = Value::Float(old_val.as_float() + rhs.as_float()); break; + case mx::ir::OpCode::FSUB_32: + new_val = Value::Float(static_cast(old_val.as_float()) - static_cast(rhs.as_float())); break; + case mx::ir::OpCode::FSUB_64: + new_val = Value::Float(old_val.as_float() - rhs.as_float()); break; + case mx::ir::OpCode::FMUL_32: + new_val = Value::Float(static_cast(old_val.as_float()) * static_cast(rhs.as_float())); break; + case mx::ir::OpCode::FMUL_64: + new_val = Value::Float(old_val.as_float() * rhs.as_float()); break; + case mx::ir::OpCode::FDIV_32: + new_val = Value::Float(static_cast(old_val.as_float()) / static_cast(rhs.as_float())); break; + case mx::ir::OpCode::FDIV_64: + new_val = Value::Float(old_val.as_float() / rhs.as_float()); break; + case mx::ir::OpCode::FREM_32: + new_val = Value::Float(std::fmodf(static_cast(old_val.as_float()), static_cast(rhs.as_float()))); break; + case mx::ir::OpCode::FREM_64: + new_val = Value::Float(std::fmod(old_val.as_float(), rhs.as_float())); break; + case mx::ir::OpCode::PTR_ADD_32: case mx::ir::OpCode::PTR_ADD_64: { + int64_t elem_sz = rmw->element_size(); + if (elem_sz <= 0) elem_sz = 1; + if (old_val.kind == Value::POINTER) { + new_val = Value::Ptr(old_val.ptr.object_id, + old_val.ptr.offset + rhs.as_int() * elem_sz); + } else { + new_val = Value::Int(old_val.as_int() + rhs.as_int() * elem_sz); + } + break; + } + // Overflow-checked arithmetic: RMW stores the result, returns + // the overflow flag (bool). + case mx::ir::OpCode::ADD_OVERFLOW_8: case mx::ir::OpCode::ADD_OVERFLOW_16: + case mx::ir::OpCode::ADD_OVERFLOW_32: case mx::ir::OpCode::ADD_OVERFLOW_64: + case mx::ir::OpCode::SUB_OVERFLOW_8: case mx::ir::OpCode::SUB_OVERFLOW_16: + case mx::ir::OpCode::SUB_OVERFLOW_32: case mx::ir::OpCode::SUB_OVERFLOW_64: + case mx::ir::OpCode::MUL_OVERFLOW_8: case mx::ir::OpCode::MUL_OVERFLOW_16: + case mx::ir::OpCode::MUL_OVERFLOW_32: case mx::ir::OpCode::MUL_OVERFLOW_64: { + Value a = Value::Int(0), b = Value::Int(0); + int rhs_i = 0; + for (auto rhs_op : rmw->rhs_operands()) { + if (rhs_i == 0) a = GetValue(rhs_op); + else if (rhs_i == 1) b = GetValue(rhs_op); + ++rhs_i; + } + __int128 wide; + if (underlying >= mx::ir::OpCode::ADD_OVERFLOW_8 && + underlying <= mx::ir::OpCode::ADD_OVERFLOW_64) + wide = static_cast<__int128>(a.as_int()) + static_cast<__int128>(b.as_int()); + else if (underlying >= mx::ir::OpCode::SUB_OVERFLOW_8 && + underlying <= mx::ir::OpCode::SUB_OVERFLOW_64) + wide = static_cast<__int128>(a.as_int()) - static_cast<__int128>(b.as_int()); + else + wide = static_cast<__int128>(a.as_int()) * static_cast<__int128>(b.as_int()); + new_val = Value::Int(static_cast(wide)); + bool overflow = (wide != static_cast<__int128>(static_cast(wide))); + MemWriteValue(addr.ptr, new_val, access_sz); + result = Value::Int(overflow ? 1 : 0); + break; + } + default: new_val = old_val; break; + } + if (!(underlying >= mx::ir::OpCode::ADD_OVERFLOW_8 && + underlying <= mx::ir::OpCode::MUL_OVERFLOW_64)) { + MemWriteValue(addr.ptr, new_val, access_sz); + result = rmw->returns_new_value() ? new_val : old_val; + } + } + } + break; + } + + // --- Call --- + case mx::ir::OpCode::CALL: { + if (auto ci = mx::CallInst::from(inst)) { + // Collect argument values. + std::vector call_args; + for (auto arg : ci->arguments()) { + call_args.push_back(GetValue(arg)); + } + + auto target = ci->target(); + if (target) { + // Try to find IR for the callee. + auto callee_ir = mx::IRFunction::from(*target); + if (callee_ir) { + if (trace_) { + std::cerr << " >> Entering call to " << target->name() << "\n"; + } + Interpreter callee_interp(*callee_ir, trace_); + result = callee_interp.Run(call_args); + if (trace_) { + std::cerr << " << Returned from " << target->name() << "\n"; + } + } else { + LOG(INFO) << "CALL to " << target->name() + << " (no IR available, returning undef)"; + } + } else { + LOG(INFO) << "Indirect CALL (not interpreted)"; + } + } + break; + } + + // --- Select (ternary) --- + case mx::ir::OpCode::SELECT: { + if (auto sel = mx::SelectInst::from(inst)) { + Value cond = GetValue(sel->condition()); + result = cond.is_truthy() ? GetValue(sel->true_value()) + : GetValue(sel->false_value()); + } + break; + } + + // --- Last value (comma operator) --- + case mx::ir::OpCode::LAST_VALUE: { + // All operands already evaluated (post-order). Return the last. + if (auto lv = mx::LastValueInst::from(inst)) { + result = GetValue(lv->last()); + } + break; + } + + + // --- Param pointer --- + case mx::ir::OpCode::PARAM_PTR_32: + case mx::ir::OpCode::PARAM_PTR_64: { + if (auto pr = mx::ParamPtrInst::from(inst)) { + uint32_t idx = pr->parameter_index(); + if (idx < param_ptrs_.size()) { + result = param_ptrs_[idx]; + } else { + LOG(WARNING) << "PARAM_PTR index " << idx + << " out of range (have " << param_ptrs_.size() + << " param pointers)"; + } + } + break; + } + + // MULTIMEM removed: merged into MEMORY case above. + + // --- Bitwise/intrinsic operations --- + case mx::ir::OpCode::BITWISE_8: + case mx::ir::OpCode::BITWISE_16: + case mx::ir::OpCode::BITWISE_32: + case mx::ir::OpCode::BITWISE_64: { + if (auto bw = mx::BitwiseOpInst::from(inst)) { + Value val = Value::Undef(); + auto ops = inst.operands(); + for (auto op_inst : ops) { val = GetValue(op_inst); break; } + int64_t v = val.as_int(); + using BO = mx::ir::BitwiseOp; + auto sub = bw->sub_opcode(); + switch (sub) { + case BO::BSWAP_16: + result = Value::Int(static_cast(__builtin_bswap16(static_cast(v)))); break; + case BO::BSWAP_32: + result = Value::Int(static_cast(__builtin_bswap32(static_cast(v)))); break; + case BO::BSWAP_64: + result = Value::Int(static_cast(__builtin_bswap64(static_cast(v)))); break; + case BO::POPCOUNT: + switch (op) { + case mx::ir::OpCode::BITWISE_8: result = Value::Int(__builtin_popcount(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_16: result = Value::Int(__builtin_popcount(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_32: result = Value::Int(__builtin_popcount(static_cast(v))); break; + default: result = Value::Int(__builtin_popcountll(static_cast(v))); break; + } + break; + case BO::CLZ: + if (!v) { result = Value::Undef(); break; } + switch (op) { + case mx::ir::OpCode::BITWISE_8: result = Value::Int(__builtin_clz(static_cast(v)) - 24); break; + case mx::ir::OpCode::BITWISE_16: result = Value::Int(__builtin_clz(static_cast(v)) - 16); break; + case mx::ir::OpCode::BITWISE_32: result = Value::Int(__builtin_clz(static_cast(v))); break; + default: result = Value::Int(__builtin_clzll(static_cast(v))); break; + } + break; + case BO::CTZ: + if (!v) { result = Value::Undef(); break; } + switch (op) { + case mx::ir::OpCode::BITWISE_8: result = Value::Int(__builtin_ctz(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_16: result = Value::Int(__builtin_ctz(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_32: result = Value::Int(__builtin_ctz(static_cast(v))); break; + default: result = Value::Int(__builtin_ctzll(static_cast(v))); break; + } + break; + case BO::FFS: + switch (op) { + case mx::ir::OpCode::BITWISE_8: result = Value::Int(__builtin_ffs(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_16: result = Value::Int(__builtin_ffs(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_32: result = Value::Int(__builtin_ffs(static_cast(v))); break; + default: result = Value::Int(__builtin_ffsll(static_cast(v))); break; + } + break; + case BO::PARITY: + switch (op) { + case mx::ir::OpCode::BITWISE_8: result = Value::Int(__builtin_parity(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_16: result = Value::Int(__builtin_parity(static_cast(v))); break; + case mx::ir::OpCode::BITWISE_32: result = Value::Int(__builtin_parity(static_cast(v))); break; + default: result = Value::Int(__builtin_parityll(static_cast(v))); break; + } + break; + case BO::ROTL: case BO::ROTR: { + Value val2 = Value::Undef(); + int count = 0; + for (auto op_inst : ops) { + if (count == 1) { val2 = GetValue(op_inst); break; } + count++; + } + int64_t amount = val2.as_int(); + if (sub == BO::ROTL) { + switch (op) { + case mx::ir::OpCode::BITWISE_8: { uint8_t x = static_cast(v); result = Value::Int(static_cast((x << (amount & 7)) | (x >> (8 - (amount & 7))))); break; } + case mx::ir::OpCode::BITWISE_16: { uint16_t x = static_cast(v); result = Value::Int(static_cast((x << (amount & 15)) | (x >> (16 - (amount & 15))))); break; } + case mx::ir::OpCode::BITWISE_32: { uint32_t x = static_cast(v); result = Value::Int(static_cast((x << (amount & 31)) | (x >> (32 - (amount & 31))))); break; } + default: { uint64_t x = static_cast(v); result = Value::Int(static_cast((x << (amount & 63)) | (x >> (64 - (amount & 63))))); break; } + } + } else { + switch (op) { + case mx::ir::OpCode::BITWISE_8: { uint8_t x = static_cast(v); result = Value::Int(static_cast((x >> (amount & 7)) | (x << (8 - (amount & 7))))); break; } + case mx::ir::OpCode::BITWISE_16: { uint16_t x = static_cast(v); result = Value::Int(static_cast((x >> (amount & 15)) | (x << (16 - (amount & 15))))); break; } + case mx::ir::OpCode::BITWISE_32: { uint32_t x = static_cast(v); result = Value::Int(static_cast((x >> (amount & 31)) | (x << (32 - (amount & 31))))); break; } + default: { uint64_t x = static_cast(v); result = Value::Int(static_cast((x >> (amount & 63)) | (x << (64 - (amount & 63))))); break; } + } + } + break; + } + default: + result = val; + break; + } + } + break; + } + // Width-specific ABS (integer absolute value). + case mx::ir::OpCode::ABS_8: { + auto u = mx::UnaryInst::from(inst); + if (u) { int8_t v = static_cast(GetValue(u->operand()).as_int()); result = Value::Int(v < 0 ? -v : v); } + break; + } + case mx::ir::OpCode::ABS_16: { + auto u = mx::UnaryInst::from(inst); + if (u) { int16_t v = static_cast(GetValue(u->operand()).as_int()); result = Value::Int(v < 0 ? -v : v); } + break; + } + case mx::ir::OpCode::ABS_32: { + auto u = mx::UnaryInst::from(inst); + if (u) { int32_t v = static_cast(GetValue(u->operand()).as_int()); result = Value::Int(v < 0 ? -v : v); } + break; + } + case mx::ir::OpCode::ABS_64: { + auto u = mx::UnaryInst::from(inst); + if (u) { int64_t v = GetValue(u->operand()).as_int(); result = Value::Int(v < 0 ? -v : v); } + break; + } + + // --- Floating-point operations --- + case mx::ir::OpCode::FLOAT: { + if (auto fo = mx::FloatOpInst::from(inst)) { + // Collect operands. + std::vector ops; + for (auto op_inst : inst.operands()) { + ops.push_back(GetValue(op_inst)); + } + using FO = mx::ir::FloatOp; + auto sub = fo->sub_opcode(); + switch (sub) { + // --- 1-arg float→float ops --- + case FO::FABS_32: + result = ops.empty() ? Value::Undef() + : Value::Float(fabsf(static_cast(ops[0].as_float()))); + break; + case FO::FABS_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::fabs(ops[0].as_float())); + break; + case FO::SQRT_32: + result = ops.empty() ? Value::Undef() + : Value::Float(sqrtf(static_cast(ops[0].as_float()))); + break; + case FO::SQRT_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::sqrt(ops[0].as_float())); + break; + case FO::CEIL_32: + result = ops.empty() ? Value::Undef() + : Value::Float(ceilf(static_cast(ops[0].as_float()))); + break; + case FO::CEIL_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::ceil(ops[0].as_float())); + break; + case FO::FLOOR_32: + result = ops.empty() ? Value::Undef() + : Value::Float(floorf(static_cast(ops[0].as_float()))); + break; + case FO::FLOOR_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::floor(ops[0].as_float())); + break; + case FO::ROUND_32: + result = ops.empty() ? Value::Undef() + : Value::Float(roundf(static_cast(ops[0].as_float()))); + break; + case FO::ROUND_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::round(ops[0].as_float())); + break; + case FO::TRUNC_32: + result = ops.empty() ? Value::Undef() + : Value::Float(truncf(static_cast(ops[0].as_float()))); + break; + case FO::TRUNC_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::trunc(ops[0].as_float())); + break; + case FO::SIN_32: + result = ops.empty() ? Value::Undef() + : Value::Float(sinf(static_cast(ops[0].as_float()))); + break; + case FO::SIN_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::sin(ops[0].as_float())); + break; + case FO::COS_32: + result = ops.empty() ? Value::Undef() + : Value::Float(cosf(static_cast(ops[0].as_float()))); + break; + case FO::COS_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::cos(ops[0].as_float())); + break; + case FO::TAN_32: + result = ops.empty() ? Value::Undef() + : Value::Float(tanf(static_cast(ops[0].as_float()))); + break; + case FO::TAN_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::tan(ops[0].as_float())); + break; + case FO::ASIN_32: + result = ops.empty() ? Value::Undef() + : Value::Float(asinf(static_cast(ops[0].as_float()))); + break; + case FO::ASIN_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::asin(ops[0].as_float())); + break; + case FO::ACOS_32: + result = ops.empty() ? Value::Undef() + : Value::Float(acosf(static_cast(ops[0].as_float()))); + break; + case FO::ACOS_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::acos(ops[0].as_float())); + break; + case FO::ATAN_32: + result = ops.empty() ? Value::Undef() + : Value::Float(atanf(static_cast(ops[0].as_float()))); + break; + case FO::ATAN_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::atan(ops[0].as_float())); + break; + case FO::EXP_32: + result = ops.empty() ? Value::Undef() + : Value::Float(expf(static_cast(ops[0].as_float()))); + break; + case FO::EXP_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::exp(ops[0].as_float())); + break; + case FO::EXP2_32: + result = ops.empty() ? Value::Undef() + : Value::Float(exp2f(static_cast(ops[0].as_float()))); + break; + case FO::EXP2_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::exp2(ops[0].as_float())); + break; + case FO::LOG_32: + result = ops.empty() ? Value::Undef() + : Value::Float(logf(static_cast(ops[0].as_float()))); + break; + case FO::LOG_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::log(ops[0].as_float())); + break; + case FO::LOG2_32: + result = ops.empty() ? Value::Undef() + : Value::Float(log2f(static_cast(ops[0].as_float()))); + break; + case FO::LOG2_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::log2(ops[0].as_float())); + break; + case FO::LOG10_32: + result = ops.empty() ? Value::Undef() + : Value::Float(log10f(static_cast(ops[0].as_float()))); + break; + case FO::LOG10_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::log10(ops[0].as_float())); + break; + case FO::SINH_32: + result = ops.empty() ? Value::Undef() + : Value::Float(sinhf(static_cast(ops[0].as_float()))); + break; + case FO::SINH_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::sinh(ops[0].as_float())); + break; + case FO::COSH_32: + result = ops.empty() ? Value::Undef() + : Value::Float(coshf(static_cast(ops[0].as_float()))); + break; + case FO::COSH_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::cosh(ops[0].as_float())); + break; + case FO::TANH_32: + result = ops.empty() ? Value::Undef() + : Value::Float(tanhf(static_cast(ops[0].as_float()))); + break; + case FO::TANH_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::tanh(ops[0].as_float())); + break; + case FO::ERF_32: + result = ops.empty() ? Value::Undef() + : Value::Float(erff(static_cast(ops[0].as_float()))); + break; + case FO::ERF_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::erf(ops[0].as_float())); + break; + case FO::ERFC_32: + result = ops.empty() ? Value::Undef() + : Value::Float(erfcf(static_cast(ops[0].as_float()))); + break; + case FO::ERFC_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::erfc(ops[0].as_float())); + break; + case FO::TGAMMA_32: + result = ops.empty() ? Value::Undef() + : Value::Float(tgammaf(static_cast(ops[0].as_float()))); + break; + case FO::TGAMMA_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::tgamma(ops[0].as_float())); + break; + case FO::LGAMMA_32: + result = ops.empty() ? Value::Undef() + : Value::Float(lgammaf(static_cast(ops[0].as_float()))); + break; + case FO::LGAMMA_64: + result = ops.empty() ? Value::Undef() + : Value::Float(std::lgamma(ops[0].as_float())); + break; + + // --- 2-arg float→float ops --- + case FO::FMIN_32: + result = (ops.size() >= 2) + ? Value::Float(fminf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::FMIN_64: + result = (ops.size() >= 2) + ? Value::Float(std::fmin(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::FMAX_32: + result = (ops.size() >= 2) + ? Value::Float(fmaxf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::FMAX_64: + result = (ops.size() >= 2) + ? Value::Float(std::fmax(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::COPYSIGN_32: + result = (ops.size() >= 2) + ? Value::Float(copysignf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::COPYSIGN_64: + result = (ops.size() >= 2) + ? Value::Float(std::copysign(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::ATAN2_32: + result = (ops.size() >= 2) + ? Value::Float(atan2f(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::ATAN2_64: + result = (ops.size() >= 2) + ? Value::Float(std::atan2(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::POW_32: + result = (ops.size() >= 2) + ? Value::Float(powf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::POW_64: + result = (ops.size() >= 2) + ? Value::Float(std::pow(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::FMOD_32: + result = (ops.size() >= 2) + ? Value::Float(fmodf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::FMOD_64: + result = (ops.size() >= 2) + ? Value::Float(std::fmod(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::REMAINDER_32: + result = (ops.size() >= 2) + ? Value::Float(remainderf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::REMAINDER_64: + result = (ops.size() >= 2) + ? Value::Float(std::remainder(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::HYPOT_32: + result = (ops.size() >= 2) + ? Value::Float(hypotf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::HYPOT_64: + result = (ops.size() >= 2) + ? Value::Float(std::hypot(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + case FO::FDIM_32: + result = (ops.size() >= 2) + ? Value::Float(fdimf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()))) + : Value::Undef(); + break; + case FO::FDIM_64: + result = (ops.size() >= 2) + ? Value::Float(std::fdim(ops[0].as_float(), ops[1].as_float())) + : Value::Undef(); + break; + + // --- 3-arg ops --- + case FO::FMA_32: + result = (ops.size() >= 3) + ? Value::Float(fmaf(static_cast(ops[0].as_float()), + static_cast(ops[1].as_float()), + static_cast(ops[2].as_float()))) + : Value::Undef(); + break; + case FO::FMA_64: + result = (ops.size() >= 3) + ? Value::Float(std::fma(ops[0].as_float(), ops[1].as_float(), ops[2].as_float())) + : Value::Undef(); + break; + + // --- Classification ops (return int) --- + case FO::ISNAN_32: + result = ops.empty() ? Value::Undef() + : Value::Int(std::isnan(static_cast(ops[0].as_float())) ? 1 : 0); + break; + case FO::ISNAN_64: + result = ops.empty() ? Value::Undef() + : Value::Int(std::isnan(ops[0].as_float()) ? 1 : 0); + break; + case FO::ISINF_32: + result = ops.empty() ? Value::Undef() + : Value::Int(std::isinf(static_cast(ops[0].as_float())) ? 1 : 0); + break; + case FO::ISINF_64: + result = ops.empty() ? Value::Undef() + : Value::Int(std::isinf(ops[0].as_float()) ? 1 : 0); + break; + case FO::ISFINITE_32: + result = ops.empty() ? Value::Undef() + : Value::Int(std::isfinite(static_cast(ops[0].as_float())) ? 1 : 0); + break; + case FO::ISFINITE_64: + result = ops.empty() ? Value::Undef() + : Value::Int(std::isfinite(ops[0].as_float()) ? 1 : 0); + break; + case FO::SIGNBIT_32: + result = ops.empty() ? Value::Undef() + : Value::Int(std::signbit(static_cast(ops[0].as_float())) ? 1 : 0); + break; + case FO::SIGNBIT_64: + result = ops.empty() ? Value::Undef() + : Value::Int(std::signbit(ops[0].as_float()) ? 1 : 0); + break; + + // --- Zero-arg constants --- + case FO::INF_32: + result = Value::Float(std::numeric_limits::infinity()); + break; + case FO::INF_64: + result = Value::Float(std::numeric_limits::infinity()); + break; + case FO::NAN_32: + result = Value::Float(std::numeric_limits::quiet_NaN()); + break; + case FO::NAN_64: + result = Value::Float(std::numeric_limits::quiet_NaN()); + break; + case FO::HUGE_32: + result = Value::Float(static_cast(HUGE_VALF)); + break; + case FO::HUGE_64: + result = Value::Float(HUGE_VAL); + break; + } + } + break; + } + + // --- Frame/return address intrinsics --- + case mx::ir::OpCode::FRAME_PTR_32: case mx::ir::OpCode::FRAME_PTR_64: + case mx::ir::OpCode::RETURN_ADDRESS_32: case mx::ir::OpCode::RETURN_ADDRESS_64: + // Not meaningfully interpretable; return undef. + result = Value::Undef(); + break; + + // --- Return value pointer (callee side) --- + case mx::ir::OpCode::RETURN_PTR_32: + case mx::ir::OpCode::RETURN_PTR_64: + result = return_ptr_; + break; + + // --- Undefined/poison value --- + case mx::ir::OpCode::UNDEFINED: + result = Value::Undef(); + break; + + // --- Overflow opcodes (only valid as RMW underlying ops, not standalone) --- + case mx::ir::OpCode::ADD_OVERFLOW_8: case mx::ir::OpCode::ADD_OVERFLOW_16: + case mx::ir::OpCode::ADD_OVERFLOW_32: case mx::ir::OpCode::ADD_OVERFLOW_64: + case mx::ir::OpCode::SUB_OVERFLOW_8: case mx::ir::OpCode::SUB_OVERFLOW_16: + case mx::ir::OpCode::SUB_OVERFLOW_32: case mx::ir::OpCode::SUB_OVERFLOW_64: + case mx::ir::OpCode::MUL_OVERFLOW_8: case mx::ir::OpCode::MUL_OVERFLOW_16: + case mx::ir::OpCode::MUL_OVERFLOW_32: case mx::ir::OpCode::MUL_OVERFLOW_64: + case mx::ir::OpCode::ATOMIC_ADD_8: case mx::ir::OpCode::ATOMIC_ADD_16: + case mx::ir::OpCode::ATOMIC_ADD_32: case mx::ir::OpCode::ATOMIC_ADD_64: + case mx::ir::OpCode::ATOMIC_SUB_8: case mx::ir::OpCode::ATOMIC_SUB_16: + case mx::ir::OpCode::ATOMIC_SUB_32: case mx::ir::OpCode::ATOMIC_SUB_64: + case mx::ir::OpCode::ATOMIC_AND_8: case mx::ir::OpCode::ATOMIC_AND_16: + case mx::ir::OpCode::ATOMIC_AND_32: case mx::ir::OpCode::ATOMIC_AND_64: + case mx::ir::OpCode::ATOMIC_OR_8: case mx::ir::OpCode::ATOMIC_OR_16: + case mx::ir::OpCode::ATOMIC_OR_32: case mx::ir::OpCode::ATOMIC_OR_64: + case mx::ir::OpCode::ATOMIC_XOR_8: case mx::ir::OpCode::ATOMIC_XOR_16: + case mx::ir::OpCode::ATOMIC_XOR_32: case mx::ir::OpCode::ATOMIC_XOR_64: + case mx::ir::OpCode::ATOMIC_NAND_8: case mx::ir::OpCode::ATOMIC_NAND_16: + case mx::ir::OpCode::ATOMIC_NAND_32: case mx::ir::OpCode::ATOMIC_NAND_64: + case mx::ir::OpCode::ATOMIC_EXCHANGE_8: case mx::ir::OpCode::ATOMIC_EXCHANGE_16: + case mx::ir::OpCode::ATOMIC_EXCHANGE_32: case mx::ir::OpCode::ATOMIC_EXCHANGE_64: + LOG(WARNING) << "RMW-only opcode used as standalone instruction"; + break; + + // --- Variadic --- + case mx::ir::OpCode::VA_START: + case mx::ir::OpCode::VA_END: + case mx::ir::OpCode::VA_COPY: { + // CRITIQUE: Variadic args need a runtime va_list model. Not implemented + // in this simple interpreter. va_arg is handled via MEMORY/CONSUME_VA_PARAM. + break; + } + + // --- Global/function address --- + case mx::ir::OpCode::GLOBAL_PTR_32: case mx::ir::OpCode::GLOBAL_PTR_64: + case mx::ir::OpCode::THREAD_LOCAL_PTR_32: case mx::ir::OpCode::THREAD_LOCAL_PTR_64: { + // In a real interpreter, this would look up the global/TLS storage. + // For now, create a synthetic pointer using the target entity ID. + result = Value::Ptr(inst.source_entity_id(), 0); + break; + } + case mx::ir::OpCode::FUNC_PTR_32: + case mx::ir::OpCode::FUNC_PTR_64: { + // Function pointer — use the source entity ID as a handle. + result = Value::Ptr(inst.source_entity_id(), 0); + break; + } + + // --- Scope markers: track object lifetimes --- + case mx::ir::OpCode::ENTER_SCOPE: { + if (auto esi = mx::EnterScopeInst::from(inst)) { + auto scope = esi->scope(); + for (auto obj : scope.objects()) { + auto oid = mx::EntityId(obj.id()).Pack(); + auto it = memory_.find(oid); + if (it != memory_.end()) { + it->second.poisoned = false; // Re-entering scope (loop iteration). + } + } + } + break; + } + case mx::ir::OpCode::EXIT_SCOPE: { + if (auto esi = mx::ExitScopeInst::from(inst)) { + auto scope = esi->scope(); + for (auto obj : scope.objects()) { + auto oid = mx::EntityId(obj.id()).Pack(); + auto it = memory_.find(oid); + if (it != memory_.end()) { + it->second.poisoned = true; // Object lifetime ended. + } + } + } + break; + } + + // --- Terminators are handled by the CFG walker, not here --- + case mx::ir::OpCode::COND_BRANCH: + case mx::ir::OpCode::SWITCH: + case mx::ir::OpCode::RET: + case mx::ir::OpCode::UNREACHABLE: + case mx::ir::OpCode::IMPLICIT_UNREACHABLE: + case mx::ir::OpCode::BREAK: + case mx::ir::OpCode::CONTINUE: + case mx::ir::OpCode::GOTO: + case mx::ir::OpCode::IMPLICIT_GOTO: + case mx::ir::OpCode::FALLTHROUGH: + case mx::ir::OpCode::IMPLICIT_FALLTHROUGH: + break; + + case mx::ir::OpCode::UNKNOWN: + LOG(WARNING) << "Encountered UNKNOWN opcode"; + break; + } + + values_[eid] = result; + Trace(inst, result); +} + +void Interpreter::EvalSubExpressions(const mx::IRInstruction &inst) { + for (auto operand : inst.operands()) { + EvalSubExpressions(operand); // depth-first + auto sub_op = operand.opcode(); + if (!mx::ir::IsTerminator(sub_op)) { + Eval(operand); + } + } +} + +// --------------------------------------------------------------------------- +// Main interpreter loop +// --------------------------------------------------------------------------- + +Value Interpreter::Run(const std::vector &args) { + params_ = args; + param_ptrs_.clear(); + values_.clear(); + memory_.clear(); + pointer_shadow_.clear(); + block_map_.clear(); + steps_ = 0; + + // Pre-allocate parameter and return storage. + // PARAM_PTR(n) returns a pointer to the nth parameter's storage. + // RETURN_PTR returns a pointer to the return value storage. + return_ptr_ = Value::Undef(); + { + uint32_t param_idx = 0; + for (auto obj : func_.objects()) { + auto k = obj.kind(); + if (k == mx::ir::ObjectKind::PARAMETER || + k == mx::ir::ObjectKind::PARAMETER_VALUE) { + auto eid = mx::EntityId(obj.id()).Pack(); + AllocateObject(obj); + Pointer ptr{eid, 0}; + if (param_idx < args.size()) { + uint32_t sz = obj.size_bytes(); + if (sz == 0) sz = 8; + MemWriteValue(ptr, args[param_idx], sz); + } + param_ptrs_.push_back(Value::Ptr(eid, 0)); + ++param_idx; + } + } + } + + // Allocate return storage (callee no longer has RETURN_SLOT object). + // Use a monotonically increasing ID that won't collide with entity IDs. + if (return_ptr_.kind == Value::UNDEFINED) { + if (auto decl = func_.source_declaration()) { + if (auto fd = mx::FunctionDecl::from(*decl)) { + auto rt = fd->return_type(); + if (auto bits = rt.size_in_bits()) { + uint32_t sz = static_cast((*bits + 7) / 8); + if (sz > 0) { + uint64_t ret_eid = next_interp_object_id_++; + auto &mem = memory_[ret_eid]; + mem.bytes.resize(sz, 0); + mem.allocated = true; + return_ptr_ = Value::Ptr(ret_eid, 0); + } + } + } + } + } + + // Build block map for CFG navigation. + for (auto block : func_.blocks()) { + block_map_[mx::EntityId(block.id()).Pack()] = block; + } + // Also add the entry block (which might be FRAME, not in RPO). + { + auto entry = func_.entry_block(); + block_map_[mx::EntityId(entry.id()).Pack()] = entry; + } + + // Start at the entry block (FRAME). + mx::IRBlock current = func_.entry_block(); + Value return_value = Value::Undef(); + + while (true) { + if (steps_ >= FLAGS_max_steps) { + LOG(ERROR) << "Interpreter exceeded max steps (" << FLAGS_max_steps << ")"; + break; + } + + + + // Clear cached values at block boundaries for fresh LOAD evaluation. + values_.clear(); + + if (trace_) { + std::cerr << "Block " << mx::ir::EnumeratorName(current.kind()) + << " (" << mx::EntityId(current.id()).Pack() << ")\n"; + } + + + // Evaluate all instructions in the block. all_instructions() yields + // only root instructions; sub-expressions are lazy-evaluated via GetValue. + for (auto inst : current.all_instructions()) { + ++steps_; + auto op = inst.opcode(); + + // Non-terminator: evaluate and store result. + if (!mx::ir::IsTerminator(op)) { + Eval(inst); + continue; + } + + // --- Terminator handling --- + + if (op == mx::ir::OpCode::RET) { + auto ri = mx::RetInst::from(inst); + if (ri) { + if (auto rv = ri->return_value()) { + return_value = GetValue(*rv); + } + } + // Fallback: read from RETURN_PTR storage if direct operand is undef. + if (return_value.kind == Value::UNDEFINED && + return_ptr_.kind == Value::POINTER) { + // Determine return size from the RETURN_SLOT object. + auto it = memory_.find(return_ptr_.ptr.object_id); + size_t ret_sz = (it != memory_.end()) ? it->second.bytes.size() : 8; + return_value = MemReadValue(return_ptr_.ptr, ret_sz, false); + } + goto done; + } + + if (op == mx::ir::OpCode::UNREACHABLE || + op == mx::ir::OpCode::IMPLICIT_UNREACHABLE) { + LOG(ERROR) << "Reached UNREACHABLE instruction"; + goto done; + } + + if (op == mx::ir::OpCode::COND_BRANCH) { + auto cb = mx::CondBranchInst::from(inst); + if (cb) { + Value cond = GetValue(cb->condition()); + auto target = cond.is_truthy() ? cb->true_block() : cb->false_block(); + current = target; + goto next_block; + } + break; + } + + if (op == mx::ir::OpCode::SWITCH) { + auto sw = mx::SwitchInst::from(inst); + if (sw) { + Value sel = GetValue(sw->selector()); + int64_t sel_val = sel.as_int(); + bool found = false; + mx::IRBlock default_block{}; + for (auto sc : sw->cases()) { + if (sc.is_default()) { + default_block = sc.target_block(); + continue; + } + if (sel_val >= sc.low() && sel_val <= sc.high()) { + current = sc.target_block(); + found = true; + break; + } + } + if (!found) { + if (default_block.id().Pack()) { + current = default_block; + } else { + LOG(ERROR) << "Switch: no matching case and no default"; + goto done; + } + } + goto next_block; + } + break; + } + + // All other terminators (GOTO, IMPLICIT_GOTO, BREAK, CONTINUE, + // FALLTHROUGH, IMPLICIT_FALLTHROUGH) are unconditional branches. + { + auto br = mx::BranchInst::from(inst); + if (br) { + current = br->target_block(); + goto next_block; + } + } + break; + } + + // If we fell through without a terminator (shouldn't happen with + // well-formed IR), break. + LOG(ERROR) << "Block ended without terminator"; + break; + + next_block: + continue; + } + + done: + std::cout << "Interpreter finished after " << steps_ << " steps.\n"; + switch (return_value.kind) { + case Value::INTEGER: + std::cout << "Return value: " << return_value.ival << "\n"; + break; + case Value::FLOATING: + std::cout << "Return value: " << return_value.fval << "\n"; + break; + case Value::POINTER: + std::cout << "Return value: ptr(" << return_value.ptr.object_id + << "+" << return_value.ptr.offset << ")\n"; + break; + default: + std::cout << "Return value: void/undef\n"; + break; + } + + return return_value; +} + +} // namespace + +int main(int argc, char *argv[]) { + std::stringstream ss; + ss << "Usage: " << argv[0] << " --db DATABASE --entity_name FUNC_NAME\n" + << "Interprets the IR of the named function."; + google::SetUsageMessage(ss.str()); + google::ParseCommandLineFlags(&argc, &argv, false); + google::InitGoogleLogging(argv[0]); + + mx::Index index = InitExample(false); + + // Find the function. + std::optional ir_func; + + if (FLAGS_entity_id != mx::kInvalidEntityId) { + auto vid = mx::EntityId(FLAGS_entity_id).Unpack(); + if (auto *fid = std::get_if(&vid)) { + // Direct entity ID lookup would go here. + LOG(ERROR) << "Direct IRFunction ID lookup not yet supported. Use --entity_name."; + return 1; + } + } + + if (!FLAGS_entity_name.empty()) { + for (auto frag : mx::Fragment::in(index)) { + for (auto decl : mx::Decl::in(frag)) { + auto func_decl = mx::FunctionDecl::from(decl); + if (!func_decl) continue; + if (std::string(func_decl->name()) != FLAGS_entity_name) continue; + ir_func = mx::IRFunction::from(*func_decl); + if (ir_func) break; + } + if (ir_func) break; + } + } + + if (!ir_func) { + LOG(ERROR) << "Could not find IR for function '" << FLAGS_entity_name << "'"; + return 1; + } + + auto decl = ir_func->source_declaration(); + std::cout << "Interpreting IR for: " + << (decl ? "decl" : "unknown") + << " (kind=" << static_cast(ir_func->kind()) << ")\n"; + + // Print summary. + unsigned num_blocks = 0, num_insts = 0, num_objs = 0; + for (auto b : ir_func->blocks()) { + ++num_blocks; + for (auto i : b.all_instructions()) { ++num_insts; (void)i; } + } + for (auto o : ir_func->objects()) { ++num_objs; (void)o; } + std::cout << num_blocks << " blocks, " << num_insts << " instructions, " + << num_objs << " objects\n"; + + // Run with zero-initialized arguments. + // A real testing harness would supply concrete values. + std::vector args; + if (auto fd = mx::FunctionDecl::from(*decl)) { + for (auto p : fd->parameters()) { + (void)p; + args.push_back(Value::Int(0)); + } + } + std::cout << "Running with " << args.size() << " zero-initialized arguments...\n\n"; + + Interpreter interp(*ir_func, FLAGS_trace); + interp.Run(args); + + return 0; +} diff --git a/bindings/Python/Entity.cpp b/bindings/Python/Entity.cpp index ddc66556b..306f4156c 100644 --- a/bindings/Python/Entity.cpp +++ b/bindings/Python/Entity.cpp @@ -87,6 +87,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_CONVERT_FROM_PYTHON, MX_CONVERT_FROM_PYTHON, MX_CONVERT_FROM_PYTHON, MX_CONVERT_FROM_PYTHON, + MX_CONVERT_FROM_PYTHON, MX_CONVERT_FROM_PYTHON) #undef MX_CONVERT_FROM_PYTHON @@ -107,6 +108,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_CONVERT_TO_PYTHON, MX_CONVERT_TO_PYTHON, MX_CONVERT_TO_PYTHON, MX_CONVERT_TO_PYTHON, + MX_CONVERT_TO_PYTHON, MX_CONVERT_TO_PYTHON) #undef MX_CONVERT_TO_PYTHON diff --git a/bindings/Python/Forward.h b/bindings/Python/Forward.h index 3cea2d800..1b49eb4b8 100644 --- a/bindings/Python/Forward.h +++ b/bindings/Python/Forward.h @@ -578,6 +578,12 @@ enum class AttributeSyntax : uint8_t; enum class DeclCategory : uint8_t; enum class PseudoKind : uint8_t; enum class EntityCategory : int32_t; +enum class IREntityKind : uint8_t; +class IRFunction; +class IRBlock; +class IRInstruction; +class IRObject; +class IRStructure; class TokenContext; class CXXCtorInitializer; class Designator; @@ -1458,4 +1464,9 @@ class IncludeMacroDirective; enum class IndexStatus : uint32_t; class Index; class RegexQuery; +namespace ir { +enum class OpCode : uint8_t; +enum class ObjectKind : uint8_t; +enum class BlockKind : uint8_t; +} // namespace ir } // namespace mx diff --git a/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp b/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp index dd7bd65d9..3715e68b4 100644 --- a/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp +++ b/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[208]) || tp >= &(gTypes[209])) { + if (tp < &(gTypes[212]) || tp >= &(gTypes[213])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AArch64SVEPcsAttr::static_kind(): - tp = &(gTypes[208]); + tp = &(gTypes[212]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[208]); + PyTypeObject * const tp = &(gTypes[212]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp b/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp index 42e3e451c..8ade72ecf 100644 --- a/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp +++ b/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[207]) || tp >= &(gTypes[208])) { + if (tp < &(gTypes[211]) || tp >= &(gTypes[212])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AArch64VectorPcsAttr::static_kind(): - tp = &(gTypes[207]); + tp = &(gTypes[211]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[207]); + PyTypeObject * const tp = &(gTypes[211]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp b/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp index d00693385..9b7c8afa8 100644 --- a/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp +++ b/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[206]) || tp >= &(gTypes[207])) { + if (tp < &(gTypes[210]) || tp >= &(gTypes[211])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AMDGPUFlatWorkGroupSizeAttr::static_kind(): - tp = &(gTypes[206]); + tp = &(gTypes[210]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[206]); + PyTypeObject * const tp = &(gTypes[210]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp b/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp index 373280da8..02fc64fb1 100644 --- a/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp +++ b/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[205]) || tp >= &(gTypes[206])) { + if (tp < &(gTypes[209]) || tp >= &(gTypes[210])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AMDGPUKernelCallAttr::static_kind(): - tp = &(gTypes[205]); + tp = &(gTypes[209]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[205]); + PyTypeObject * const tp = &(gTypes[209]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp b/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp index 7c3a4bd69..f1abc06ee 100644 --- a/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp +++ b/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[204]) || tp >= &(gTypes[205])) { + if (tp < &(gTypes[208]) || tp >= &(gTypes[209])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AMDGPUNumSGPRAttr::static_kind(): - tp = &(gTypes[204]); + tp = &(gTypes[208]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[204]); + PyTypeObject * const tp = &(gTypes[208]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp b/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp index 269da0623..7b595019c 100644 --- a/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp +++ b/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[203]) || tp >= &(gTypes[204])) { + if (tp < &(gTypes[207]) || tp >= &(gTypes[208])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AMDGPUNumVGPRAttr::static_kind(): - tp = &(gTypes[203]); + tp = &(gTypes[207]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[203]); + PyTypeObject * const tp = &(gTypes[207]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp b/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp index 65ece675e..a80477fd6 100644 --- a/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp +++ b/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[202]) || tp >= &(gTypes[203])) { + if (tp < &(gTypes[206]) || tp >= &(gTypes[207])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AMDGPUWavesPerEUAttr::static_kind(): - tp = &(gTypes[202]); + tp = &(gTypes[206]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[202]); + PyTypeObject * const tp = &(gTypes[206]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ARMInterruptAttr.cpp b/bindings/Python/Generated/AST/ARMInterruptAttr.cpp index c0677b8b1..f66c3c754 100644 --- a/bindings/Python/Generated/AST/ARMInterruptAttr.cpp +++ b/bindings/Python/Generated/AST/ARMInterruptAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[201]) || tp >= &(gTypes[202])) { + if (tp < &(gTypes[205]) || tp >= &(gTypes[206])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ARMInterruptAttr::static_kind(): - tp = &(gTypes[201]); + tp = &(gTypes[205]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[201]); + PyTypeObject * const tp = &(gTypes[205]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AVRInterruptAttr.cpp b/bindings/Python/Generated/AST/AVRInterruptAttr.cpp index 39322bd80..7768e4f06 100644 --- a/bindings/Python/Generated/AST/AVRInterruptAttr.cpp +++ b/bindings/Python/Generated/AST/AVRInterruptAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[200]) || tp >= &(gTypes[201])) { + if (tp < &(gTypes[204]) || tp >= &(gTypes[205])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AVRInterruptAttr::static_kind(): - tp = &(gTypes[200]); + tp = &(gTypes[204]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[200]); + PyTypeObject * const tp = &(gTypes[204]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AVRSignalAttr.cpp b/bindings/Python/Generated/AST/AVRSignalAttr.cpp index 91e786465..a44a451bb 100644 --- a/bindings/Python/Generated/AST/AVRSignalAttr.cpp +++ b/bindings/Python/Generated/AST/AVRSignalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[199]) || tp >= &(gTypes[200])) { + if (tp < &(gTypes[203]) || tp >= &(gTypes[204])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AVRSignalAttr::static_kind(): - tp = &(gTypes[199]); + tp = &(gTypes[203]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[199]); + PyTypeObject * const tp = &(gTypes[203]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AbiTagAttr.cpp b/bindings/Python/Generated/AST/AbiTagAttr.cpp index a8d40bd60..245ed5311 100644 --- a/bindings/Python/Generated/AST/AbiTagAttr.cpp +++ b/bindings/Python/Generated/AST/AbiTagAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[9]) || tp >= &(gTypes[10])) { + if (tp < &(gTypes[13]) || tp >= &(gTypes[14])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AbiTagAttr::static_kind(): - tp = &(gTypes[9]); + tp = &(gTypes[13]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[9]); + PyTypeObject * const tp = &(gTypes[13]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp b/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp index 8f76d09d3..86d3e11ab 100644 --- a/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp +++ b/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[651]) || tp >= &(gTypes[654])) { + if (tp < &(gTypes[655]) || tp >= &(gTypes[658])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConditionalOperator::static_kind(): - tp = &(gTypes[652]); + tp = &(gTypes[656]); break; case mx::BinaryConditionalOperator::static_kind(): - tp = &(gTypes[653]); + tp = &(gTypes[657]); break; } @@ -356,7 +356,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -386,7 +386,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[651]); + PyTypeObject * const tp = &(gTypes[655]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -401,12 +401,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AccessSpecDecl.cpp b/bindings/Python/Generated/AST/AccessSpecDecl.cpp index 1eeafff21..ef4b858c6 100644 --- a/bindings/Python/Generated/AST/AccessSpecDecl.cpp +++ b/bindings/Python/Generated/AST/AccessSpecDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[726]) || tp >= &(gTypes[727])) { + if (tp < &(gTypes[730]) || tp >= &(gTypes[731])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AccessSpecDecl::static_kind(): - tp = &(gTypes[726]); + tp = &(gTypes[730]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[726]); + PyTypeObject * const tp = &(gTypes[730]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp b/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp index e7e1aa481..b8fb643a8 100644 --- a/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp +++ b/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[198]) || tp >= &(gTypes[199])) { + if (tp < &(gTypes[202]) || tp >= &(gTypes[203])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AcquireCapabilityAttr::static_kind(): - tp = &(gTypes[198]); + tp = &(gTypes[202]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[198]); + PyTypeObject * const tp = &(gTypes[202]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AcquireHandleAttr.cpp b/bindings/Python/Generated/AST/AcquireHandleAttr.cpp index 693db115d..2d154ad3f 100644 --- a/bindings/Python/Generated/AST/AcquireHandleAttr.cpp +++ b/bindings/Python/Generated/AST/AcquireHandleAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[197]) || tp >= &(gTypes[198])) { + if (tp < &(gTypes[201]) || tp >= &(gTypes[202])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AcquireHandleAttr::static_kind(): - tp = &(gTypes[197]); + tp = &(gTypes[201]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[197]); + PyTypeObject * const tp = &(gTypes[201]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp b/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp index 17d699308..6c9bd394d 100644 --- a/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp +++ b/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[196]) || tp >= &(gTypes[197])) { + if (tp < &(gTypes[200]) || tp >= &(gTypes[201])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AcquiredAfterAttr::static_kind(): - tp = &(gTypes[196]); + tp = &(gTypes[200]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[196]); + PyTypeObject * const tp = &(gTypes[200]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp b/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp index 9f0adbc8c..f243764c5 100644 --- a/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp +++ b/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[195]) || tp >= &(gTypes[196])) { + if (tp < &(gTypes[199]) || tp >= &(gTypes[200])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AcquiredBeforeAttr::static_kind(): - tp = &(gTypes[195]); + tp = &(gTypes[199]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[195]); + PyTypeObject * const tp = &(gTypes[199]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AddrLabelExpr.cpp b/bindings/Python/Generated/AST/AddrLabelExpr.cpp index 88d35747d..f1a479729 100644 --- a/bindings/Python/Generated/AST/AddrLabelExpr.cpp +++ b/bindings/Python/Generated/AST/AddrLabelExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[650]) || tp >= &(gTypes[651])) { + if (tp < &(gTypes[654]) || tp >= &(gTypes[655])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AddrLabelExpr::static_kind(): - tp = &(gTypes[650]); + tp = &(gTypes[654]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[650]); + PyTypeObject * const tp = &(gTypes[654]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AddressSpaceAttr.cpp b/bindings/Python/Generated/AST/AddressSpaceAttr.cpp index aa291179b..e1aedc72b 100644 --- a/bindings/Python/Generated/AST/AddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/AddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[37]) || tp >= &(gTypes[38])) { + if (tp < &(gTypes[41]) || tp >= &(gTypes[42])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AddressSpaceAttr::static_kind(): - tp = &(gTypes[37]); + tp = &(gTypes[41]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[37]); + PyTypeObject * const tp = &(gTypes[41]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AdjustedType.cpp b/bindings/Python/Generated/AST/AdjustedType.cpp index 4d82b0c2e..02a2eb2d8 100644 --- a/bindings/Python/Generated/AST/AdjustedType.cpp +++ b/bindings/Python/Generated/AST/AdjustedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[459]) || tp >= &(gTypes[461])) { + if (tp < &(gTypes[463]) || tp >= &(gTypes[465])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AdjustedType::static_kind(): - tp = &(gTypes[459]); + tp = &(gTypes[463]); break; case mx::DecayedType::static_kind(): - tp = &(gTypes[460]); + tp = &(gTypes[464]); break; } @@ -297,7 +297,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[459]); + PyTypeObject * const tp = &(gTypes[463]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AliasAttr.cpp b/bindings/Python/Generated/AST/AliasAttr.cpp index 9059075e5..4af8fd751 100644 --- a/bindings/Python/Generated/AST/AliasAttr.cpp +++ b/bindings/Python/Generated/AST/AliasAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[8]) || tp >= &(gTypes[9])) { + if (tp < &(gTypes[12]) || tp >= &(gTypes[13])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AliasAttr::static_kind(): - tp = &(gTypes[8]); + tp = &(gTypes[12]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[8]); + PyTypeObject * const tp = &(gTypes[12]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AlignMac68kAttr.cpp b/bindings/Python/Generated/AST/AlignMac68kAttr.cpp index 653898b9a..b964249a3 100644 --- a/bindings/Python/Generated/AST/AlignMac68kAttr.cpp +++ b/bindings/Python/Generated/AST/AlignMac68kAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[194]) || tp >= &(gTypes[195])) { + if (tp < &(gTypes[198]) || tp >= &(gTypes[199])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlignMac68kAttr::static_kind(): - tp = &(gTypes[194]); + tp = &(gTypes[198]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[194]); + PyTypeObject * const tp = &(gTypes[198]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AlignNaturalAttr.cpp b/bindings/Python/Generated/AST/AlignNaturalAttr.cpp index 639d61edb..c2fdba895 100644 --- a/bindings/Python/Generated/AST/AlignNaturalAttr.cpp +++ b/bindings/Python/Generated/AST/AlignNaturalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[193]) || tp >= &(gTypes[194])) { + if (tp < &(gTypes[197]) || tp >= &(gTypes[198])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlignNaturalAttr::static_kind(): - tp = &(gTypes[193]); + tp = &(gTypes[197]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[193]); + PyTypeObject * const tp = &(gTypes[197]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AlignValueAttr.cpp b/bindings/Python/Generated/AST/AlignValueAttr.cpp index 330d1afe0..0067f6816 100644 --- a/bindings/Python/Generated/AST/AlignValueAttr.cpp +++ b/bindings/Python/Generated/AST/AlignValueAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[7]) || tp >= &(gTypes[8])) { + if (tp < &(gTypes[11]) || tp >= &(gTypes[12])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlignValueAttr::static_kind(): - tp = &(gTypes[7]); + tp = &(gTypes[11]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[7]); + PyTypeObject * const tp = &(gTypes[11]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AlignedAttr.cpp b/bindings/Python/Generated/AST/AlignedAttr.cpp index a3c7b0a14..c655aafcf 100644 --- a/bindings/Python/Generated/AST/AlignedAttr.cpp +++ b/bindings/Python/Generated/AST/AlignedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[192]) || tp >= &(gTypes[193])) { + if (tp < &(gTypes[196]) || tp >= &(gTypes[197])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlignedAttr::static_kind(): - tp = &(gTypes[192]); + tp = &(gTypes[196]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -451,7 +451,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[192]); + PyTypeObject * const tp = &(gTypes[196]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -466,12 +466,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AllocAlignAttr.cpp b/bindings/Python/Generated/AST/AllocAlignAttr.cpp index 8d66dab85..ca20b773d 100644 --- a/bindings/Python/Generated/AST/AllocAlignAttr.cpp +++ b/bindings/Python/Generated/AST/AllocAlignAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[191]) || tp >= &(gTypes[192])) { + if (tp < &(gTypes[195]) || tp >= &(gTypes[196])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AllocAlignAttr::static_kind(): - tp = &(gTypes[191]); + tp = &(gTypes[195]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[191]); + PyTypeObject * const tp = &(gTypes[195]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AllocSizeAttr.cpp b/bindings/Python/Generated/AST/AllocSizeAttr.cpp index ca175b29b..5dd70711b 100644 --- a/bindings/Python/Generated/AST/AllocSizeAttr.cpp +++ b/bindings/Python/Generated/AST/AllocSizeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[190]) || tp >= &(gTypes[191])) { + if (tp < &(gTypes[194]) || tp >= &(gTypes[195])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AllocSizeAttr::static_kind(): - tp = &(gTypes[190]); + tp = &(gTypes[194]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[190]); + PyTypeObject * const tp = &(gTypes[194]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp b/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp index a4f6faf86..4b94ea396 100644 --- a/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp +++ b/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[189]) || tp >= &(gTypes[190])) { + if (tp < &(gTypes[193]) || tp >= &(gTypes[194])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlwaysDestroyAttr::static_kind(): - tp = &(gTypes[189]); + tp = &(gTypes[193]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[189]); + PyTypeObject * const tp = &(gTypes[193]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp b/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp index e00f1d268..0542b0a04 100644 --- a/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp +++ b/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[115]) || tp >= &(gTypes[116])) { + if (tp < &(gTypes[119]) || tp >= &(gTypes[120])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlwaysInlineAttr::static_kind(): - tp = &(gTypes[115]); + tp = &(gTypes[119]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[115]); + PyTypeObject * const tp = &(gTypes[119]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[114].tp_hash; - tp->tp_richcompare = gTypes[114].tp_richcompare; + tp->tp_hash = gTypes[118].tp_hash; + tp->tp_richcompare = gTypes[118].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[114]); + tp->tp_base = &(gTypes[118]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp b/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp index eb56d49bf..e3dabc1db 100644 --- a/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp +++ b/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[188]) || tp >= &(gTypes[189])) { + if (tp < &(gTypes[192]) || tp >= &(gTypes[193])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AnalyzerNoReturnAttr::static_kind(): - tp = &(gTypes[188]); + tp = &(gTypes[192]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[188]); + PyTypeObject * const tp = &(gTypes[192]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AnnotateAttr.cpp b/bindings/Python/Generated/AST/AnnotateAttr.cpp index 12c7fe4aa..1fef06c4d 100644 --- a/bindings/Python/Generated/AST/AnnotateAttr.cpp +++ b/bindings/Python/Generated/AST/AnnotateAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[395]) || tp >= &(gTypes[396])) { + if (tp < &(gTypes[399]) || tp >= &(gTypes[400])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AnnotateAttr::static_kind(): - tp = &(gTypes[395]); + tp = &(gTypes[399]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[395]); + PyTypeObject * const tp = &(gTypes[399]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp b/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp index 5cb07ce27..ee2f6b968 100644 --- a/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp +++ b/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[36]) || tp >= &(gTypes[37])) { + if (tp < &(gTypes[40]) || tp >= &(gTypes[41])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AnnotateTypeAttr::static_kind(): - tp = &(gTypes[36]); + tp = &(gTypes[40]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[36]); + PyTypeObject * const tp = &(gTypes[40]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp b/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp index 75ea402e1..e57b5c961 100644 --- a/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp +++ b/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[187]) || tp >= &(gTypes[188])) { + if (tp < &(gTypes[191]) || tp >= &(gTypes[192])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AnyX86InterruptAttr::static_kind(): - tp = &(gTypes[187]); + tp = &(gTypes[191]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[187]); + PyTypeObject * const tp = &(gTypes[191]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp b/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp index a7986dfad..bfc043964 100644 --- a/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp +++ b/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[186]) || tp >= &(gTypes[187])) { + if (tp < &(gTypes[190]) || tp >= &(gTypes[191])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AnyX86NoCallerSavedRegistersAttr::static_kind(): - tp = &(gTypes[186]); + tp = &(gTypes[190]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[186]); + PyTypeObject * const tp = &(gTypes[190]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp b/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp index 13ab7536c..a6f808b8a 100644 --- a/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp +++ b/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[185]) || tp >= &(gTypes[186])) { + if (tp < &(gTypes[189]) || tp >= &(gTypes[190])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AnyX86NoCfCheckAttr::static_kind(): - tp = &(gTypes[185]); + tp = &(gTypes[189]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[185]); + PyTypeObject * const tp = &(gTypes[189]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp b/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp index 23c1a26c2..547719d43 100644 --- a/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp +++ b/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[184]) || tp >= &(gTypes[185])) { + if (tp < &(gTypes[188]) || tp >= &(gTypes[189])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArcWeakrefUnavailableAttr::static_kind(): - tp = &(gTypes[184]); + tp = &(gTypes[188]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[184]); + PyTypeObject * const tp = &(gTypes[188]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp b/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp index a1a2abd2c..359f1e2e8 100644 --- a/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp +++ b/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[183]) || tp >= &(gTypes[184])) { + if (tp < &(gTypes[187]) || tp >= &(gTypes[188])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArgumentWithTypeTagAttr::static_kind(): - tp = &(gTypes[183]); + tp = &(gTypes[187]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[183]); + PyTypeObject * const tp = &(gTypes[187]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp b/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp index 5bcdbecdc..592826201 100644 --- a/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp +++ b/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[182]) || tp >= &(gTypes[183])) { + if (tp < &(gTypes[186]) || tp >= &(gTypes[187])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmBuiltinAliasAttr::static_kind(): - tp = &(gTypes[182]); + tp = &(gTypes[186]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[182]); + PyTypeObject * const tp = &(gTypes[186]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmInAttr.cpp b/bindings/Python/Generated/AST/ArmInAttr.cpp index 978c2a8f3..ded375259 100644 --- a/bindings/Python/Generated/AST/ArmInAttr.cpp +++ b/bindings/Python/Generated/AST/ArmInAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[35]) || tp >= &(gTypes[36])) { + if (tp < &(gTypes[39]) || tp >= &(gTypes[40])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmInAttr::static_kind(): - tp = &(gTypes[35]); + tp = &(gTypes[39]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[35]); + PyTypeObject * const tp = &(gTypes[39]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmInOutAttr.cpp b/bindings/Python/Generated/AST/ArmInOutAttr.cpp index 8f4f2cae9..49d9ad8b2 100644 --- a/bindings/Python/Generated/AST/ArmInOutAttr.cpp +++ b/bindings/Python/Generated/AST/ArmInOutAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[34]) || tp >= &(gTypes[35])) { + if (tp < &(gTypes[38]) || tp >= &(gTypes[39])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmInOutAttr::static_kind(): - tp = &(gTypes[34]); + tp = &(gTypes[38]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[34]); + PyTypeObject * const tp = &(gTypes[38]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp b/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp index 54d450b36..fd67174c0 100644 --- a/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp +++ b/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[181]) || tp >= &(gTypes[182])) { + if (tp < &(gTypes[185]) || tp >= &(gTypes[186])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmLocallyStreamingAttr::static_kind(): - tp = &(gTypes[181]); + tp = &(gTypes[185]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[181]); + PyTypeObject * const tp = &(gTypes[185]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp b/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp index 8ee8663c5..c49adbbd9 100644 --- a/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp +++ b/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[33]) || tp >= &(gTypes[34])) { + if (tp < &(gTypes[37]) || tp >= &(gTypes[38])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmMveStrictPolymorphismAttr::static_kind(): - tp = &(gTypes[33]); + tp = &(gTypes[37]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[33]); + PyTypeObject * const tp = &(gTypes[37]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmNewAttr.cpp b/bindings/Python/Generated/AST/ArmNewAttr.cpp index 1f0370d18..3792d9348 100644 --- a/bindings/Python/Generated/AST/ArmNewAttr.cpp +++ b/bindings/Python/Generated/AST/ArmNewAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[180]) || tp >= &(gTypes[181])) { + if (tp < &(gTypes[184]) || tp >= &(gTypes[185])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmNewAttr::static_kind(): - tp = &(gTypes[180]); + tp = &(gTypes[184]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[180]); + PyTypeObject * const tp = &(gTypes[184]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmOutAttr.cpp b/bindings/Python/Generated/AST/ArmOutAttr.cpp index 39dfa80f5..5a6ef349f 100644 --- a/bindings/Python/Generated/AST/ArmOutAttr.cpp +++ b/bindings/Python/Generated/AST/ArmOutAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[32]) || tp >= &(gTypes[33])) { + if (tp < &(gTypes[36]) || tp >= &(gTypes[37])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmOutAttr::static_kind(): - tp = &(gTypes[32]); + tp = &(gTypes[36]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[32]); + PyTypeObject * const tp = &(gTypes[36]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmPreservesAttr.cpp b/bindings/Python/Generated/AST/ArmPreservesAttr.cpp index 4481459bf..64dbdcefa 100644 --- a/bindings/Python/Generated/AST/ArmPreservesAttr.cpp +++ b/bindings/Python/Generated/AST/ArmPreservesAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[31]) || tp >= &(gTypes[32])) { + if (tp < &(gTypes[35]) || tp >= &(gTypes[36])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmPreservesAttr::static_kind(): - tp = &(gTypes[31]); + tp = &(gTypes[35]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[31]); + PyTypeObject * const tp = &(gTypes[35]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmStreamingAttr.cpp b/bindings/Python/Generated/AST/ArmStreamingAttr.cpp index da733a7a4..eabf399af 100644 --- a/bindings/Python/Generated/AST/ArmStreamingAttr.cpp +++ b/bindings/Python/Generated/AST/ArmStreamingAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[30]) || tp >= &(gTypes[31])) { + if (tp < &(gTypes[34]) || tp >= &(gTypes[35])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmStreamingAttr::static_kind(): - tp = &(gTypes[30]); + tp = &(gTypes[34]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[30]); + PyTypeObject * const tp = &(gTypes[34]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp b/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp index c844f9fa3..37c12b409 100644 --- a/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp +++ b/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[29]) || tp >= &(gTypes[30])) { + if (tp < &(gTypes[33]) || tp >= &(gTypes[34])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArmStreamingCompatibleAttr::static_kind(): - tp = &(gTypes[29]); + tp = &(gTypes[33]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[29]); + PyTypeObject * const tp = &(gTypes[33]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp b/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp index c80ec4b3d..ac2909371 100644 --- a/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp +++ b/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[649]) || tp >= &(gTypes[650])) { + if (tp < &(gTypes[653]) || tp >= &(gTypes[654])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArrayInitIndexExpr::static_kind(): - tp = &(gTypes[649]); + tp = &(gTypes[653]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[649]); + PyTypeObject * const tp = &(gTypes[653]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp b/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp index 8aa7490df..855c69029 100644 --- a/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp +++ b/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[648]) || tp >= &(gTypes[649])) { + if (tp < &(gTypes[652]) || tp >= &(gTypes[653])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArrayInitLoopExpr::static_kind(): - tp = &(gTypes[648]); + tp = &(gTypes[652]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[648]); + PyTypeObject * const tp = &(gTypes[652]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp b/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp index c20d73c49..5a803667a 100644 --- a/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp +++ b/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[647]) || tp >= &(gTypes[648])) { + if (tp < &(gTypes[651]) || tp >= &(gTypes[652])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArraySubscriptExpr::static_kind(): - tp = &(gTypes[647]); + tp = &(gTypes[651]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[647]); + PyTypeObject * const tp = &(gTypes[651]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArrayType.cpp b/bindings/Python/Generated/AST/ArrayType.cpp index 8ad04273f..27f6b9812 100644 --- a/bindings/Python/Generated/AST/ArrayType.cpp +++ b/bindings/Python/Generated/AST/ArrayType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[454]) || tp >= &(gTypes[459])) { + if (tp < &(gTypes[458]) || tp >= &(gTypes[463])) { return std::nullopt; } @@ -88,19 +88,19 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VariableArrayType::static_kind(): - tp = &(gTypes[455]); + tp = &(gTypes[459]); break; case mx::IncompleteArrayType::static_kind(): - tp = &(gTypes[456]); + tp = &(gTypes[460]); break; case mx::DependentSizedArrayType::static_kind(): - tp = &(gTypes[457]); + tp = &(gTypes[461]); break; case mx::ConstantArrayType::static_kind(): - tp = &(gTypes[458]); + tp = &(gTypes[462]); break; } @@ -288,7 +288,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -340,7 +340,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[454]); + PyTypeObject * const tp = &(gTypes[458]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -355,12 +355,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp b/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp index 89c739ef6..4542e7a0b 100644 --- a/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp +++ b/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[646]) || tp >= &(gTypes[647])) { + if (tp < &(gTypes[650]) || tp >= &(gTypes[651])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArrayTypeTraitExpr::static_kind(): - tp = &(gTypes[646]); + tp = &(gTypes[650]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[646]); + PyTypeObject * const tp = &(gTypes[650]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ArtificialAttr.cpp b/bindings/Python/Generated/AST/ArtificialAttr.cpp index 0be84672e..fe64795a0 100644 --- a/bindings/Python/Generated/AST/ArtificialAttr.cpp +++ b/bindings/Python/Generated/AST/ArtificialAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[179]) || tp >= &(gTypes[180])) { + if (tp < &(gTypes[183]) || tp >= &(gTypes[184])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ArtificialAttr::static_kind(): - tp = &(gTypes[179]); + tp = &(gTypes[183]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[179]); + PyTypeObject * const tp = &(gTypes[183]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AsTypeExpr.cpp b/bindings/Python/Generated/AST/AsTypeExpr.cpp index be16dd38e..f9f8fc873 100644 --- a/bindings/Python/Generated/AST/AsTypeExpr.cpp +++ b/bindings/Python/Generated/AST/AsTypeExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[645]) || tp >= &(gTypes[646])) { + if (tp < &(gTypes[649]) || tp >= &(gTypes[650])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AsTypeExpr::static_kind(): - tp = &(gTypes[645]); + tp = &(gTypes[649]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[645]); + PyTypeObject * const tp = &(gTypes[649]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AsmLabelAttr.cpp b/bindings/Python/Generated/AST/AsmLabelAttr.cpp index aedde84fd..16daf1ed6 100644 --- a/bindings/Python/Generated/AST/AsmLabelAttr.cpp +++ b/bindings/Python/Generated/AST/AsmLabelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[178]) || tp >= &(gTypes[179])) { + if (tp < &(gTypes[182]) || tp >= &(gTypes[183])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AsmLabelAttr::static_kind(): - tp = &(gTypes[178]); + tp = &(gTypes[182]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[178]); + PyTypeObject * const tp = &(gTypes[182]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AsmStmt.cpp b/bindings/Python/Generated/AST/AsmStmt.cpp index c33143da2..b12e025c1 100644 --- a/bindings/Python/Generated/AST/AsmStmt.cpp +++ b/bindings/Python/Generated/AST/AsmStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[580]) || tp >= &(gTypes[583])) { + if (tp < &(gTypes[584]) || tp >= &(gTypes[587])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSAsmStmt::static_kind(): - tp = &(gTypes[581]); + tp = &(gTypes[585]); break; case mx::GCCAsmStmt::static_kind(): - tp = &(gTypes[582]); + tp = &(gTypes[586]); break; } @@ -456,7 +456,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -574,7 +574,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[580]); + PyTypeObject * const tp = &(gTypes[584]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -589,12 +589,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp b/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp index 755fce32c..99492e035 100644 --- a/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp +++ b/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[177]) || tp >= &(gTypes[178])) { + if (tp < &(gTypes[181]) || tp >= &(gTypes[182])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AssertCapabilityAttr::static_kind(): - tp = &(gTypes[177]); + tp = &(gTypes[181]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[177]); + PyTypeObject * const tp = &(gTypes[181]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp b/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp index 0b58f21cb..3f05ee60d 100644 --- a/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp +++ b/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[176]) || tp >= &(gTypes[177])) { + if (tp < &(gTypes[180]) || tp >= &(gTypes[181])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AssertExclusiveLockAttr::static_kind(): - tp = &(gTypes[176]); + tp = &(gTypes[180]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[176]); + PyTypeObject * const tp = &(gTypes[180]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp b/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp index da1169cb2..655c99322 100644 --- a/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp +++ b/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[175]) || tp >= &(gTypes[176])) { + if (tp < &(gTypes[179]) || tp >= &(gTypes[180])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AssertSharedLockAttr::static_kind(): - tp = &(gTypes[175]); + tp = &(gTypes[179]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[175]); + PyTypeObject * const tp = &(gTypes[179]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp b/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp index 6087cecc5..ae9c41a93 100644 --- a/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp +++ b/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[174]) || tp >= &(gTypes[175])) { + if (tp < &(gTypes[178]) || tp >= &(gTypes[179])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AssumeAlignedAttr::static_kind(): - tp = &(gTypes[174]); + tp = &(gTypes[178]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[174]); + PyTypeObject * const tp = &(gTypes[178]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AssumptionAttr.cpp b/bindings/Python/Generated/AST/AssumptionAttr.cpp index 8f412fd46..8de8f95c6 100644 --- a/bindings/Python/Generated/AST/AssumptionAttr.cpp +++ b/bindings/Python/Generated/AST/AssumptionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[173]) || tp >= &(gTypes[174])) { + if (tp < &(gTypes[177]) || tp >= &(gTypes[178])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AssumptionAttr::static_kind(): - tp = &(gTypes[173]); + tp = &(gTypes[177]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[173]); + PyTypeObject * const tp = &(gTypes[177]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AtomicExpr.cpp b/bindings/Python/Generated/AST/AtomicExpr.cpp index 8b2166eac..c0b46e6d2 100644 --- a/bindings/Python/Generated/AST/AtomicExpr.cpp +++ b/bindings/Python/Generated/AST/AtomicExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[644]) || tp >= &(gTypes[645])) { + if (tp < &(gTypes[648]) || tp >= &(gTypes[649])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AtomicExpr::static_kind(): - tp = &(gTypes[644]); + tp = &(gTypes[648]); break; } @@ -489,7 +489,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -541,7 +541,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[644]); + PyTypeObject * const tp = &(gTypes[648]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -556,12 +556,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AtomicType.cpp b/bindings/Python/Generated/AST/AtomicType.cpp index 3477bb191..20fbdc350 100644 --- a/bindings/Python/Generated/AST/AtomicType.cpp +++ b/bindings/Python/Generated/AST/AtomicType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[453]) || tp >= &(gTypes[454])) { + if (tp < &(gTypes[457]) || tp >= &(gTypes[458])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AtomicType::static_kind(): - tp = &(gTypes[453]); + tp = &(gTypes[457]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[453]); + PyTypeObject * const tp = &(gTypes[457]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Attr.cpp b/bindings/Python/Generated/AST/Attr.cpp index bba4c3770..15863c891 100644 --- a/bindings/Python/Generated/AST/Attr.cpp +++ b/bindings/Python/Generated/AST/Attr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[6]) || tp >= &(gTypes[410])) { + if (tp < &(gTypes[10]) || tp >= &(gTypes[414])) { return std::nullopt; } @@ -88,1587 +88,1587 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlignValueAttr::static_kind(): - tp = &(gTypes[7]); + tp = &(gTypes[11]); break; case mx::AliasAttr::static_kind(): - tp = &(gTypes[8]); + tp = &(gTypes[12]); break; case mx::AbiTagAttr::static_kind(): - tp = &(gTypes[9]); + tp = &(gTypes[13]); break; case mx::SPtrAttr::static_kind(): - tp = &(gTypes[11]); + tp = &(gTypes[15]); break; case mx::Ptr64Attr::static_kind(): - tp = &(gTypes[12]); + tp = &(gTypes[16]); break; case mx::Ptr32Attr::static_kind(): - tp = &(gTypes[13]); + tp = &(gTypes[17]); break; case mx::OpenCLPrivateAddressSpaceAttr::static_kind(): - tp = &(gTypes[14]); + tp = &(gTypes[18]); break; case mx::OpenCLLocalAddressSpaceAttr::static_kind(): - tp = &(gTypes[15]); + tp = &(gTypes[19]); break; case mx::OpenCLGlobalHostAddressSpaceAttr::static_kind(): - tp = &(gTypes[16]); + tp = &(gTypes[20]); break; case mx::OpenCLGlobalDeviceAddressSpaceAttr::static_kind(): - tp = &(gTypes[17]); + tp = &(gTypes[21]); break; case mx::OpenCLGlobalAddressSpaceAttr::static_kind(): - tp = &(gTypes[18]); + tp = &(gTypes[22]); break; case mx::OpenCLGenericAddressSpaceAttr::static_kind(): - tp = &(gTypes[19]); + tp = &(gTypes[23]); break; case mx::OpenCLConstantAddressSpaceAttr::static_kind(): - tp = &(gTypes[20]); + tp = &(gTypes[24]); break; case mx::ObjCKindOfAttr::static_kind(): - tp = &(gTypes[21]); + tp = &(gTypes[25]); break; case mx::ObjCInertUnsafeUnretainedAttr::static_kind(): - tp = &(gTypes[22]); + tp = &(gTypes[26]); break; case mx::ObjCGCAttr::static_kind(): - tp = &(gTypes[23]); + tp = &(gTypes[27]); break; case mx::NoDerefAttr::static_kind(): - tp = &(gTypes[24]); + tp = &(gTypes[28]); break; case mx::HLSLParamModifierAttr::static_kind(): - tp = &(gTypes[25]); + tp = &(gTypes[29]); break; case mx::HLSLGroupSharedAddressSpaceAttr::static_kind(): - tp = &(gTypes[26]); + tp = &(gTypes[30]); break; case mx::CmseNSCallAttr::static_kind(): - tp = &(gTypes[27]); + tp = &(gTypes[31]); break; case mx::BTFTypeTagAttr::static_kind(): - tp = &(gTypes[28]); + tp = &(gTypes[32]); break; case mx::ArmStreamingCompatibleAttr::static_kind(): - tp = &(gTypes[29]); + tp = &(gTypes[33]); break; case mx::ArmStreamingAttr::static_kind(): - tp = &(gTypes[30]); + tp = &(gTypes[34]); break; case mx::ArmPreservesAttr::static_kind(): - tp = &(gTypes[31]); + tp = &(gTypes[35]); break; case mx::ArmOutAttr::static_kind(): - tp = &(gTypes[32]); + tp = &(gTypes[36]); break; case mx::ArmMveStrictPolymorphismAttr::static_kind(): - tp = &(gTypes[33]); + tp = &(gTypes[37]); break; case mx::ArmInOutAttr::static_kind(): - tp = &(gTypes[34]); + tp = &(gTypes[38]); break; case mx::ArmInAttr::static_kind(): - tp = &(gTypes[35]); + tp = &(gTypes[39]); break; case mx::AnnotateTypeAttr::static_kind(): - tp = &(gTypes[36]); + tp = &(gTypes[40]); break; case mx::AddressSpaceAttr::static_kind(): - tp = &(gTypes[37]); + tp = &(gTypes[41]); break; case mx::WebAssemblyFuncrefAttr::static_kind(): - tp = &(gTypes[38]); + tp = &(gTypes[42]); break; case mx::UPtrAttr::static_kind(): - tp = &(gTypes[39]); + tp = &(gTypes[43]); break; case mx::TypeNullableResultAttr::static_kind(): - tp = &(gTypes[40]); + tp = &(gTypes[44]); break; case mx::TypeNullableAttr::static_kind(): - tp = &(gTypes[41]); + tp = &(gTypes[45]); break; case mx::TypeNullUnspecifiedAttr::static_kind(): - tp = &(gTypes[42]); + tp = &(gTypes[46]); break; case mx::TypeNonNullAttr::static_kind(): - tp = &(gTypes[43]); + tp = &(gTypes[47]); break; case mx::ThreadAttr::static_kind(): - tp = &(gTypes[44]); + tp = &(gTypes[48]); break; case mx::SwiftVersionedRemovalAttr::static_kind(): - tp = &(gTypes[45]); + tp = &(gTypes[49]); break; case mx::SwiftVersionedAdditionAttr::static_kind(): - tp = &(gTypes[46]); + tp = &(gTypes[50]); break; case mx::SwiftObjCMembersAttr::static_kind(): - tp = &(gTypes[47]); + tp = &(gTypes[51]); break; case mx::OpenCLUnrollHintAttr::static_kind(): - tp = &(gTypes[49]); + tp = &(gTypes[53]); break; case mx::MustTailAttr::static_kind(): - tp = &(gTypes[50]); + tp = &(gTypes[54]); break; case mx::LikelyAttr::static_kind(): - tp = &(gTypes[51]); + tp = &(gTypes[55]); break; case mx::FallThroughAttr::static_kind(): - tp = &(gTypes[52]); + tp = &(gTypes[56]); break; case mx::CodeAlignAttr::static_kind(): - tp = &(gTypes[53]); + tp = &(gTypes[57]); break; case mx::UnlikelyAttr::static_kind(): - tp = &(gTypes[54]); + tp = &(gTypes[58]); break; case mx::RenderScriptKernelAttr::static_kind(): - tp = &(gTypes[55]); + tp = &(gTypes[59]); break; case mx::OverloadableAttr::static_kind(): - tp = &(gTypes[56]); + tp = &(gTypes[60]); break; case mx::OpenCLAccessAttr::static_kind(): - tp = &(gTypes[57]); + tp = &(gTypes[61]); break; case mx::ObjCRuntimeVisibleAttr::static_kind(): - tp = &(gTypes[58]); + tp = &(gTypes[62]); break; case mx::ObjCRuntimeNameAttr::static_kind(): - tp = &(gTypes[59]); + tp = &(gTypes[63]); break; case mx::ObjCNonRuntimeProtocolAttr::static_kind(): - tp = &(gTypes[60]); + tp = &(gTypes[64]); break; case mx::ObjCNonLazyClassAttr::static_kind(): - tp = &(gTypes[61]); + tp = &(gTypes[65]); break; case mx::ObjCDirectMembersAttr::static_kind(): - tp = &(gTypes[62]); + tp = &(gTypes[66]); break; case mx::ObjCDirectAttr::static_kind(): - tp = &(gTypes[63]); + tp = &(gTypes[67]); break; case mx::ObjCDesignatedInitializerAttr::static_kind(): - tp = &(gTypes[64]); + tp = &(gTypes[68]); break; case mx::ObjCClassStubAttr::static_kind(): - tp = &(gTypes[65]); + tp = &(gTypes[69]); break; case mx::ObjCBoxableAttr::static_kind(): - tp = &(gTypes[66]); + tp = &(gTypes[70]); break; case mx::OMPReferencedVarAttr::static_kind(): - tp = &(gTypes[67]); + tp = &(gTypes[71]); break; case mx::OMPDeclareSimdDeclAttr::static_kind(): - tp = &(gTypes[68]); + tp = &(gTypes[72]); break; case mx::OMPCaptureKindAttr::static_kind(): - tp = &(gTypes[69]); + tp = &(gTypes[73]); break; case mx::NoEscapeAttr::static_kind(): - tp = &(gTypes[70]); + tp = &(gTypes[74]); break; case mx::NoBuiltinAttr::static_kind(): - tp = &(gTypes[71]); + tp = &(gTypes[75]); break; case mx::ModeAttr::static_kind(): - tp = &(gTypes[72]); + tp = &(gTypes[76]); break; case mx::LoopHintAttr::static_kind(): - tp = &(gTypes[73]); + tp = &(gTypes[77]); break; case mx::LoaderUninitializedAttr::static_kind(): - tp = &(gTypes[74]); + tp = &(gTypes[78]); break; case mx::InitSegAttr::static_kind(): - tp = &(gTypes[75]); + tp = &(gTypes[79]); break; case mx::IBOutletCollectionAttr::static_kind(): - tp = &(gTypes[77]); + tp = &(gTypes[81]); break; case mx::IBOutletAttr::static_kind(): - tp = &(gTypes[78]); + tp = &(gTypes[82]); break; case mx::IBActionAttr::static_kind(): - tp = &(gTypes[79]); + tp = &(gTypes[83]); break; case mx::HotAttr::static_kind(): - tp = &(gTypes[80]); + tp = &(gTypes[84]); break; case mx::HLSLShaderAttr::static_kind(): - tp = &(gTypes[81]); + tp = &(gTypes[85]); break; case mx::HLSLResourceBindingAttr::static_kind(): - tp = &(gTypes[82]); + tp = &(gTypes[86]); break; case mx::HLSLResourceAttr::static_kind(): - tp = &(gTypes[83]); + tp = &(gTypes[87]); break; case mx::HLSLNumThreadsAttr::static_kind(): - tp = &(gTypes[84]); + tp = &(gTypes[88]); break; case mx::HLSLSV_GroupIndexAttr::static_kind(): - tp = &(gTypes[86]); + tp = &(gTypes[90]); break; case mx::HLSLSV_DispatchThreadIDAttr::static_kind(): - tp = &(gTypes[87]); + tp = &(gTypes[91]); break; case mx::HIPManagedAttr::static_kind(): - tp = &(gTypes[88]); + tp = &(gTypes[92]); break; case mx::GuardedVarAttr::static_kind(): - tp = &(gTypes[89]); + tp = &(gTypes[93]); break; case mx::GuardedByAttr::static_kind(): - tp = &(gTypes[90]); + tp = &(gTypes[94]); break; case mx::GNUInlineAttr::static_kind(): - tp = &(gTypes[91]); + tp = &(gTypes[95]); break; case mx::FunctionReturnThunksAttr::static_kind(): - tp = &(gTypes[92]); + tp = &(gTypes[96]); break; case mx::FormatAttr::static_kind(): - tp = &(gTypes[93]); + tp = &(gTypes[97]); break; case mx::FormatArgAttr::static_kind(): - tp = &(gTypes[94]); + tp = &(gTypes[98]); break; case mx::FlattenAttr::static_kind(): - tp = &(gTypes[95]); + tp = &(gTypes[99]); break; case mx::FlagEnumAttr::static_kind(): - tp = &(gTypes[96]); + tp = &(gTypes[100]); break; case mx::FinalAttr::static_kind(): - tp = &(gTypes[97]); + tp = &(gTypes[101]); break; case mx::FastCallAttr::static_kind(): - tp = &(gTypes[98]); + tp = &(gTypes[102]); break; case mx::ExternalSourceSymbolAttr::static_kind(): - tp = &(gTypes[99]); + tp = &(gTypes[103]); break; case mx::ExclusiveTrylockFunctionAttr::static_kind(): - tp = &(gTypes[100]); + tp = &(gTypes[104]); break; case mx::ExcludeFromExplicitInstantiationAttr::static_kind(): - tp = &(gTypes[101]); + tp = &(gTypes[105]); break; case mx::ErrorAttr::static_kind(): - tp = &(gTypes[102]); + tp = &(gTypes[106]); break; case mx::EnumExtensibilityAttr::static_kind(): - tp = &(gTypes[103]); + tp = &(gTypes[107]); break; case mx::EnforceTCBLeafAttr::static_kind(): - tp = &(gTypes[104]); + tp = &(gTypes[108]); break; case mx::EnforceTCBAttr::static_kind(): - tp = &(gTypes[105]); + tp = &(gTypes[109]); break; case mx::EnableIfAttr::static_kind(): - tp = &(gTypes[106]); + tp = &(gTypes[110]); break; case mx::EmptyBasesAttr::static_kind(): - tp = &(gTypes[107]); + tp = &(gTypes[111]); break; case mx::DisableTailCallsAttr::static_kind(): - tp = &(gTypes[108]); + tp = &(gTypes[112]); break; case mx::DisableSanitizerInstrumentationAttr::static_kind(): - tp = &(gTypes[109]); + tp = &(gTypes[113]); break; case mx::DiagnoseIfAttr::static_kind(): - tp = &(gTypes[110]); + tp = &(gTypes[114]); break; case mx::DiagnoseAsBuiltinAttr::static_kind(): - tp = &(gTypes[111]); + tp = &(gTypes[115]); break; case mx::DestructorAttr::static_kind(): - tp = &(gTypes[112]); + tp = &(gTypes[116]); break; case mx::DeprecatedAttr::static_kind(): - tp = &(gTypes[113]); + tp = &(gTypes[117]); break; case mx::AlwaysInlineAttr::static_kind(): - tp = &(gTypes[115]); + tp = &(gTypes[119]); break; case mx::SuppressAttr::static_kind(): - tp = &(gTypes[116]); + tp = &(gTypes[120]); break; case mx::NoMergeAttr::static_kind(): - tp = &(gTypes[117]); + tp = &(gTypes[121]); break; case mx::NoInlineAttr::static_kind(): - tp = &(gTypes[118]); + tp = &(gTypes[122]); break; case mx::DLLImportStaticLocalAttr::static_kind(): - tp = &(gTypes[119]); + tp = &(gTypes[123]); break; case mx::DLLImportAttr::static_kind(): - tp = &(gTypes[120]); + tp = &(gTypes[124]); break; case mx::DLLExportStaticLocalAttr::static_kind(): - tp = &(gTypes[121]); + tp = &(gTypes[125]); break; case mx::DLLExportAttr::static_kind(): - tp = &(gTypes[122]); + tp = &(gTypes[126]); break; case mx::CountedByAttr::static_kind(): - tp = &(gTypes[123]); + tp = &(gTypes[127]); break; case mx::CoroWrapperAttr::static_kind(): - tp = &(gTypes[124]); + tp = &(gTypes[128]); break; case mx::CoroReturnTypeAttr::static_kind(): - tp = &(gTypes[125]); + tp = &(gTypes[129]); break; case mx::CoroOnlyDestroyWhenCompleteAttr::static_kind(): - tp = &(gTypes[126]); + tp = &(gTypes[130]); break; case mx::CoroLifetimeBoundAttr::static_kind(): - tp = &(gTypes[127]); + tp = &(gTypes[131]); break; case mx::CoroDisableLifetimeBoundAttr::static_kind(): - tp = &(gTypes[128]); + tp = &(gTypes[132]); break; case mx::ConvergentAttr::static_kind(): - tp = &(gTypes[129]); + tp = &(gTypes[133]); break; case mx::ConsumableSetOnReadAttr::static_kind(): - tp = &(gTypes[130]); + tp = &(gTypes[134]); break; case mx::ConsumableAutoCastAttr::static_kind(): - tp = &(gTypes[131]); + tp = &(gTypes[135]); break; case mx::ConsumableAttr::static_kind(): - tp = &(gTypes[132]); + tp = &(gTypes[136]); break; case mx::ConstructorAttr::static_kind(): - tp = &(gTypes[133]); + tp = &(gTypes[137]); break; case mx::ConstInitAttr::static_kind(): - tp = &(gTypes[134]); + tp = &(gTypes[138]); break; case mx::ConstAttr::static_kind(): - tp = &(gTypes[135]); + tp = &(gTypes[139]); break; case mx::CommonAttr::static_kind(): - tp = &(gTypes[136]); + tp = &(gTypes[140]); break; case mx::ColdAttr::static_kind(): - tp = &(gTypes[137]); + tp = &(gTypes[141]); break; case mx::CodeSegAttr::static_kind(): - tp = &(gTypes[138]); + tp = &(gTypes[142]); break; case mx::CodeModelAttr::static_kind(): - tp = &(gTypes[139]); + tp = &(gTypes[143]); break; case mx::CmseNSEntryAttr::static_kind(): - tp = &(gTypes[140]); + tp = &(gTypes[144]); break; case mx::CleanupAttr::static_kind(): - tp = &(gTypes[141]); + tp = &(gTypes[145]); break; case mx::CapturedRecordAttr::static_kind(): - tp = &(gTypes[142]); + tp = &(gTypes[146]); break; case mx::CapabilityAttr::static_kind(): - tp = &(gTypes[143]); + tp = &(gTypes[147]); break; case mx::CallbackAttr::static_kind(): - tp = &(gTypes[144]); + tp = &(gTypes[148]); break; case mx::CallableWhenAttr::static_kind(): - tp = &(gTypes[145]); + tp = &(gTypes[149]); break; case mx::CXX11NoReturnAttr::static_kind(): - tp = &(gTypes[146]); + tp = &(gTypes[150]); break; case mx::CUDASharedAttr::static_kind(): - tp = &(gTypes[147]); + tp = &(gTypes[151]); break; case mx::CUDALaunchBoundsAttr::static_kind(): - tp = &(gTypes[148]); + tp = &(gTypes[152]); break; case mx::CUDAInvalidTargetAttr::static_kind(): - tp = &(gTypes[149]); + tp = &(gTypes[153]); break; case mx::CUDAHostAttr::static_kind(): - tp = &(gTypes[150]); + tp = &(gTypes[154]); break; case mx::CUDAGlobalAttr::static_kind(): - tp = &(gTypes[151]); + tp = &(gTypes[155]); break; case mx::CUDADeviceBuiltinTextureTypeAttr::static_kind(): - tp = &(gTypes[152]); + tp = &(gTypes[156]); break; case mx::CUDADeviceBuiltinSurfaceTypeAttr::static_kind(): - tp = &(gTypes[153]); + tp = &(gTypes[157]); break; case mx::CUDADeviceAttr::static_kind(): - tp = &(gTypes[154]); + tp = &(gTypes[158]); break; case mx::CUDAConstantAttr::static_kind(): - tp = &(gTypes[155]); + tp = &(gTypes[159]); break; case mx::CPUSpecificAttr::static_kind(): - tp = &(gTypes[156]); + tp = &(gTypes[160]); break; case mx::CPUDispatchAttr::static_kind(): - tp = &(gTypes[157]); + tp = &(gTypes[161]); break; case mx::CFUnknownTransferAttr::static_kind(): - tp = &(gTypes[158]); + tp = &(gTypes[162]); break; case mx::CFReturnsRetainedAttr::static_kind(): - tp = &(gTypes[159]); + tp = &(gTypes[163]); break; case mx::CFReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[160]); + tp = &(gTypes[164]); break; case mx::CFICanonicalJumpTableAttr::static_kind(): - tp = &(gTypes[161]); + tp = &(gTypes[165]); break; case mx::CFGuardAttr::static_kind(): - tp = &(gTypes[162]); + tp = &(gTypes[166]); break; case mx::CFAuditedTransferAttr::static_kind(): - tp = &(gTypes[163]); + tp = &(gTypes[167]); break; case mx::CDeclAttr::static_kind(): - tp = &(gTypes[164]); + tp = &(gTypes[168]); break; case mx::C11NoReturnAttr::static_kind(): - tp = &(gTypes[165]); + tp = &(gTypes[169]); break; case mx::BuiltinAttr::static_kind(): - tp = &(gTypes[166]); + tp = &(gTypes[170]); break; case mx::BlocksAttr::static_kind(): - tp = &(gTypes[167]); + tp = &(gTypes[171]); break; case mx::BTFDeclTagAttr::static_kind(): - tp = &(gTypes[168]); + tp = &(gTypes[172]); break; case mx::BPFPreserveStaticOffsetAttr::static_kind(): - tp = &(gTypes[169]); + tp = &(gTypes[173]); break; case mx::BPFPreserveAccessIndexAttr::static_kind(): - tp = &(gTypes[170]); + tp = &(gTypes[174]); break; case mx::AvailableOnlyInDefaultEvalMethodAttr::static_kind(): - tp = &(gTypes[171]); + tp = &(gTypes[175]); break; case mx::AvailabilityAttr::static_kind(): - tp = &(gTypes[172]); + tp = &(gTypes[176]); break; case mx::AssumptionAttr::static_kind(): - tp = &(gTypes[173]); + tp = &(gTypes[177]); break; case mx::AssumeAlignedAttr::static_kind(): - tp = &(gTypes[174]); + tp = &(gTypes[178]); break; case mx::AssertSharedLockAttr::static_kind(): - tp = &(gTypes[175]); + tp = &(gTypes[179]); break; case mx::AssertExclusiveLockAttr::static_kind(): - tp = &(gTypes[176]); + tp = &(gTypes[180]); break; case mx::AssertCapabilityAttr::static_kind(): - tp = &(gTypes[177]); + tp = &(gTypes[181]); break; case mx::AsmLabelAttr::static_kind(): - tp = &(gTypes[178]); + tp = &(gTypes[182]); break; case mx::ArtificialAttr::static_kind(): - tp = &(gTypes[179]); + tp = &(gTypes[183]); break; case mx::ArmNewAttr::static_kind(): - tp = &(gTypes[180]); + tp = &(gTypes[184]); break; case mx::ArmLocallyStreamingAttr::static_kind(): - tp = &(gTypes[181]); + tp = &(gTypes[185]); break; case mx::ArmBuiltinAliasAttr::static_kind(): - tp = &(gTypes[182]); + tp = &(gTypes[186]); break; case mx::ArgumentWithTypeTagAttr::static_kind(): - tp = &(gTypes[183]); + tp = &(gTypes[187]); break; case mx::ArcWeakrefUnavailableAttr::static_kind(): - tp = &(gTypes[184]); + tp = &(gTypes[188]); break; case mx::AnyX86NoCfCheckAttr::static_kind(): - tp = &(gTypes[185]); + tp = &(gTypes[189]); break; case mx::AnyX86NoCallerSavedRegistersAttr::static_kind(): - tp = &(gTypes[186]); + tp = &(gTypes[190]); break; case mx::AnyX86InterruptAttr::static_kind(): - tp = &(gTypes[187]); + tp = &(gTypes[191]); break; case mx::AnalyzerNoReturnAttr::static_kind(): - tp = &(gTypes[188]); + tp = &(gTypes[192]); break; case mx::AlwaysDestroyAttr::static_kind(): - tp = &(gTypes[189]); + tp = &(gTypes[193]); break; case mx::AllocSizeAttr::static_kind(): - tp = &(gTypes[190]); + tp = &(gTypes[194]); break; case mx::AllocAlignAttr::static_kind(): - tp = &(gTypes[191]); + tp = &(gTypes[195]); break; case mx::AlignedAttr::static_kind(): - tp = &(gTypes[192]); + tp = &(gTypes[196]); break; case mx::AlignNaturalAttr::static_kind(): - tp = &(gTypes[193]); + tp = &(gTypes[197]); break; case mx::AlignMac68kAttr::static_kind(): - tp = &(gTypes[194]); + tp = &(gTypes[198]); break; case mx::AcquiredBeforeAttr::static_kind(): - tp = &(gTypes[195]); + tp = &(gTypes[199]); break; case mx::AcquiredAfterAttr::static_kind(): - tp = &(gTypes[196]); + tp = &(gTypes[200]); break; case mx::AcquireHandleAttr::static_kind(): - tp = &(gTypes[197]); + tp = &(gTypes[201]); break; case mx::AcquireCapabilityAttr::static_kind(): - tp = &(gTypes[198]); + tp = &(gTypes[202]); break; case mx::AVRSignalAttr::static_kind(): - tp = &(gTypes[199]); + tp = &(gTypes[203]); break; case mx::AVRInterruptAttr::static_kind(): - tp = &(gTypes[200]); + tp = &(gTypes[204]); break; case mx::ARMInterruptAttr::static_kind(): - tp = &(gTypes[201]); + tp = &(gTypes[205]); break; case mx::AMDGPUWavesPerEUAttr::static_kind(): - tp = &(gTypes[202]); + tp = &(gTypes[206]); break; case mx::AMDGPUNumVGPRAttr::static_kind(): - tp = &(gTypes[203]); + tp = &(gTypes[207]); break; case mx::AMDGPUNumSGPRAttr::static_kind(): - tp = &(gTypes[204]); + tp = &(gTypes[208]); break; case mx::AMDGPUKernelCallAttr::static_kind(): - tp = &(gTypes[205]); + tp = &(gTypes[209]); break; case mx::AMDGPUFlatWorkGroupSizeAttr::static_kind(): - tp = &(gTypes[206]); + tp = &(gTypes[210]); break; case mx::AArch64VectorPcsAttr::static_kind(): - tp = &(gTypes[207]); + tp = &(gTypes[211]); break; case mx::AArch64SVEPcsAttr::static_kind(): - tp = &(gTypes[208]); + tp = &(gTypes[212]); break; case mx::ZeroCallUsedRegsAttr::static_kind(): - tp = &(gTypes[209]); + tp = &(gTypes[213]); break; case mx::XRayLogArgsAttr::static_kind(): - tp = &(gTypes[210]); + tp = &(gTypes[214]); break; case mx::XRayInstrumentAttr::static_kind(): - tp = &(gTypes[211]); + tp = &(gTypes[215]); break; case mx::X86ForceAlignArgPointerAttr::static_kind(): - tp = &(gTypes[212]); + tp = &(gTypes[216]); break; case mx::WorkGroupSizeHintAttr::static_kind(): - tp = &(gTypes[213]); + tp = &(gTypes[217]); break; case mx::WebAssemblyImportNameAttr::static_kind(): - tp = &(gTypes[214]); + tp = &(gTypes[218]); break; case mx::WebAssemblyImportModuleAttr::static_kind(): - tp = &(gTypes[215]); + tp = &(gTypes[219]); break; case mx::WebAssemblyExportNameAttr::static_kind(): - tp = &(gTypes[216]); + tp = &(gTypes[220]); break; case mx::WeakRefAttr::static_kind(): - tp = &(gTypes[217]); + tp = &(gTypes[221]); break; case mx::WeakImportAttr::static_kind(): - tp = &(gTypes[218]); + tp = &(gTypes[222]); break; case mx::WeakAttr::static_kind(): - tp = &(gTypes[219]); + tp = &(gTypes[223]); break; case mx::WarnUnusedResultAttr::static_kind(): - tp = &(gTypes[220]); + tp = &(gTypes[224]); break; case mx::WarnUnusedAttr::static_kind(): - tp = &(gTypes[221]); + tp = &(gTypes[225]); break; case mx::VisibilityAttr::static_kind(): - tp = &(gTypes[222]); + tp = &(gTypes[226]); break; case mx::VectorCallAttr::static_kind(): - tp = &(gTypes[223]); + tp = &(gTypes[227]); break; case mx::VecTypeHintAttr::static_kind(): - tp = &(gTypes[224]); + tp = &(gTypes[228]); break; case mx::VecReturnAttr::static_kind(): - tp = &(gTypes[225]); + tp = &(gTypes[229]); break; case mx::UuidAttr::static_kind(): - tp = &(gTypes[226]); + tp = &(gTypes[230]); break; case mx::UsingIfExistsAttr::static_kind(): - tp = &(gTypes[227]); + tp = &(gTypes[231]); break; case mx::UsedAttr::static_kind(): - tp = &(gTypes[228]); + tp = &(gTypes[232]); break; case mx::UnusedAttr::static_kind(): - tp = &(gTypes[229]); + tp = &(gTypes[233]); break; case mx::UnsafeBufferUsageAttr::static_kind(): - tp = &(gTypes[230]); + tp = &(gTypes[234]); break; case mx::UninitializedAttr::static_kind(): - tp = &(gTypes[231]); + tp = &(gTypes[235]); break; case mx::UnavailableAttr::static_kind(): - tp = &(gTypes[232]); + tp = &(gTypes[236]); break; case mx::TypeVisibilityAttr::static_kind(): - tp = &(gTypes[233]); + tp = &(gTypes[237]); break; case mx::TypeTagForDatatypeAttr::static_kind(): - tp = &(gTypes[234]); + tp = &(gTypes[238]); break; case mx::TryAcquireCapabilityAttr::static_kind(): - tp = &(gTypes[235]); + tp = &(gTypes[239]); break; case mx::TrivialABIAttr::static_kind(): - tp = &(gTypes[236]); + tp = &(gTypes[240]); break; case mx::TransparentUnionAttr::static_kind(): - tp = &(gTypes[237]); + tp = &(gTypes[241]); break; case mx::ThisCallAttr::static_kind(): - tp = &(gTypes[238]); + tp = &(gTypes[242]); break; case mx::TestTypestateAttr::static_kind(): - tp = &(gTypes[239]); + tp = &(gTypes[243]); break; case mx::TargetVersionAttr::static_kind(): - tp = &(gTypes[240]); + tp = &(gTypes[244]); break; case mx::TargetClonesAttr::static_kind(): - tp = &(gTypes[241]); + tp = &(gTypes[245]); break; case mx::TargetAttr::static_kind(): - tp = &(gTypes[242]); + tp = &(gTypes[246]); break; case mx::TLSModelAttr::static_kind(): - tp = &(gTypes[243]); + tp = &(gTypes[247]); break; case mx::SysVABIAttr::static_kind(): - tp = &(gTypes[244]); + tp = &(gTypes[248]); break; case mx::SwiftPrivateAttr::static_kind(): - tp = &(gTypes[245]); + tp = &(gTypes[249]); break; case mx::SwiftNewTypeAttr::static_kind(): - tp = &(gTypes[246]); + tp = &(gTypes[250]); break; case mx::SwiftNameAttr::static_kind(): - tp = &(gTypes[247]); + tp = &(gTypes[251]); break; case mx::SwiftImportPropertyAsAccessorsAttr::static_kind(): - tp = &(gTypes[248]); + tp = &(gTypes[252]); break; case mx::SwiftImportAsNonGenericAttr::static_kind(): - tp = &(gTypes[249]); + tp = &(gTypes[253]); break; case mx::SwiftErrorAttr::static_kind(): - tp = &(gTypes[250]); + tp = &(gTypes[254]); break; case mx::SwiftCallAttr::static_kind(): - tp = &(gTypes[251]); + tp = &(gTypes[255]); break; case mx::SwiftBridgedTypedefAttr::static_kind(): - tp = &(gTypes[252]); + tp = &(gTypes[256]); break; case mx::SwiftBridgeAttr::static_kind(): - tp = &(gTypes[253]); + tp = &(gTypes[257]); break; case mx::SwiftAttrAttr::static_kind(): - tp = &(gTypes[254]); + tp = &(gTypes[258]); break; case mx::SwiftAsyncNameAttr::static_kind(): - tp = &(gTypes[255]); + tp = &(gTypes[259]); break; case mx::SwiftAsyncErrorAttr::static_kind(): - tp = &(gTypes[256]); + tp = &(gTypes[260]); break; case mx::SwiftAsyncCallAttr::static_kind(): - tp = &(gTypes[257]); + tp = &(gTypes[261]); break; case mx::SwiftAsyncAttr::static_kind(): - tp = &(gTypes[258]); + tp = &(gTypes[262]); break; case mx::StrictGuardStackCheckAttr::static_kind(): - tp = &(gTypes[259]); + tp = &(gTypes[263]); break; case mx::StrictFPAttr::static_kind(): - tp = &(gTypes[260]); + tp = &(gTypes[264]); break; case mx::StdCallAttr::static_kind(): - tp = &(gTypes[261]); + tp = &(gTypes[265]); break; case mx::StandaloneDebugAttr::static_kind(): - tp = &(gTypes[262]); + tp = &(gTypes[266]); break; case mx::SpeculativeLoadHardeningAttr::static_kind(): - tp = &(gTypes[263]); + tp = &(gTypes[267]); break; case mx::SharedTrylockFunctionAttr::static_kind(): - tp = &(gTypes[264]); + tp = &(gTypes[268]); break; case mx::SetTypestateAttr::static_kind(): - tp = &(gTypes[265]); + tp = &(gTypes[269]); break; case mx::SentinelAttr::static_kind(): - tp = &(gTypes[266]); + tp = &(gTypes[270]); break; case mx::SelectAnyAttr::static_kind(): - tp = &(gTypes[267]); + tp = &(gTypes[271]); break; case mx::SectionAttr::static_kind(): - tp = &(gTypes[268]); + tp = &(gTypes[272]); break; case mx::ScopedLockableAttr::static_kind(): - tp = &(gTypes[269]); + tp = &(gTypes[273]); break; case mx::SYCLSpecialClassAttr::static_kind(): - tp = &(gTypes[270]); + tp = &(gTypes[274]); break; case mx::SYCLKernelAttr::static_kind(): - tp = &(gTypes[271]); + tp = &(gTypes[275]); break; case mx::ReturnsTwiceAttr::static_kind(): - tp = &(gTypes[272]); + tp = &(gTypes[276]); break; case mx::ReturnsNonNullAttr::static_kind(): - tp = &(gTypes[273]); + tp = &(gTypes[277]); break; case mx::ReturnTypestateAttr::static_kind(): - tp = &(gTypes[274]); + tp = &(gTypes[278]); break; case mx::RetainAttr::static_kind(): - tp = &(gTypes[275]); + tp = &(gTypes[279]); break; case mx::RestrictAttr::static_kind(): - tp = &(gTypes[276]); + tp = &(gTypes[280]); break; case mx::RequiresCapabilityAttr::static_kind(): - tp = &(gTypes[277]); + tp = &(gTypes[281]); break; case mx::ReqdWorkGroupSizeAttr::static_kind(): - tp = &(gTypes[278]); + tp = &(gTypes[282]); break; case mx::ReleaseCapabilityAttr::static_kind(): - tp = &(gTypes[279]); + tp = &(gTypes[283]); break; case mx::ReinitializesAttr::static_kind(): - tp = &(gTypes[280]); + tp = &(gTypes[284]); break; case mx::RegCallAttr::static_kind(): - tp = &(gTypes[281]); + tp = &(gTypes[285]); break; case mx::ReadOnlyPlacementAttr::static_kind(): - tp = &(gTypes[282]); + tp = &(gTypes[286]); break; case mx::RandomizeLayoutAttr::static_kind(): - tp = &(gTypes[283]); + tp = &(gTypes[287]); break; case mx::RISCVInterruptAttr::static_kind(): - tp = &(gTypes[284]); + tp = &(gTypes[288]); break; case mx::PureAttr::static_kind(): - tp = &(gTypes[285]); + tp = &(gTypes[289]); break; case mx::PtGuardedVarAttr::static_kind(): - tp = &(gTypes[286]); + tp = &(gTypes[290]); break; case mx::PtGuardedByAttr::static_kind(): - tp = &(gTypes[287]); + tp = &(gTypes[291]); break; case mx::PreserveMostAttr::static_kind(): - tp = &(gTypes[288]); + tp = &(gTypes[292]); break; case mx::PreserveAllAttr::static_kind(): - tp = &(gTypes[289]); + tp = &(gTypes[293]); break; case mx::PreferredTypeAttr::static_kind(): - tp = &(gTypes[290]); + tp = &(gTypes[294]); break; case mx::PreferredNameAttr::static_kind(): - tp = &(gTypes[291]); + tp = &(gTypes[295]); break; case mx::PragmaClangTextSectionAttr::static_kind(): - tp = &(gTypes[292]); + tp = &(gTypes[296]); break; case mx::PragmaClangRodataSectionAttr::static_kind(): - tp = &(gTypes[293]); + tp = &(gTypes[297]); break; case mx::PragmaClangRelroSectionAttr::static_kind(): - tp = &(gTypes[294]); + tp = &(gTypes[298]); break; case mx::PragmaClangDataSectionAttr::static_kind(): - tp = &(gTypes[295]); + tp = &(gTypes[299]); break; case mx::PragmaClangBSSSectionAttr::static_kind(): - tp = &(gTypes[296]); + tp = &(gTypes[300]); break; case mx::PointerAttr::static_kind(): - tp = &(gTypes[297]); + tp = &(gTypes[301]); break; case mx::PcsAttr::static_kind(): - tp = &(gTypes[298]); + tp = &(gTypes[302]); break; case mx::PatchableFunctionEntryAttr::static_kind(): - tp = &(gTypes[299]); + tp = &(gTypes[303]); break; case mx::PascalAttr::static_kind(): - tp = &(gTypes[300]); + tp = &(gTypes[304]); break; case mx::ParamTypestateAttr::static_kind(): - tp = &(gTypes[301]); + tp = &(gTypes[305]); break; case mx::PackedAttr::static_kind(): - tp = &(gTypes[302]); + tp = &(gTypes[306]); break; case mx::OwnershipAttr::static_kind(): - tp = &(gTypes[303]); + tp = &(gTypes[307]); break; case mx::OwnerAttr::static_kind(): - tp = &(gTypes[304]); + tp = &(gTypes[308]); break; case mx::OverrideAttr::static_kind(): - tp = &(gTypes[305]); + tp = &(gTypes[309]); break; case mx::OptimizeNoneAttr::static_kind(): - tp = &(gTypes[306]); + tp = &(gTypes[310]); break; case mx::OpenCLKernelAttr::static_kind(): - tp = &(gTypes[307]); + tp = &(gTypes[311]); break; case mx::OpenCLIntelReqdSubGroupSizeAttr::static_kind(): - tp = &(gTypes[308]); + tp = &(gTypes[312]); break; case mx::ObjCSubclassingRestrictedAttr::static_kind(): - tp = &(gTypes[309]); + tp = &(gTypes[313]); break; case mx::ObjCRootClassAttr::static_kind(): - tp = &(gTypes[310]); + tp = &(gTypes[314]); break; case mx::ObjCReturnsInnerPointerAttr::static_kind(): - tp = &(gTypes[311]); + tp = &(gTypes[315]); break; case mx::ObjCRequiresSuperAttr::static_kind(): - tp = &(gTypes[312]); + tp = &(gTypes[316]); break; case mx::ObjCRequiresPropertyDefsAttr::static_kind(): - tp = &(gTypes[313]); + tp = &(gTypes[317]); break; case mx::ObjCPreciseLifetimeAttr::static_kind(): - tp = &(gTypes[314]); + tp = &(gTypes[318]); break; case mx::ObjCOwnershipAttr::static_kind(): - tp = &(gTypes[315]); + tp = &(gTypes[319]); break; case mx::ObjCNSObjectAttr::static_kind(): - tp = &(gTypes[316]); + tp = &(gTypes[320]); break; case mx::ObjCMethodFamilyAttr::static_kind(): - tp = &(gTypes[317]); + tp = &(gTypes[321]); break; case mx::ObjCIndependentClassAttr::static_kind(): - tp = &(gTypes[318]); + tp = &(gTypes[322]); break; case mx::ObjCExternallyRetainedAttr::static_kind(): - tp = &(gTypes[319]); + tp = &(gTypes[323]); break; case mx::ObjCExplicitProtocolImplAttr::static_kind(): - tp = &(gTypes[320]); + tp = &(gTypes[324]); break; case mx::ObjCExceptionAttr::static_kind(): - tp = &(gTypes[321]); + tp = &(gTypes[325]); break; case mx::ObjCBridgeRelatedAttr::static_kind(): - tp = &(gTypes[322]); + tp = &(gTypes[326]); break; case mx::ObjCBridgeMutableAttr::static_kind(): - tp = &(gTypes[323]); + tp = &(gTypes[327]); break; case mx::ObjCBridgeAttr::static_kind(): - tp = &(gTypes[324]); + tp = &(gTypes[328]); break; case mx::OSReturnsRetainedOnZeroAttr::static_kind(): - tp = &(gTypes[325]); + tp = &(gTypes[329]); break; case mx::OSReturnsRetainedOnNonZeroAttr::static_kind(): - tp = &(gTypes[326]); + tp = &(gTypes[330]); break; case mx::OSReturnsRetainedAttr::static_kind(): - tp = &(gTypes[327]); + tp = &(gTypes[331]); break; case mx::OSReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[328]); + tp = &(gTypes[332]); break; case mx::OSConsumesThisAttr::static_kind(): - tp = &(gTypes[329]); + tp = &(gTypes[333]); break; case mx::OMPThreadPrivateDeclAttr::static_kind(): - tp = &(gTypes[330]); + tp = &(gTypes[334]); break; case mx::OMPDeclareVariantAttr::static_kind(): - tp = &(gTypes[331]); + tp = &(gTypes[335]); break; case mx::OMPDeclareTargetDeclAttr::static_kind(): - tp = &(gTypes[332]); + tp = &(gTypes[336]); break; case mx::OMPCaptureNoInitAttr::static_kind(): - tp = &(gTypes[333]); + tp = &(gTypes[337]); break; case mx::OMPAllocateDeclAttr::static_kind(): - tp = &(gTypes[334]); + tp = &(gTypes[338]); break; case mx::NotTailCalledAttr::static_kind(): - tp = &(gTypes[335]); + tp = &(gTypes[339]); break; case mx::NoUwtableAttr::static_kind(): - tp = &(gTypes[336]); + tp = &(gTypes[340]); break; case mx::NoUniqueAddressAttr::static_kind(): - tp = &(gTypes[337]); + tp = &(gTypes[341]); break; case mx::NoThrowAttr::static_kind(): - tp = &(gTypes[338]); + tp = &(gTypes[342]); break; case mx::NoThreadSafetyAnalysisAttr::static_kind(): - tp = &(gTypes[339]); + tp = &(gTypes[343]); break; case mx::NoStackProtectorAttr::static_kind(): - tp = &(gTypes[340]); + tp = &(gTypes[344]); break; case mx::NoSplitStackAttr::static_kind(): - tp = &(gTypes[341]); + tp = &(gTypes[345]); break; case mx::NoSpeculativeLoadHardeningAttr::static_kind(): - tp = &(gTypes[342]); + tp = &(gTypes[346]); break; case mx::NoSanitizeAttr::static_kind(): - tp = &(gTypes[343]); + tp = &(gTypes[347]); break; case mx::NoReturnAttr::static_kind(): - tp = &(gTypes[344]); + tp = &(gTypes[348]); break; case mx::NoRandomizeLayoutAttr::static_kind(): - tp = &(gTypes[345]); + tp = &(gTypes[349]); break; case mx::NoProfileFunctionAttr::static_kind(): - tp = &(gTypes[346]); + tp = &(gTypes[350]); break; case mx::NoMips16Attr::static_kind(): - tp = &(gTypes[347]); + tp = &(gTypes[351]); break; case mx::NoMicroMipsAttr::static_kind(): - tp = &(gTypes[348]); + tp = &(gTypes[352]); break; case mx::NoInstrumentFunctionAttr::static_kind(): - tp = &(gTypes[349]); + tp = &(gTypes[353]); break; case mx::NoDuplicateAttr::static_kind(): - tp = &(gTypes[350]); + tp = &(gTypes[354]); break; case mx::NoDestroyAttr::static_kind(): - tp = &(gTypes[351]); + tp = &(gTypes[355]); break; case mx::NoDebugAttr::static_kind(): - tp = &(gTypes[352]); + tp = &(gTypes[356]); break; case mx::NoCommonAttr::static_kind(): - tp = &(gTypes[353]); + tp = &(gTypes[357]); break; case mx::NoAliasAttr::static_kind(): - tp = &(gTypes[354]); + tp = &(gTypes[358]); break; case mx::NakedAttr::static_kind(): - tp = &(gTypes[355]); + tp = &(gTypes[359]); break; case mx::NVPTXKernelAttr::static_kind(): - tp = &(gTypes[356]); + tp = &(gTypes[360]); break; case mx::NSReturnsRetainedAttr::static_kind(): - tp = &(gTypes[357]); + tp = &(gTypes[361]); break; case mx::NSReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[358]); + tp = &(gTypes[362]); break; case mx::NSReturnsAutoreleasedAttr::static_kind(): - tp = &(gTypes[359]); + tp = &(gTypes[363]); break; case mx::NSErrorDomainAttr::static_kind(): - tp = &(gTypes[360]); + tp = &(gTypes[364]); break; case mx::NSConsumesSelfAttr::static_kind(): - tp = &(gTypes[361]); + tp = &(gTypes[365]); break; case mx::MipsShortCallAttr::static_kind(): - tp = &(gTypes[362]); + tp = &(gTypes[366]); break; case mx::MipsLongCallAttr::static_kind(): - tp = &(gTypes[363]); + tp = &(gTypes[367]); break; case mx::MipsInterruptAttr::static_kind(): - tp = &(gTypes[364]); + tp = &(gTypes[368]); break; case mx::Mips16Attr::static_kind(): - tp = &(gTypes[365]); + tp = &(gTypes[369]); break; case mx::MinVectorWidthAttr::static_kind(): - tp = &(gTypes[366]); + tp = &(gTypes[370]); break; case mx::MinSizeAttr::static_kind(): - tp = &(gTypes[367]); + tp = &(gTypes[371]); break; case mx::MicroMipsAttr::static_kind(): - tp = &(gTypes[368]); + tp = &(gTypes[372]); break; case mx::MaybeUndefAttr::static_kind(): - tp = &(gTypes[369]); + tp = &(gTypes[373]); break; case mx::MayAliasAttr::static_kind(): - tp = &(gTypes[370]); + tp = &(gTypes[374]); break; case mx::MaxFieldAlignmentAttr::static_kind(): - tp = &(gTypes[371]); + tp = &(gTypes[375]); break; case mx::MSVtorDispAttr::static_kind(): - tp = &(gTypes[372]); + tp = &(gTypes[376]); break; case mx::MSStructAttr::static_kind(): - tp = &(gTypes[373]); + tp = &(gTypes[377]); break; case mx::MSP430InterruptAttr::static_kind(): - tp = &(gTypes[374]); + tp = &(gTypes[378]); break; case mx::MSNoVTableAttr::static_kind(): - tp = &(gTypes[375]); + tp = &(gTypes[379]); break; case mx::MSInheritanceAttr::static_kind(): - tp = &(gTypes[376]); + tp = &(gTypes[380]); break; case mx::MSConstexprAttr::static_kind(): - tp = &(gTypes[377]); + tp = &(gTypes[381]); break; case mx::MSAllocatorAttr::static_kind(): - tp = &(gTypes[378]); + tp = &(gTypes[382]); break; case mx::MSABIAttr::static_kind(): - tp = &(gTypes[379]); + tp = &(gTypes[383]); break; case mx::MIGServerRoutineAttr::static_kind(): - tp = &(gTypes[380]); + tp = &(gTypes[384]); break; case mx::M68kRTDAttr::static_kind(): - tp = &(gTypes[381]); + tp = &(gTypes[385]); break; case mx::M68kInterruptAttr::static_kind(): - tp = &(gTypes[382]); + tp = &(gTypes[386]); break; case mx::LocksExcludedAttr::static_kind(): - tp = &(gTypes[383]); + tp = &(gTypes[387]); break; case mx::LockReturnedAttr::static_kind(): - tp = &(gTypes[384]); + tp = &(gTypes[388]); break; case mx::LifetimeBoundAttr::static_kind(): - tp = &(gTypes[385]); + tp = &(gTypes[389]); break; case mx::LeafAttr::static_kind(): - tp = &(gTypes[386]); + tp = &(gTypes[390]); break; case mx::LayoutVersionAttr::static_kind(): - tp = &(gTypes[387]); + tp = &(gTypes[391]); break; case mx::LTOVisibilityPublicAttr::static_kind(): - tp = &(gTypes[388]); + tp = &(gTypes[392]); break; case mx::InternalLinkageAttr::static_kind(): - tp = &(gTypes[389]); + tp = &(gTypes[393]); break; case mx::IntelOclBiccAttr::static_kind(): - tp = &(gTypes[390]); + tp = &(gTypes[394]); break; case mx::InitPriorityAttr::static_kind(): - tp = &(gTypes[391]); + tp = &(gTypes[395]); break; case mx::CarriesDependencyAttr::static_kind(): - tp = &(gTypes[393]); + tp = &(gTypes[397]); break; case mx::CFConsumedAttr::static_kind(): - tp = &(gTypes[394]); + tp = &(gTypes[398]); break; case mx::AnnotateAttr::static_kind(): - tp = &(gTypes[395]); + tp = &(gTypes[399]); break; case mx::UseHandleAttr::static_kind(): - tp = &(gTypes[396]); + tp = &(gTypes[400]); break; case mx::ReleaseHandleAttr::static_kind(): - tp = &(gTypes[397]); + tp = &(gTypes[401]); break; case mx::PassObjectSizeAttr::static_kind(): - tp = &(gTypes[398]); + tp = &(gTypes[402]); break; case mx::SwiftIndirectResultAttr::static_kind(): - tp = &(gTypes[400]); + tp = &(gTypes[404]); break; case mx::SwiftErrorResultAttr::static_kind(): - tp = &(gTypes[401]); + tp = &(gTypes[405]); break; case mx::SwiftContextAttr::static_kind(): - tp = &(gTypes[402]); + tp = &(gTypes[406]); break; case mx::SwiftAsyncContextAttr::static_kind(): - tp = &(gTypes[403]); + tp = &(gTypes[407]); break; case mx::OSConsumedAttr::static_kind(): - tp = &(gTypes[404]); + tp = &(gTypes[408]); break; case mx::NonNullAttr::static_kind(): - tp = &(gTypes[405]); + tp = &(gTypes[409]); break; case mx::NSConsumedAttr::static_kind(): - tp = &(gTypes[406]); + tp = &(gTypes[410]); break; case mx::IFuncAttr::static_kind(): - tp = &(gTypes[407]); + tp = &(gTypes[411]); break; case mx::CalledOnceAttr::static_kind(): - tp = &(gTypes[408]); + tp = &(gTypes[412]); break; case mx::BuiltinAliasAttr::static_kind(): - tp = &(gTypes[409]); + tp = &(gTypes[413]); break; } @@ -1974,7 +1974,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -2026,7 +2026,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[6]); + PyTypeObject * const tp = &(gTypes[10]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/AttributedStmt.cpp b/bindings/Python/Generated/AST/AttributedStmt.cpp index a4e5df749..411523c32 100644 --- a/bindings/Python/Generated/AST/AttributedStmt.cpp +++ b/bindings/Python/Generated/AST/AttributedStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[718]) || tp >= &(gTypes[719])) { + if (tp < &(gTypes[722]) || tp >= &(gTypes[723])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AttributedStmt::static_kind(): - tp = &(gTypes[718]); + tp = &(gTypes[722]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -411,7 +411,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[718]); + PyTypeObject * const tp = &(gTypes[722]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -426,12 +426,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[584].tp_hash; - tp->tp_richcompare = gTypes[584].tp_richcompare; + tp->tp_hash = gTypes[588].tp_hash; + tp->tp_richcompare = gTypes[588].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[584]); + tp->tp_base = &(gTypes[588]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AttributedType.cpp b/bindings/Python/Generated/AST/AttributedType.cpp index a820c56fd..1521fef48 100644 --- a/bindings/Python/Generated/AST/AttributedType.cpp +++ b/bindings/Python/Generated/AST/AttributedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[452]) || tp >= &(gTypes[453])) { + if (tp < &(gTypes[456]) || tp >= &(gTypes[457])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AttributedType::static_kind(): - tp = &(gTypes[452]); + tp = &(gTypes[456]); break; } @@ -373,7 +373,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -425,7 +425,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[452]); + PyTypeObject * const tp = &(gTypes[456]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -440,12 +440,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AutoType.cpp b/bindings/Python/Generated/AST/AutoType.cpp index ba4a2ca1e..f9b47e6e6 100644 --- a/bindings/Python/Generated/AST/AutoType.cpp +++ b/bindings/Python/Generated/AST/AutoType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[445]) || tp >= &(gTypes[446])) { + if (tp < &(gTypes[449]) || tp >= &(gTypes[450])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AutoType::static_kind(): - tp = &(gTypes[445]); + tp = &(gTypes[449]); break; } @@ -333,7 +333,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -407,7 +407,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[445]); + PyTypeObject * const tp = &(gTypes[449]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -422,12 +422,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[443].tp_hash; - tp->tp_richcompare = gTypes[443].tp_richcompare; + tp->tp_hash = gTypes[447].tp_hash; + tp->tp_richcompare = gTypes[447].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[443]); + tp->tp_base = &(gTypes[447]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AvailabilityAttr.cpp b/bindings/Python/Generated/AST/AvailabilityAttr.cpp index c6bc03c2f..09b89f191 100644 --- a/bindings/Python/Generated/AST/AvailabilityAttr.cpp +++ b/bindings/Python/Generated/AST/AvailabilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[172]) || tp >= &(gTypes[173])) { + if (tp < &(gTypes[176]) || tp >= &(gTypes[177])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AvailabilityAttr::static_kind(): - tp = &(gTypes[172]); + tp = &(gTypes[176]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -391,7 +391,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[172]); + PyTypeObject * const tp = &(gTypes[176]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -406,12 +406,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp b/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp index 8c173a777..ccad48127 100644 --- a/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp +++ b/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[171]) || tp >= &(gTypes[172])) { + if (tp < &(gTypes[175]) || tp >= &(gTypes[176])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AvailableOnlyInDefaultEvalMethodAttr::static_kind(): - tp = &(gTypes[171]); + tp = &(gTypes[175]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[171]); + PyTypeObject * const tp = &(gTypes[175]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp b/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp index b90ad2465..803a44447 100644 --- a/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp +++ b/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[170]) || tp >= &(gTypes[171])) { + if (tp < &(gTypes[174]) || tp >= &(gTypes[175])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BPFPreserveAccessIndexAttr::static_kind(): - tp = &(gTypes[170]); + tp = &(gTypes[174]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[170]); + PyTypeObject * const tp = &(gTypes[174]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp b/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp index 3143083ff..2a6e02cac 100644 --- a/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp +++ b/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[169]) || tp >= &(gTypes[170])) { + if (tp < &(gTypes[173]) || tp >= &(gTypes[174])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BPFPreserveStaticOffsetAttr::static_kind(): - tp = &(gTypes[169]); + tp = &(gTypes[173]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[169]); + PyTypeObject * const tp = &(gTypes[173]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp b/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp index 20825c7ce..df62a9802 100644 --- a/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp +++ b/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[168]) || tp >= &(gTypes[169])) { + if (tp < &(gTypes[172]) || tp >= &(gTypes[173])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BTFDeclTagAttr::static_kind(): - tp = &(gTypes[168]); + tp = &(gTypes[172]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[168]); + PyTypeObject * const tp = &(gTypes[172]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BTFTagAttributedType.cpp b/bindings/Python/Generated/AST/BTFTagAttributedType.cpp index 8cba9f0fd..f3944c88b 100644 --- a/bindings/Python/Generated/AST/BTFTagAttributedType.cpp +++ b/bindings/Python/Generated/AST/BTFTagAttributedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[451]) || tp >= &(gTypes[452])) { + if (tp < &(gTypes[455]) || tp >= &(gTypes[456])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BTFTagAttributedType::static_kind(): - tp = &(gTypes[451]); + tp = &(gTypes[455]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[451]); + PyTypeObject * const tp = &(gTypes[455]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp b/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp index fd7e3281e..d23034270 100644 --- a/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp +++ b/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[28]) || tp >= &(gTypes[29])) { + if (tp < &(gTypes[32]) || tp >= &(gTypes[33])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BTFTypeTagAttr::static_kind(): - tp = &(gTypes[28]); + tp = &(gTypes[32]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[28]); + PyTypeObject * const tp = &(gTypes[32]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BaseUsingDecl.cpp b/bindings/Python/Generated/AST/BaseUsingDecl.cpp index c588c7bcc..8bcb16636 100644 --- a/bindings/Python/Generated/AST/BaseUsingDecl.cpp +++ b/bindings/Python/Generated/AST/BaseUsingDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[741]) || tp >= &(gTypes[744])) { + if (tp < &(gTypes[745]) || tp >= &(gTypes[748])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingEnumDecl::static_kind(): - tp = &(gTypes[742]); + tp = &(gTypes[746]); break; case mx::UsingDecl::static_kind(): - tp = &(gTypes[743]); + tp = &(gTypes[747]); break; } @@ -356,7 +356,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -408,7 +408,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[741]); + PyTypeObject * const tp = &(gTypes[745]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -423,12 +423,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp b/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp index bd11041c6..9fbfb2043 100644 --- a/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp +++ b/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[653]) || tp >= &(gTypes[654])) { + if (tp < &(gTypes[657]) || tp >= &(gTypes[658])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BinaryConditionalOperator::static_kind(): - tp = &(gTypes[653]); + tp = &(gTypes[657]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[653]); + PyTypeObject * const tp = &(gTypes[657]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[651].tp_hash; - tp->tp_richcompare = gTypes[651].tp_richcompare; + tp->tp_hash = gTypes[655].tp_hash; + tp->tp_richcompare = gTypes[655].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[651]); + tp->tp_base = &(gTypes[655]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BinaryOperator.cpp b/bindings/Python/Generated/AST/BinaryOperator.cpp index 825abff45..51f0a9505 100644 --- a/bindings/Python/Generated/AST/BinaryOperator.cpp +++ b/bindings/Python/Generated/AST/BinaryOperator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[642]) || tp >= &(gTypes[644])) { + if (tp < &(gTypes[646]) || tp >= &(gTypes[648])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BinaryOperator::static_kind(): - tp = &(gTypes[642]); + tp = &(gTypes[646]); break; case mx::CompoundAssignOperator::static_kind(): - tp = &(gTypes[643]); + tp = &(gTypes[647]); break; } @@ -513,7 +513,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -543,7 +543,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[642]); + PyTypeObject * const tp = &(gTypes[646]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -558,12 +558,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BindingDecl.cpp b/bindings/Python/Generated/AST/BindingDecl.cpp index aa983c30d..465a6446f 100644 --- a/bindings/Python/Generated/AST/BindingDecl.cpp +++ b/bindings/Python/Generated/AST/BindingDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[771]) || tp >= &(gTypes[772])) { + if (tp < &(gTypes[775]) || tp >= &(gTypes[776])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BindingDecl::static_kind(): - tp = &(gTypes[771]); + tp = &(gTypes[775]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[771]); + PyTypeObject * const tp = &(gTypes[775]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BitIntType.cpp b/bindings/Python/Generated/AST/BitIntType.cpp index 1fe568f5d..10e8a7d40 100644 --- a/bindings/Python/Generated/AST/BitIntType.cpp +++ b/bindings/Python/Generated/AST/BitIntType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[450]) || tp >= &(gTypes[451])) { + if (tp < &(gTypes[454]) || tp >= &(gTypes[455])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BitIntType::static_kind(): - tp = &(gTypes[450]); + tp = &(gTypes[454]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[450]); + PyTypeObject * const tp = &(gTypes[454]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BlockDecl.cpp b/bindings/Python/Generated/AST/BlockDecl.cpp index ecfb6f11e..3b56d353c 100644 --- a/bindings/Python/Generated/AST/BlockDecl.cpp +++ b/bindings/Python/Generated/AST/BlockDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[725]) || tp >= &(gTypes[726])) { + if (tp < &(gTypes[729]) || tp >= &(gTypes[730])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BlockDecl::static_kind(): - tp = &(gTypes[725]); + tp = &(gTypes[729]); break; } @@ -519,7 +519,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -593,7 +593,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[725]); + PyTypeObject * const tp = &(gTypes[729]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -608,12 +608,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BlockExpr.cpp b/bindings/Python/Generated/AST/BlockExpr.cpp index 9e1bd7ea6..d56325170 100644 --- a/bindings/Python/Generated/AST/BlockExpr.cpp +++ b/bindings/Python/Generated/AST/BlockExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[641]) || tp >= &(gTypes[642])) { + if (tp < &(gTypes[645]) || tp >= &(gTypes[646])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BlockExpr::static_kind(): - tp = &(gTypes[641]); + tp = &(gTypes[645]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[641]); + PyTypeObject * const tp = &(gTypes[645]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BlockPointerType.cpp b/bindings/Python/Generated/AST/BlockPointerType.cpp index 0862ce132..4488e0fe5 100644 --- a/bindings/Python/Generated/AST/BlockPointerType.cpp +++ b/bindings/Python/Generated/AST/BlockPointerType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[449]) || tp >= &(gTypes[450])) { + if (tp < &(gTypes[453]) || tp >= &(gTypes[454])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BlockPointerType::static_kind(): - tp = &(gTypes[449]); + tp = &(gTypes[453]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[449]); + PyTypeObject * const tp = &(gTypes[453]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BlocksAttr.cpp b/bindings/Python/Generated/AST/BlocksAttr.cpp index 047a2da03..e2579e250 100644 --- a/bindings/Python/Generated/AST/BlocksAttr.cpp +++ b/bindings/Python/Generated/AST/BlocksAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[167]) || tp >= &(gTypes[168])) { + if (tp < &(gTypes[171]) || tp >= &(gTypes[172])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BlocksAttr::static_kind(): - tp = &(gTypes[167]); + tp = &(gTypes[171]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[167]); + PyTypeObject * const tp = &(gTypes[171]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BreakStmt.cpp b/bindings/Python/Generated/AST/BreakStmt.cpp index b3bb72b48..68eb9451b 100644 --- a/bindings/Python/Generated/AST/BreakStmt.cpp +++ b/bindings/Python/Generated/AST/BreakStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[579]) || tp >= &(gTypes[580])) { + if (tp < &(gTypes[583]) || tp >= &(gTypes[584])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BreakStmt::static_kind(): - tp = &(gTypes[579]); + tp = &(gTypes[583]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[579]); + PyTypeObject * const tp = &(gTypes[583]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp b/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp index 0d79b362a..bc4a48391 100644 --- a/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp +++ b/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[409]) || tp >= &(gTypes[410])) { + if (tp < &(gTypes[413]) || tp >= &(gTypes[414])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BuiltinAliasAttr::static_kind(): - tp = &(gTypes[409]); + tp = &(gTypes[413]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[409]); + PyTypeObject * const tp = &(gTypes[413]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BuiltinAttr.cpp b/bindings/Python/Generated/AST/BuiltinAttr.cpp index d4a416294..7d96540ab 100644 --- a/bindings/Python/Generated/AST/BuiltinAttr.cpp +++ b/bindings/Python/Generated/AST/BuiltinAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[166]) || tp >= &(gTypes[167])) { + if (tp < &(gTypes[170]) || tp >= &(gTypes[171])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BuiltinAttr::static_kind(): - tp = &(gTypes[166]); + tp = &(gTypes[170]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[166]); + PyTypeObject * const tp = &(gTypes[170]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp b/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp index 4e7aa48f5..37acdc58d 100644 --- a/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp +++ b/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[611]) || tp >= &(gTypes[612])) { + if (tp < &(gTypes[615]) || tp >= &(gTypes[616])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BuiltinBitCastExpr::static_kind(): - tp = &(gTypes[611]); + tp = &(gTypes[615]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[611]); + PyTypeObject * const tp = &(gTypes[615]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[602].tp_hash; - tp->tp_richcompare = gTypes[602].tp_richcompare; + tp->tp_hash = gTypes[606].tp_hash; + tp->tp_richcompare = gTypes[606].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[602]); + tp->tp_base = &(gTypes[606]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp b/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp index 8ae6246f5..7ec2ae02b 100644 --- a/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp +++ b/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[799]) || tp >= &(gTypes[800])) { + if (tp < &(gTypes[803]) || tp >= &(gTypes[804])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BuiltinTemplateDecl::static_kind(): - tp = &(gTypes[799]); + tp = &(gTypes[803]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[799]); + PyTypeObject * const tp = &(gTypes[803]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[792].tp_hash; - tp->tp_richcompare = gTypes[792].tp_richcompare; + tp->tp_hash = gTypes[796].tp_hash; + tp->tp_richcompare = gTypes[796].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[792]); + tp->tp_base = &(gTypes[796]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/BuiltinType.cpp b/bindings/Python/Generated/AST/BuiltinType.cpp index 90c8b2a38..db4b18c8f 100644 --- a/bindings/Python/Generated/AST/BuiltinType.cpp +++ b/bindings/Python/Generated/AST/BuiltinType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[448]) || tp >= &(gTypes[449])) { + if (tp < &(gTypes[452]) || tp >= &(gTypes[453])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::BuiltinType::static_kind(): - tp = &(gTypes[448]); + tp = &(gTypes[452]); break; } @@ -343,7 +343,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -395,7 +395,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[448]); + PyTypeObject * const tp = &(gTypes[452]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -410,12 +410,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/C11NoReturnAttr.cpp b/bindings/Python/Generated/AST/C11NoReturnAttr.cpp index e71e9a51f..5cbed46fe 100644 --- a/bindings/Python/Generated/AST/C11NoReturnAttr.cpp +++ b/bindings/Python/Generated/AST/C11NoReturnAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[165]) || tp >= &(gTypes[166])) { + if (tp < &(gTypes[169]) || tp >= &(gTypes[170])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::C11NoReturnAttr::static_kind(): - tp = &(gTypes[165]); + tp = &(gTypes[169]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[165]); + PyTypeObject * const tp = &(gTypes[169]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CDeclAttr.cpp b/bindings/Python/Generated/AST/CDeclAttr.cpp index 3fbcf777d..2e57f3781 100644 --- a/bindings/Python/Generated/AST/CDeclAttr.cpp +++ b/bindings/Python/Generated/AST/CDeclAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[164]) || tp >= &(gTypes[165])) { + if (tp < &(gTypes[168]) || tp >= &(gTypes[169])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CDeclAttr::static_kind(): - tp = &(gTypes[164]); + tp = &(gTypes[168]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[164]); + PyTypeObject * const tp = &(gTypes[168]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp b/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp index c50f37528..a28aabb83 100644 --- a/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp +++ b/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[163]) || tp >= &(gTypes[164])) { + if (tp < &(gTypes[167]) || tp >= &(gTypes[168])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CFAuditedTransferAttr::static_kind(): - tp = &(gTypes[163]); + tp = &(gTypes[167]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[163]); + PyTypeObject * const tp = &(gTypes[167]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CFConsumedAttr.cpp b/bindings/Python/Generated/AST/CFConsumedAttr.cpp index 5b98f5446..b57c2a3bf 100644 --- a/bindings/Python/Generated/AST/CFConsumedAttr.cpp +++ b/bindings/Python/Generated/AST/CFConsumedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[394]) || tp >= &(gTypes[395])) { + if (tp < &(gTypes[398]) || tp >= &(gTypes[399])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CFConsumedAttr::static_kind(): - tp = &(gTypes[394]); + tp = &(gTypes[398]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[394]); + PyTypeObject * const tp = &(gTypes[398]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CFGuardAttr.cpp b/bindings/Python/Generated/AST/CFGuardAttr.cpp index f1c023f64..e88c79b2b 100644 --- a/bindings/Python/Generated/AST/CFGuardAttr.cpp +++ b/bindings/Python/Generated/AST/CFGuardAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[162]) || tp >= &(gTypes[163])) { + if (tp < &(gTypes[166]) || tp >= &(gTypes[167])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CFGuardAttr::static_kind(): - tp = &(gTypes[162]); + tp = &(gTypes[166]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[162]); + PyTypeObject * const tp = &(gTypes[166]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp b/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp index 781bb5f91..bbce781c4 100644 --- a/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp +++ b/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[161]) || tp >= &(gTypes[162])) { + if (tp < &(gTypes[165]) || tp >= &(gTypes[166])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CFICanonicalJumpTableAttr::static_kind(): - tp = &(gTypes[161]); + tp = &(gTypes[165]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[161]); + PyTypeObject * const tp = &(gTypes[165]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp b/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp index b3f6bd056..080558295 100644 --- a/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp +++ b/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[160]) || tp >= &(gTypes[161])) { + if (tp < &(gTypes[164]) || tp >= &(gTypes[165])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CFReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[160]); + tp = &(gTypes[164]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[160]); + PyTypeObject * const tp = &(gTypes[164]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp b/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp index b1ba2982a..083ae6b51 100644 --- a/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp +++ b/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[159]) || tp >= &(gTypes[160])) { + if (tp < &(gTypes[163]) || tp >= &(gTypes[164])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CFReturnsRetainedAttr::static_kind(): - tp = &(gTypes[159]); + tp = &(gTypes[163]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[159]); + PyTypeObject * const tp = &(gTypes[163]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp b/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp index 87ccb15ef..b5b76e315 100644 --- a/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp +++ b/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[158]) || tp >= &(gTypes[159])) { + if (tp < &(gTypes[162]) || tp >= &(gTypes[163])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CFUnknownTransferAttr::static_kind(): - tp = &(gTypes[158]); + tp = &(gTypes[162]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[158]); + PyTypeObject * const tp = &(gTypes[162]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CPUDispatchAttr.cpp b/bindings/Python/Generated/AST/CPUDispatchAttr.cpp index 32e3523a0..a0bbd63d8 100644 --- a/bindings/Python/Generated/AST/CPUDispatchAttr.cpp +++ b/bindings/Python/Generated/AST/CPUDispatchAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[157]) || tp >= &(gTypes[158])) { + if (tp < &(gTypes[161]) || tp >= &(gTypes[162])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CPUDispatchAttr::static_kind(): - tp = &(gTypes[157]); + tp = &(gTypes[161]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[157]); + PyTypeObject * const tp = &(gTypes[161]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CPUSpecificAttr.cpp b/bindings/Python/Generated/AST/CPUSpecificAttr.cpp index 4309cc733..3c21e7c3d 100644 --- a/bindings/Python/Generated/AST/CPUSpecificAttr.cpp +++ b/bindings/Python/Generated/AST/CPUSpecificAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[156]) || tp >= &(gTypes[157])) { + if (tp < &(gTypes[160]) || tp >= &(gTypes[161])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CPUSpecificAttr::static_kind(): - tp = &(gTypes[156]); + tp = &(gTypes[160]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[156]); + PyTypeObject * const tp = &(gTypes[160]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CStyleCastExpr.cpp b/bindings/Python/Generated/AST/CStyleCastExpr.cpp index d8646aed4..45cd8606e 100644 --- a/bindings/Python/Generated/AST/CStyleCastExpr.cpp +++ b/bindings/Python/Generated/AST/CStyleCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[610]) || tp >= &(gTypes[611])) { + if (tp < &(gTypes[614]) || tp >= &(gTypes[615])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CStyleCastExpr::static_kind(): - tp = &(gTypes[610]); + tp = &(gTypes[614]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[610]); + PyTypeObject * const tp = &(gTypes[614]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[602].tp_hash; - tp->tp_richcompare = gTypes[602].tp_richcompare; + tp->tp_hash = gTypes[606].tp_hash; + tp->tp_richcompare = gTypes[606].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[602]); + tp->tp_base = &(gTypes[606]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDAConstantAttr.cpp b/bindings/Python/Generated/AST/CUDAConstantAttr.cpp index 1ed5d0a9a..26af9394c 100644 --- a/bindings/Python/Generated/AST/CUDAConstantAttr.cpp +++ b/bindings/Python/Generated/AST/CUDAConstantAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[155]) || tp >= &(gTypes[156])) { + if (tp < &(gTypes[159]) || tp >= &(gTypes[160])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDAConstantAttr::static_kind(): - tp = &(gTypes[155]); + tp = &(gTypes[159]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[155]); + PyTypeObject * const tp = &(gTypes[159]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDADeviceAttr.cpp b/bindings/Python/Generated/AST/CUDADeviceAttr.cpp index ccab33d37..15ace9b36 100644 --- a/bindings/Python/Generated/AST/CUDADeviceAttr.cpp +++ b/bindings/Python/Generated/AST/CUDADeviceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[154]) || tp >= &(gTypes[155])) { + if (tp < &(gTypes[158]) || tp >= &(gTypes[159])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDADeviceAttr::static_kind(): - tp = &(gTypes[154]); + tp = &(gTypes[158]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[154]); + PyTypeObject * const tp = &(gTypes[158]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp b/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp index 3fb916713..ebaa2876f 100644 --- a/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp +++ b/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[153]) || tp >= &(gTypes[154])) { + if (tp < &(gTypes[157]) || tp >= &(gTypes[158])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDADeviceBuiltinSurfaceTypeAttr::static_kind(): - tp = &(gTypes[153]); + tp = &(gTypes[157]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[153]); + PyTypeObject * const tp = &(gTypes[157]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp b/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp index 6bb171171..620d4173f 100644 --- a/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp +++ b/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[152]) || tp >= &(gTypes[153])) { + if (tp < &(gTypes[156]) || tp >= &(gTypes[157])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDADeviceBuiltinTextureTypeAttr::static_kind(): - tp = &(gTypes[152]); + tp = &(gTypes[156]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[152]); + PyTypeObject * const tp = &(gTypes[156]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp b/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp index b5618b785..47cf9503b 100644 --- a/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp +++ b/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[151]) || tp >= &(gTypes[152])) { + if (tp < &(gTypes[155]) || tp >= &(gTypes[156])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDAGlobalAttr::static_kind(): - tp = &(gTypes[151]); + tp = &(gTypes[155]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[151]); + PyTypeObject * const tp = &(gTypes[155]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDAHostAttr.cpp b/bindings/Python/Generated/AST/CUDAHostAttr.cpp index cac8e30a8..7d5de7c84 100644 --- a/bindings/Python/Generated/AST/CUDAHostAttr.cpp +++ b/bindings/Python/Generated/AST/CUDAHostAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[150]) || tp >= &(gTypes[151])) { + if (tp < &(gTypes[154]) || tp >= &(gTypes[155])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDAHostAttr::static_kind(): - tp = &(gTypes[150]); + tp = &(gTypes[154]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[150]); + PyTypeObject * const tp = &(gTypes[154]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp b/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp index 39a130f00..cd25c4a82 100644 --- a/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp +++ b/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[149]) || tp >= &(gTypes[150])) { + if (tp < &(gTypes[153]) || tp >= &(gTypes[154])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDAInvalidTargetAttr::static_kind(): - tp = &(gTypes[149]); + tp = &(gTypes[153]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[149]); + PyTypeObject * const tp = &(gTypes[153]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp b/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp index 1f661143e..794f4c2b7 100644 --- a/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp +++ b/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[616]) || tp >= &(gTypes[617])) { + if (tp < &(gTypes[620]) || tp >= &(gTypes[621])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDAKernelCallExpr::static_kind(): - tp = &(gTypes[616]); + tp = &(gTypes[620]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[616]); + PyTypeObject * const tp = &(gTypes[620]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[613].tp_hash; - tp->tp_richcompare = gTypes[613].tp_richcompare; + tp->tp_hash = gTypes[617].tp_hash; + tp->tp_richcompare = gTypes[617].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[613]); + tp->tp_base = &(gTypes[617]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp b/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp index 6a4f3cccc..0e63561b3 100644 --- a/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp +++ b/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[148]) || tp >= &(gTypes[149])) { + if (tp < &(gTypes[152]) || tp >= &(gTypes[153])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDALaunchBoundsAttr::static_kind(): - tp = &(gTypes[148]); + tp = &(gTypes[152]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[148]); + PyTypeObject * const tp = &(gTypes[152]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CUDASharedAttr.cpp b/bindings/Python/Generated/AST/CUDASharedAttr.cpp index bf89f2842..cd3c0b2b3 100644 --- a/bindings/Python/Generated/AST/CUDASharedAttr.cpp +++ b/bindings/Python/Generated/AST/CUDASharedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[147]) || tp >= &(gTypes[148])) { + if (tp < &(gTypes[151]) || tp >= &(gTypes[152])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CUDASharedAttr::static_kind(): - tp = &(gTypes[147]); + tp = &(gTypes[151]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[147]); + PyTypeObject * const tp = &(gTypes[151]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp b/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp index c96f38e6c..e33ce88e6 100644 --- a/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp +++ b/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[146]) || tp >= &(gTypes[147])) { + if (tp < &(gTypes[150]) || tp >= &(gTypes[151])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXX11NoReturnAttr::static_kind(): - tp = &(gTypes[146]); + tp = &(gTypes[150]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[146]); + PyTypeObject * const tp = &(gTypes[150]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp b/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp index 0f1e8dcbd..8937a7fd4 100644 --- a/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp +++ b/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[606]) || tp >= &(gTypes[607])) { + if (tp < &(gTypes[610]) || tp >= &(gTypes[611])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXAddrspaceCastExpr::static_kind(): - tp = &(gTypes[606]); + tp = &(gTypes[610]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[606]); + PyTypeObject * const tp = &(gTypes[610]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[603].tp_hash; - tp->tp_richcompare = gTypes[603].tp_richcompare; + tp->tp_hash = gTypes[607].tp_hash; + tp->tp_richcompare = gTypes[607].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[603]); + tp->tp_base = &(gTypes[607]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp b/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp index f9f546e33..3f5efdb8d 100644 --- a/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp +++ b/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[3]) || tp >= &(gTypes[4])) { + if (tp < &(gTypes[7]) || tp >= &(gTypes[8])) { return std::nullopt; } @@ -386,7 +386,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -438,7 +438,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[3]); + PyTypeObject * const tp = &(gTypes[7]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp b/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp index 0ce445863..4804f0b9c 100644 --- a/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp +++ b/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[640]) || tp >= &(gTypes[641])) { + if (tp < &(gTypes[644]) || tp >= &(gTypes[645])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXBindTemporaryExpr::static_kind(): - tp = &(gTypes[640]); + tp = &(gTypes[644]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[640]); + PyTypeObject * const tp = &(gTypes[644]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp b/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp index 1c8c424e7..5d0a52b39 100644 --- a/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp +++ b/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[639]) || tp >= &(gTypes[640])) { + if (tp < &(gTypes[643]) || tp >= &(gTypes[644])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXBoolLiteralExpr::static_kind(): - tp = &(gTypes[639]); + tp = &(gTypes[643]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[639]); + PyTypeObject * const tp = &(gTypes[643]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXCatchStmt.cpp b/bindings/Python/Generated/AST/CXXCatchStmt.cpp index 493ee108b..db792296d 100644 --- a/bindings/Python/Generated/AST/CXXCatchStmt.cpp +++ b/bindings/Python/Generated/AST/CXXCatchStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[578]) || tp >= &(gTypes[579])) { + if (tp < &(gTypes[582]) || tp >= &(gTypes[583])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXCatchStmt::static_kind(): - tp = &(gTypes[578]); + tp = &(gTypes[582]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[578]); + PyTypeObject * const tp = &(gTypes[582]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXConstCastExpr.cpp b/bindings/Python/Generated/AST/CXXConstCastExpr.cpp index 1131ac22e..f0fe3f73e 100644 --- a/bindings/Python/Generated/AST/CXXConstCastExpr.cpp +++ b/bindings/Python/Generated/AST/CXXConstCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[605]) || tp >= &(gTypes[606])) { + if (tp < &(gTypes[609]) || tp >= &(gTypes[610])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXConstCastExpr::static_kind(): - tp = &(gTypes[605]); + tp = &(gTypes[609]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[605]); + PyTypeObject * const tp = &(gTypes[609]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[603].tp_hash; - tp->tp_richcompare = gTypes[603].tp_richcompare; + tp->tp_hash = gTypes[607].tp_hash; + tp->tp_richcompare = gTypes[607].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[603]); + tp->tp_base = &(gTypes[607]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXConstructExpr.cpp b/bindings/Python/Generated/AST/CXXConstructExpr.cpp index 44a1ddece..7190b681a 100644 --- a/bindings/Python/Generated/AST/CXXConstructExpr.cpp +++ b/bindings/Python/Generated/AST/CXXConstructExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[637]) || tp >= &(gTypes[639])) { + if (tp < &(gTypes[641]) || tp >= &(gTypes[643])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXConstructExpr::static_kind(): - tp = &(gTypes[637]); + tp = &(gTypes[641]); break; case mx::CXXTemporaryObjectExpr::static_kind(): - tp = &(gTypes[638]); + tp = &(gTypes[642]); break; } @@ -443,7 +443,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -495,7 +495,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[637]); + PyTypeObject * const tp = &(gTypes[641]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -510,12 +510,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXConstructorDecl.cpp b/bindings/Python/Generated/AST/CXXConstructorDecl.cpp index ec5fd5e81..34c17d380 100644 --- a/bindings/Python/Generated/AST/CXXConstructorDecl.cpp +++ b/bindings/Python/Generated/AST/CXXConstructorDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[766]) || tp >= &(gTypes[767])) { + if (tp < &(gTypes[770]) || tp >= &(gTypes[771])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXConstructorDecl::static_kind(): - tp = &(gTypes[766]); + tp = &(gTypes[770]); break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -481,7 +481,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[766]); + PyTypeObject * const tp = &(gTypes[770]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -496,12 +496,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[763].tp_hash; - tp->tp_richcompare = gTypes[763].tp_richcompare; + tp->tp_hash = gTypes[767].tp_hash; + tp->tp_richcompare = gTypes[767].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[763]); + tp->tp_base = &(gTypes[767]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXConversionDecl.cpp b/bindings/Python/Generated/AST/CXXConversionDecl.cpp index d1c24ff32..11f215c20 100644 --- a/bindings/Python/Generated/AST/CXXConversionDecl.cpp +++ b/bindings/Python/Generated/AST/CXXConversionDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[765]) || tp >= &(gTypes[766])) { + if (tp < &(gTypes[769]) || tp >= &(gTypes[770])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXConversionDecl::static_kind(): - tp = &(gTypes[765]); + tp = &(gTypes[769]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[765]); + PyTypeObject * const tp = &(gTypes[769]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[763].tp_hash; - tp->tp_richcompare = gTypes[763].tp_richcompare; + tp->tp_hash = gTypes[767].tp_hash; + tp->tp_richcompare = gTypes[767].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[763]); + tp->tp_base = &(gTypes[767]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXCtorInitializer.cpp b/bindings/Python/Generated/AST/CXXCtorInitializer.cpp index 8d57214c7..656449bea 100644 --- a/bindings/Python/Generated/AST/CXXCtorInitializer.cpp +++ b/bindings/Python/Generated/AST/CXXCtorInitializer.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[1]) || tp >= &(gTypes[2])) { + if (tp < &(gTypes[5]) || tp >= &(gTypes[6])) { return std::nullopt; } @@ -436,7 +436,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -488,7 +488,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[1]); + PyTypeObject * const tp = &(gTypes[5]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp b/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp index 3e2dda7f8..4072ffa3f 100644 --- a/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp +++ b/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[767]) || tp >= &(gTypes[768])) { + if (tp < &(gTypes[771]) || tp >= &(gTypes[772])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDeductionGuideDecl::static_kind(): - tp = &(gTypes[767]); + tp = &(gTypes[771]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[767]); + PyTypeObject * const tp = &(gTypes[771]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[762].tp_hash; - tp->tp_richcompare = gTypes[762].tp_richcompare; + tp->tp_hash = gTypes[766].tp_hash; + tp->tp_richcompare = gTypes[766].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[762]); + tp->tp_base = &(gTypes[766]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp b/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp index e3e135cdb..f528c5f76 100644 --- a/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp +++ b/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[636]) || tp >= &(gTypes[637])) { + if (tp < &(gTypes[640]) || tp >= &(gTypes[641])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDefaultArgExpr::static_kind(): - tp = &(gTypes[636]); + tp = &(gTypes[640]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[636]); + PyTypeObject * const tp = &(gTypes[640]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp b/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp index bdd1bbcb2..1768dca1e 100644 --- a/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp +++ b/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[635]) || tp >= &(gTypes[636])) { + if (tp < &(gTypes[639]) || tp >= &(gTypes[640])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDefaultInitExpr::static_kind(): - tp = &(gTypes[635]); + tp = &(gTypes[639]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[635]); + PyTypeObject * const tp = &(gTypes[639]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXDeleteExpr.cpp b/bindings/Python/Generated/AST/CXXDeleteExpr.cpp index d0810a9dc..f59ecea42 100644 --- a/bindings/Python/Generated/AST/CXXDeleteExpr.cpp +++ b/bindings/Python/Generated/AST/CXXDeleteExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[634]) || tp >= &(gTypes[635])) { + if (tp < &(gTypes[638]) || tp >= &(gTypes[639])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDeleteExpr::static_kind(): - tp = &(gTypes[634]); + tp = &(gTypes[638]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[634]); + PyTypeObject * const tp = &(gTypes[638]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp b/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp index f99b8f9d2..1416d94cb 100644 --- a/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp +++ b/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[633]) || tp >= &(gTypes[634])) { + if (tp < &(gTypes[637]) || tp >= &(gTypes[638])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDependentScopeMemberExpr::static_kind(): - tp = &(gTypes[633]); + tp = &(gTypes[637]); break; } @@ -439,7 +439,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -469,7 +469,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[633]); + PyTypeObject * const tp = &(gTypes[637]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -484,12 +484,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXDestructorDecl.cpp b/bindings/Python/Generated/AST/CXXDestructorDecl.cpp index 52694e573..ac7e0d732 100644 --- a/bindings/Python/Generated/AST/CXXDestructorDecl.cpp +++ b/bindings/Python/Generated/AST/CXXDestructorDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[764]) || tp >= &(gTypes[765])) { + if (tp < &(gTypes[768]) || tp >= &(gTypes[769])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDestructorDecl::static_kind(): - tp = &(gTypes[764]); + tp = &(gTypes[768]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[764]); + PyTypeObject * const tp = &(gTypes[768]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[763].tp_hash; - tp->tp_richcompare = gTypes[763].tp_richcompare; + tp->tp_hash = gTypes[767].tp_hash; + tp->tp_richcompare = gTypes[767].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[763]); + tp->tp_base = &(gTypes[767]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp b/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp index a1447edab..c60d09ae0 100644 --- a/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp +++ b/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[604]) || tp >= &(gTypes[605])) { + if (tp < &(gTypes[608]) || tp >= &(gTypes[609])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDynamicCastExpr::static_kind(): - tp = &(gTypes[604]); + tp = &(gTypes[608]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[604]); + PyTypeObject * const tp = &(gTypes[608]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[603].tp_hash; - tp->tp_richcompare = gTypes[603].tp_richcompare; + tp->tp_hash = gTypes[607].tp_hash; + tp->tp_richcompare = gTypes[607].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[603]); + tp->tp_base = &(gTypes[607]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXFoldExpr.cpp b/bindings/Python/Generated/AST/CXXFoldExpr.cpp index 51a485755..f03bf8897 100644 --- a/bindings/Python/Generated/AST/CXXFoldExpr.cpp +++ b/bindings/Python/Generated/AST/CXXFoldExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[632]) || tp >= &(gTypes[633])) { + if (tp < &(gTypes[636]) || tp >= &(gTypes[637])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXFoldExpr::static_kind(): - tp = &(gTypes[632]); + tp = &(gTypes[636]); break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[632]); + PyTypeObject * const tp = &(gTypes[636]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -474,12 +474,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXForRangeStmt.cpp b/bindings/Python/Generated/AST/CXXForRangeStmt.cpp index 02eb856fd..ac3fbc607 100644 --- a/bindings/Python/Generated/AST/CXXForRangeStmt.cpp +++ b/bindings/Python/Generated/AST/CXXForRangeStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[577]) || tp >= &(gTypes[578])) { + if (tp < &(gTypes[581]) || tp >= &(gTypes[582])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXForRangeStmt::static_kind(): - tp = &(gTypes[577]); + tp = &(gTypes[581]); break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -489,7 +489,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[577]); + PyTypeObject * const tp = &(gTypes[581]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -504,12 +504,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp b/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp index 9ba31c2fe..2575651f7 100644 --- a/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp +++ b/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[609]) || tp >= &(gTypes[610])) { + if (tp < &(gTypes[613]) || tp >= &(gTypes[614])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXFunctionalCastExpr::static_kind(): - tp = &(gTypes[609]); + tp = &(gTypes[613]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[609]); + PyTypeObject * const tp = &(gTypes[613]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[602].tp_hash; - tp->tp_richcompare = gTypes[602].tp_richcompare; + tp->tp_hash = gTypes[606].tp_hash; + tp->tp_richcompare = gTypes[606].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[602]); + tp->tp_base = &(gTypes[606]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp b/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp index 522d3e70a..a4f25b2fa 100644 --- a/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp +++ b/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[631]) || tp >= &(gTypes[632])) { + if (tp < &(gTypes[635]) || tp >= &(gTypes[636])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXInheritedCtorInitExpr::static_kind(): - tp = &(gTypes[631]); + tp = &(gTypes[635]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[631]); + PyTypeObject * const tp = &(gTypes[635]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp b/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp index 0be5b9359..dc25e2642 100644 --- a/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp +++ b/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[615]) || tp >= &(gTypes[616])) { + if (tp < &(gTypes[619]) || tp >= &(gTypes[620])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXMemberCallExpr::static_kind(): - tp = &(gTypes[615]); + tp = &(gTypes[619]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[615]); + PyTypeObject * const tp = &(gTypes[619]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[613].tp_hash; - tp->tp_richcompare = gTypes[613].tp_richcompare; + tp->tp_hash = gTypes[617].tp_hash; + tp->tp_richcompare = gTypes[617].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[613]); + tp->tp_base = &(gTypes[617]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXMethodDecl.cpp b/bindings/Python/Generated/AST/CXXMethodDecl.cpp index a6227e4c5..5e1e2e166 100644 --- a/bindings/Python/Generated/AST/CXXMethodDecl.cpp +++ b/bindings/Python/Generated/AST/CXXMethodDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[763]) || tp >= &(gTypes[767])) { + if (tp < &(gTypes[767]) || tp >= &(gTypes[771])) { return std::nullopt; } @@ -88,19 +88,19 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXMethodDecl::static_kind(): - tp = &(gTypes[763]); + tp = &(gTypes[767]); break; case mx::CXXDestructorDecl::static_kind(): - tp = &(gTypes[764]); + tp = &(gTypes[768]); break; case mx::CXXConversionDecl::static_kind(): - tp = &(gTypes[765]); + tp = &(gTypes[769]); break; case mx::CXXConstructorDecl::static_kind(): - tp = &(gTypes[766]); + tp = &(gTypes[770]); break; } @@ -551,7 +551,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -603,7 +603,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[763]); + PyTypeObject * const tp = &(gTypes[767]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -618,12 +618,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[762].tp_hash; - tp->tp_richcompare = gTypes[762].tp_richcompare; + tp->tp_hash = gTypes[766].tp_hash; + tp->tp_richcompare = gTypes[766].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[762]); + tp->tp_base = &(gTypes[766]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp b/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp index d9349e3e9..b0f4e59a9 100644 --- a/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp +++ b/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[603]) || tp >= &(gTypes[609])) { + if (tp < &(gTypes[607]) || tp >= &(gTypes[613])) { return std::nullopt; } @@ -88,23 +88,23 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDynamicCastExpr::static_kind(): - tp = &(gTypes[604]); + tp = &(gTypes[608]); break; case mx::CXXConstCastExpr::static_kind(): - tp = &(gTypes[605]); + tp = &(gTypes[609]); break; case mx::CXXAddrspaceCastExpr::static_kind(): - tp = &(gTypes[606]); + tp = &(gTypes[610]); break; case mx::CXXStaticCastExpr::static_kind(): - tp = &(gTypes[607]); + tp = &(gTypes[611]); break; case mx::CXXReinterpretCastExpr::static_kind(): - tp = &(gTypes[608]); + tp = &(gTypes[612]); break; } @@ -358,7 +358,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -388,7 +388,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[603]); + PyTypeObject * const tp = &(gTypes[607]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -403,12 +403,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[602].tp_hash; - tp->tp_richcompare = gTypes[602].tp_richcompare; + tp->tp_hash = gTypes[606].tp_hash; + tp->tp_richcompare = gTypes[606].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[602]); + tp->tp_base = &(gTypes[606]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXNewExpr.cpp b/bindings/Python/Generated/AST/CXXNewExpr.cpp index 5985c24a3..245e66631 100644 --- a/bindings/Python/Generated/AST/CXXNewExpr.cpp +++ b/bindings/Python/Generated/AST/CXXNewExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[630]) || tp >= &(gTypes[631])) { + if (tp < &(gTypes[634]) || tp >= &(gTypes[635])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXNewExpr::static_kind(): - tp = &(gTypes[630]); + tp = &(gTypes[634]); break; } @@ -489,7 +489,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -541,7 +541,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[630]); + PyTypeObject * const tp = &(gTypes[634]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -556,12 +556,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp b/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp index a0050b0a6..0e001cc38 100644 --- a/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp +++ b/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[629]) || tp >= &(gTypes[630])) { + if (tp < &(gTypes[633]) || tp >= &(gTypes[634])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXNoexceptExpr::static_kind(): - tp = &(gTypes[629]); + tp = &(gTypes[633]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[629]); + PyTypeObject * const tp = &(gTypes[633]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp b/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp index c0b810539..1f4ed3688 100644 --- a/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp +++ b/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[628]) || tp >= &(gTypes[629])) { + if (tp < &(gTypes[632]) || tp >= &(gTypes[633])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXNullPtrLiteralExpr::static_kind(): - tp = &(gTypes[628]); + tp = &(gTypes[632]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[628]); + PyTypeObject * const tp = &(gTypes[632]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp b/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp index 0e6d48ab5..052f40f61 100644 --- a/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp +++ b/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[614]) || tp >= &(gTypes[615])) { + if (tp < &(gTypes[618]) || tp >= &(gTypes[619])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXOperatorCallExpr::static_kind(): - tp = &(gTypes[614]); + tp = &(gTypes[618]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[614]); + PyTypeObject * const tp = &(gTypes[618]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[613].tp_hash; - tp->tp_richcompare = gTypes[613].tp_richcompare; + tp->tp_hash = gTypes[617].tp_hash; + tp->tp_richcompare = gTypes[617].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[613]); + tp->tp_base = &(gTypes[617]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp b/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp index 8144d8e4d..68461a8bd 100644 --- a/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp +++ b/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[627]) || tp >= &(gTypes[628])) { + if (tp < &(gTypes[631]) || tp >= &(gTypes[632])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXParenListInitExpr::static_kind(): - tp = &(gTypes[627]); + tp = &(gTypes[631]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[627]); + PyTypeObject * const tp = &(gTypes[631]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp b/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp index 82761cfa9..b988189b6 100644 --- a/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp +++ b/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[626]) || tp >= &(gTypes[627])) { + if (tp < &(gTypes[630]) || tp >= &(gTypes[631])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXPseudoDestructorExpr::static_kind(): - tp = &(gTypes[626]); + tp = &(gTypes[630]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[626]); + PyTypeObject * const tp = &(gTypes[630]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXRecordDecl.cpp b/bindings/Python/Generated/AST/CXXRecordDecl.cpp index c7069ca0b..72bef7e87 100644 --- a/bindings/Python/Generated/AST/CXXRecordDecl.cpp +++ b/bindings/Python/Generated/AST/CXXRecordDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[783]) || tp >= &(gTypes[786])) { + if (tp < &(gTypes[787]) || tp >= &(gTypes[790])) { return std::nullopt; } @@ -88,15 +88,15 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXRecordDecl::static_kind(): - tp = &(gTypes[783]); + tp = &(gTypes[787]); break; case mx::ClassTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[784]); + tp = &(gTypes[788]); break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; } @@ -1607,7 +1607,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -1659,7 +1659,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[783]); + PyTypeObject * const tp = &(gTypes[787]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -1674,12 +1674,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[782].tp_hash; - tp->tp_richcompare = gTypes[782].tp_richcompare; + tp->tp_hash = gTypes[786].tp_hash; + tp->tp_richcompare = gTypes[786].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[782]); + tp->tp_base = &(gTypes[786]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp b/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp index 94542498e..0114ad6cd 100644 --- a/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp +++ b/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[608]) || tp >= &(gTypes[609])) { + if (tp < &(gTypes[612]) || tp >= &(gTypes[613])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXReinterpretCastExpr::static_kind(): - tp = &(gTypes[608]); + tp = &(gTypes[612]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[608]); + PyTypeObject * const tp = &(gTypes[612]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[603].tp_hash; - tp->tp_richcompare = gTypes[603].tp_richcompare; + tp->tp_hash = gTypes[607].tp_hash; + tp->tp_richcompare = gTypes[607].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[603]); + tp->tp_base = &(gTypes[607]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp b/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp index 3930ac90f..d7d520444 100644 --- a/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp +++ b/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[625]) || tp >= &(gTypes[626])) { + if (tp < &(gTypes[629]) || tp >= &(gTypes[630])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXRewrittenBinaryOperator::static_kind(): - tp = &(gTypes[625]); + tp = &(gTypes[629]); break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -449,7 +449,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[625]); + PyTypeObject * const tp = &(gTypes[629]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -464,12 +464,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp b/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp index a869372b6..852ae783b 100644 --- a/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp +++ b/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[624]) || tp >= &(gTypes[625])) { + if (tp < &(gTypes[628]) || tp >= &(gTypes[629])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXScalarValueInitExpr::static_kind(): - tp = &(gTypes[624]); + tp = &(gTypes[628]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[624]); + PyTypeObject * const tp = &(gTypes[628]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp b/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp index 6ca813b09..9436e4377 100644 --- a/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp +++ b/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[607]) || tp >= &(gTypes[608])) { + if (tp < &(gTypes[611]) || tp >= &(gTypes[612])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXStaticCastExpr::static_kind(): - tp = &(gTypes[607]); + tp = &(gTypes[611]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[607]); + PyTypeObject * const tp = &(gTypes[611]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[603].tp_hash; - tp->tp_richcompare = gTypes[603].tp_richcompare; + tp->tp_hash = gTypes[607].tp_hash; + tp->tp_richcompare = gTypes[607].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[603]); + tp->tp_base = &(gTypes[607]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp b/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp index 5e7d22507..a15190653 100644 --- a/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp +++ b/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[623]) || tp >= &(gTypes[624])) { + if (tp < &(gTypes[627]) || tp >= &(gTypes[628])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXStdInitializerListExpr::static_kind(): - tp = &(gTypes[623]); + tp = &(gTypes[627]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[623]); + PyTypeObject * const tp = &(gTypes[627]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp b/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp index a3e3c7217..74b35e5a2 100644 --- a/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp +++ b/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[638]) || tp >= &(gTypes[639])) { + if (tp < &(gTypes[642]) || tp >= &(gTypes[643])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXTemporaryObjectExpr::static_kind(): - tp = &(gTypes[638]); + tp = &(gTypes[642]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[638]); + PyTypeObject * const tp = &(gTypes[642]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[637].tp_hash; - tp->tp_richcompare = gTypes[637].tp_richcompare; + tp->tp_hash = gTypes[641].tp_hash; + tp->tp_richcompare = gTypes[641].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[637]); + tp->tp_base = &(gTypes[641]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXThisExpr.cpp b/bindings/Python/Generated/AST/CXXThisExpr.cpp index 79b66c4fc..2f8a926db 100644 --- a/bindings/Python/Generated/AST/CXXThisExpr.cpp +++ b/bindings/Python/Generated/AST/CXXThisExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[622]) || tp >= &(gTypes[623])) { + if (tp < &(gTypes[626]) || tp >= &(gTypes[627])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXThisExpr::static_kind(): - tp = &(gTypes[622]); + tp = &(gTypes[626]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[622]); + PyTypeObject * const tp = &(gTypes[626]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXThrowExpr.cpp b/bindings/Python/Generated/AST/CXXThrowExpr.cpp index 1efdc1750..0b0cc1a8a 100644 --- a/bindings/Python/Generated/AST/CXXThrowExpr.cpp +++ b/bindings/Python/Generated/AST/CXXThrowExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[621]) || tp >= &(gTypes[622])) { + if (tp < &(gTypes[625]) || tp >= &(gTypes[626])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXThrowExpr::static_kind(): - tp = &(gTypes[621]); + tp = &(gTypes[625]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[621]); + PyTypeObject * const tp = &(gTypes[625]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXTryStmt.cpp b/bindings/Python/Generated/AST/CXXTryStmt.cpp index fb95e9d95..3783102ed 100644 --- a/bindings/Python/Generated/AST/CXXTryStmt.cpp +++ b/bindings/Python/Generated/AST/CXXTryStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[576]) || tp >= &(gTypes[577])) { + if (tp < &(gTypes[580]) || tp >= &(gTypes[581])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXTryStmt::static_kind(): - tp = &(gTypes[576]); + tp = &(gTypes[580]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -411,7 +411,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[576]); + PyTypeObject * const tp = &(gTypes[580]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -426,12 +426,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXTypeidExpr.cpp b/bindings/Python/Generated/AST/CXXTypeidExpr.cpp index 4403edea4..3cef97a74 100644 --- a/bindings/Python/Generated/AST/CXXTypeidExpr.cpp +++ b/bindings/Python/Generated/AST/CXXTypeidExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[620]) || tp >= &(gTypes[621])) { + if (tp < &(gTypes[624]) || tp >= &(gTypes[625])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXTypeidExpr::static_kind(): - tp = &(gTypes[620]); + tp = &(gTypes[624]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[620]); + PyTypeObject * const tp = &(gTypes[624]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp b/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp index 74ad96adf..b984691a2 100644 --- a/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp +++ b/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[619]) || tp >= &(gTypes[620])) { + if (tp < &(gTypes[623]) || tp >= &(gTypes[624])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXUnresolvedConstructExpr::static_kind(): - tp = &(gTypes[619]); + tp = &(gTypes[623]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -431,7 +431,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[619]); + PyTypeObject * const tp = &(gTypes[623]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -446,12 +446,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CXXUuidofExpr.cpp b/bindings/Python/Generated/AST/CXXUuidofExpr.cpp index 75b08560e..fd0a849cb 100644 --- a/bindings/Python/Generated/AST/CXXUuidofExpr.cpp +++ b/bindings/Python/Generated/AST/CXXUuidofExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[618]) || tp >= &(gTypes[619])) { + if (tp < &(gTypes[622]) || tp >= &(gTypes[623])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXUuidofExpr::static_kind(): - tp = &(gTypes[618]); + tp = &(gTypes[622]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[618]); + PyTypeObject * const tp = &(gTypes[622]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CallExpr.cpp b/bindings/Python/Generated/AST/CallExpr.cpp index 845c1c932..bceeecd97 100644 --- a/bindings/Python/Generated/AST/CallExpr.cpp +++ b/bindings/Python/Generated/AST/CallExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[613]) || tp >= &(gTypes[618])) { + if (tp < &(gTypes[617]) || tp >= &(gTypes[622])) { return std::nullopt; } @@ -88,23 +88,23 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CallExpr::static_kind(): - tp = &(gTypes[613]); + tp = &(gTypes[617]); break; case mx::CXXOperatorCallExpr::static_kind(): - tp = &(gTypes[614]); + tp = &(gTypes[618]); break; case mx::CXXMemberCallExpr::static_kind(): - tp = &(gTypes[615]); + tp = &(gTypes[619]); break; case mx::CUDAKernelCallExpr::static_kind(): - tp = &(gTypes[616]); + tp = &(gTypes[620]); break; case mx::UserDefinedLiteral::static_kind(): - tp = &(gTypes[617]); + tp = &(gTypes[621]); break; } @@ -505,7 +505,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -557,7 +557,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[613]); + PyTypeObject * const tp = &(gTypes[617]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -572,12 +572,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CallableWhenAttr.cpp b/bindings/Python/Generated/AST/CallableWhenAttr.cpp index ad37d24bb..1b8c99376 100644 --- a/bindings/Python/Generated/AST/CallableWhenAttr.cpp +++ b/bindings/Python/Generated/AST/CallableWhenAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[145]) || tp >= &(gTypes[146])) { + if (tp < &(gTypes[149]) || tp >= &(gTypes[150])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CallableWhenAttr::static_kind(): - tp = &(gTypes[145]); + tp = &(gTypes[149]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[145]); + PyTypeObject * const tp = &(gTypes[149]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CallbackAttr.cpp b/bindings/Python/Generated/AST/CallbackAttr.cpp index 87ece8960..7fa74329b 100644 --- a/bindings/Python/Generated/AST/CallbackAttr.cpp +++ b/bindings/Python/Generated/AST/CallbackAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[144]) || tp >= &(gTypes[145])) { + if (tp < &(gTypes[148]) || tp >= &(gTypes[149])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CallbackAttr::static_kind(): - tp = &(gTypes[144]); + tp = &(gTypes[148]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[144]); + PyTypeObject * const tp = &(gTypes[148]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CalledOnceAttr.cpp b/bindings/Python/Generated/AST/CalledOnceAttr.cpp index 1da3e352d..7c083c14b 100644 --- a/bindings/Python/Generated/AST/CalledOnceAttr.cpp +++ b/bindings/Python/Generated/AST/CalledOnceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[408]) || tp >= &(gTypes[409])) { + if (tp < &(gTypes[412]) || tp >= &(gTypes[413])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CalledOnceAttr::static_kind(): - tp = &(gTypes[408]); + tp = &(gTypes[412]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[408]); + PyTypeObject * const tp = &(gTypes[412]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CapabilityAttr.cpp b/bindings/Python/Generated/AST/CapabilityAttr.cpp index abbdc4d40..797465e09 100644 --- a/bindings/Python/Generated/AST/CapabilityAttr.cpp +++ b/bindings/Python/Generated/AST/CapabilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[143]) || tp >= &(gTypes[144])) { + if (tp < &(gTypes[147]) || tp >= &(gTypes[148])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CapabilityAttr::static_kind(): - tp = &(gTypes[143]); + tp = &(gTypes[147]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[143]); + PyTypeObject * const tp = &(gTypes[147]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CapturedDecl.cpp b/bindings/Python/Generated/AST/CapturedDecl.cpp index 07530c09e..286064d7e 100644 --- a/bindings/Python/Generated/AST/CapturedDecl.cpp +++ b/bindings/Python/Generated/AST/CapturedDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[724]) || tp >= &(gTypes[725])) { + if (tp < &(gTypes[728]) || tp >= &(gTypes[729])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CapturedDecl::static_kind(): - tp = &(gTypes[724]); + tp = &(gTypes[728]); break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -461,7 +461,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[724]); + PyTypeObject * const tp = &(gTypes[728]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -476,12 +476,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CapturedRecordAttr.cpp b/bindings/Python/Generated/AST/CapturedRecordAttr.cpp index 37e180a08..cdd285c6d 100644 --- a/bindings/Python/Generated/AST/CapturedRecordAttr.cpp +++ b/bindings/Python/Generated/AST/CapturedRecordAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[142]) || tp >= &(gTypes[143])) { + if (tp < &(gTypes[146]) || tp >= &(gTypes[147])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CapturedRecordAttr::static_kind(): - tp = &(gTypes[142]); + tp = &(gTypes[146]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[142]); + PyTypeObject * const tp = &(gTypes[146]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CapturedStmt.cpp b/bindings/Python/Generated/AST/CapturedStmt.cpp index aecdc0364..39ee8ac36 100644 --- a/bindings/Python/Generated/AST/CapturedStmt.cpp +++ b/bindings/Python/Generated/AST/CapturedStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[575]) || tp >= &(gTypes[576])) { + if (tp < &(gTypes[579]) || tp >= &(gTypes[580])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CapturedStmt::static_kind(): - tp = &(gTypes[575]); + tp = &(gTypes[579]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[575]); + PyTypeObject * const tp = &(gTypes[579]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp b/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp index e911b6036..6fe700161 100644 --- a/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp +++ b/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[393]) || tp >= &(gTypes[394])) { + if (tp < &(gTypes[397]) || tp >= &(gTypes[398])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CarriesDependencyAttr::static_kind(): - tp = &(gTypes[393]); + tp = &(gTypes[397]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[393]); + PyTypeObject * const tp = &(gTypes[397]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CaseStmt.cpp b/bindings/Python/Generated/AST/CaseStmt.cpp index 4e2ac4d9d..76d384fa4 100644 --- a/bindings/Python/Generated/AST/CaseStmt.cpp +++ b/bindings/Python/Generated/AST/CaseStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[722]) || tp >= &(gTypes[723])) { + if (tp < &(gTypes[726]) || tp >= &(gTypes[727])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CaseStmt::static_kind(): - tp = &(gTypes[722]); + tp = &(gTypes[726]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[722]); + PyTypeObject * const tp = &(gTypes[726]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[720].tp_hash; - tp->tp_richcompare = gTypes[720].tp_richcompare; + tp->tp_hash = gTypes[724].tp_hash; + tp->tp_richcompare = gTypes[724].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[720]); + tp->tp_base = &(gTypes[724]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CastExpr.cpp b/bindings/Python/Generated/AST/CastExpr.cpp index 1fa47b741..cd96ad2c2 100644 --- a/bindings/Python/Generated/AST/CastExpr.cpp +++ b/bindings/Python/Generated/AST/CastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[600]) || tp >= &(gTypes[613])) { + if (tp < &(gTypes[604]) || tp >= &(gTypes[617])) { return std::nullopt; } @@ -88,43 +88,43 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImplicitCastExpr::static_kind(): - tp = &(gTypes[601]); + tp = &(gTypes[605]); break; case mx::CXXDynamicCastExpr::static_kind(): - tp = &(gTypes[604]); + tp = &(gTypes[608]); break; case mx::CXXConstCastExpr::static_kind(): - tp = &(gTypes[605]); + tp = &(gTypes[609]); break; case mx::CXXAddrspaceCastExpr::static_kind(): - tp = &(gTypes[606]); + tp = &(gTypes[610]); break; case mx::CXXStaticCastExpr::static_kind(): - tp = &(gTypes[607]); + tp = &(gTypes[611]); break; case mx::CXXReinterpretCastExpr::static_kind(): - tp = &(gTypes[608]); + tp = &(gTypes[612]); break; case mx::CXXFunctionalCastExpr::static_kind(): - tp = &(gTypes[609]); + tp = &(gTypes[613]); break; case mx::CStyleCastExpr::static_kind(): - tp = &(gTypes[610]); + tp = &(gTypes[614]); break; case mx::BuiltinBitCastExpr::static_kind(): - tp = &(gTypes[611]); + tp = &(gTypes[615]); break; case mx::ObjCBridgedCastExpr::static_kind(): - tp = &(gTypes[612]); + tp = &(gTypes[616]); break; } @@ -418,7 +418,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -448,7 +448,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[600]); + PyTypeObject * const tp = &(gTypes[604]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -463,12 +463,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CharacterLiteral.cpp b/bindings/Python/Generated/AST/CharacterLiteral.cpp index 117d444e1..de6edbc46 100644 --- a/bindings/Python/Generated/AST/CharacterLiteral.cpp +++ b/bindings/Python/Generated/AST/CharacterLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[599]) || tp >= &(gTypes[600])) { + if (tp < &(gTypes[603]) || tp >= &(gTypes[604])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CharacterLiteral::static_kind(): - tp = &(gTypes[599]); + tp = &(gTypes[603]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[599]); + PyTypeObject * const tp = &(gTypes[603]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ChooseExpr.cpp b/bindings/Python/Generated/AST/ChooseExpr.cpp index fda00c4fd..32367a62a 100644 --- a/bindings/Python/Generated/AST/ChooseExpr.cpp +++ b/bindings/Python/Generated/AST/ChooseExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[598]) || tp >= &(gTypes[599])) { + if (tp < &(gTypes[602]) || tp >= &(gTypes[603])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ChooseExpr::static_kind(): - tp = &(gTypes[598]); + tp = &(gTypes[602]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[598]); + PyTypeObject * const tp = &(gTypes[602]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ClassTemplateDecl.cpp b/bindings/Python/Generated/AST/ClassTemplateDecl.cpp index e4eb15d26..afb0b7993 100644 --- a/bindings/Python/Generated/AST/ClassTemplateDecl.cpp +++ b/bindings/Python/Generated/AST/ClassTemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[795]) || tp >= &(gTypes[796])) { + if (tp < &(gTypes[799]) || tp >= &(gTypes[800])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ClassTemplateDecl::static_kind(): - tp = &(gTypes[795]); + tp = &(gTypes[799]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[795]); + PyTypeObject * const tp = &(gTypes[799]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[793].tp_hash; - tp->tp_richcompare = gTypes[793].tp_richcompare; + tp->tp_hash = gTypes[797].tp_hash; + tp->tp_richcompare = gTypes[797].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[793]); + tp->tp_base = &(gTypes[797]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp b/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp index f6ecf0c77..b651da3d5 100644 --- a/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp +++ b/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[785]) || tp >= &(gTypes[786])) { + if (tp < &(gTypes[789]) || tp >= &(gTypes[790])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[785]); + PyTypeObject * const tp = &(gTypes[789]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[784].tp_hash; - tp->tp_richcompare = gTypes[784].tp_richcompare; + tp->tp_hash = gTypes[788].tp_hash; + tp->tp_richcompare = gTypes[788].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[784]); + tp->tp_base = &(gTypes[788]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp b/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp index d41b85e00..71da15244 100644 --- a/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp +++ b/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[784]) || tp >= &(gTypes[786])) { + if (tp < &(gTypes[788]) || tp >= &(gTypes[790])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ClassTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[784]); + tp = &(gTypes[788]); break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; } @@ -443,7 +443,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -495,7 +495,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[784]); + PyTypeObject * const tp = &(gTypes[788]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -510,12 +510,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[783].tp_hash; - tp->tp_richcompare = gTypes[783].tp_richcompare; + tp->tp_hash = gTypes[787].tp_hash; + tp->tp_richcompare = gTypes[787].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[783]); + tp->tp_base = &(gTypes[787]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CleanupAttr.cpp b/bindings/Python/Generated/AST/CleanupAttr.cpp index 50a0e4ee6..ffa550512 100644 --- a/bindings/Python/Generated/AST/CleanupAttr.cpp +++ b/bindings/Python/Generated/AST/CleanupAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[141]) || tp >= &(gTypes[142])) { + if (tp < &(gTypes[145]) || tp >= &(gTypes[146])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CleanupAttr::static_kind(): - tp = &(gTypes[141]); + tp = &(gTypes[145]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[141]); + PyTypeObject * const tp = &(gTypes[145]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CmseNSCallAttr.cpp b/bindings/Python/Generated/AST/CmseNSCallAttr.cpp index ca52aa45f..efac22beb 100644 --- a/bindings/Python/Generated/AST/CmseNSCallAttr.cpp +++ b/bindings/Python/Generated/AST/CmseNSCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[27]) || tp >= &(gTypes[28])) { + if (tp < &(gTypes[31]) || tp >= &(gTypes[32])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CmseNSCallAttr::static_kind(): - tp = &(gTypes[27]); + tp = &(gTypes[31]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[27]); + PyTypeObject * const tp = &(gTypes[31]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp b/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp index a730e1b15..84c53d5ab 100644 --- a/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp +++ b/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[140]) || tp >= &(gTypes[141])) { + if (tp < &(gTypes[144]) || tp >= &(gTypes[145])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CmseNSEntryAttr::static_kind(): - tp = &(gTypes[140]); + tp = &(gTypes[144]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[140]); + PyTypeObject * const tp = &(gTypes[144]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoawaitExpr.cpp b/bindings/Python/Generated/AST/CoawaitExpr.cpp index 5e02389c5..c84d1b5a7 100644 --- a/bindings/Python/Generated/AST/CoawaitExpr.cpp +++ b/bindings/Python/Generated/AST/CoawaitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[593]) || tp >= &(gTypes[594])) { + if (tp < &(gTypes[597]) || tp >= &(gTypes[598])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoawaitExpr::static_kind(): - tp = &(gTypes[593]); + tp = &(gTypes[597]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[593]); + PyTypeObject * const tp = &(gTypes[597]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[592].tp_hash; - tp->tp_richcompare = gTypes[592].tp_richcompare; + tp->tp_hash = gTypes[596].tp_hash; + tp->tp_richcompare = gTypes[596].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[592]); + tp->tp_base = &(gTypes[596]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CodeAlignAttr.cpp b/bindings/Python/Generated/AST/CodeAlignAttr.cpp index 79f12a84e..e1269f1a4 100644 --- a/bindings/Python/Generated/AST/CodeAlignAttr.cpp +++ b/bindings/Python/Generated/AST/CodeAlignAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[53]) || tp >= &(gTypes[54])) { + if (tp < &(gTypes[57]) || tp >= &(gTypes[58])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CodeAlignAttr::static_kind(): - tp = &(gTypes[53]); + tp = &(gTypes[57]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[53]); + PyTypeObject * const tp = &(gTypes[57]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[48].tp_hash; - tp->tp_richcompare = gTypes[48].tp_richcompare; + tp->tp_hash = gTypes[52].tp_hash; + tp->tp_richcompare = gTypes[52].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[48]); + tp->tp_base = &(gTypes[52]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CodeModelAttr.cpp b/bindings/Python/Generated/AST/CodeModelAttr.cpp index e57c324f2..14b0cc26a 100644 --- a/bindings/Python/Generated/AST/CodeModelAttr.cpp +++ b/bindings/Python/Generated/AST/CodeModelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[139]) || tp >= &(gTypes[140])) { + if (tp < &(gTypes[143]) || tp >= &(gTypes[144])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CodeModelAttr::static_kind(): - tp = &(gTypes[139]); + tp = &(gTypes[143]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[139]); + PyTypeObject * const tp = &(gTypes[143]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CodeSegAttr.cpp b/bindings/Python/Generated/AST/CodeSegAttr.cpp index e5be4ac10..8798b1d8a 100644 --- a/bindings/Python/Generated/AST/CodeSegAttr.cpp +++ b/bindings/Python/Generated/AST/CodeSegAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[138]) || tp >= &(gTypes[139])) { + if (tp < &(gTypes[142]) || tp >= &(gTypes[143])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CodeSegAttr::static_kind(): - tp = &(gTypes[138]); + tp = &(gTypes[142]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[138]); + PyTypeObject * const tp = &(gTypes[142]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ColdAttr.cpp b/bindings/Python/Generated/AST/ColdAttr.cpp index 182415ac4..e701b4eaa 100644 --- a/bindings/Python/Generated/AST/ColdAttr.cpp +++ b/bindings/Python/Generated/AST/ColdAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[137]) || tp >= &(gTypes[138])) { + if (tp < &(gTypes[141]) || tp >= &(gTypes[142])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ColdAttr::static_kind(): - tp = &(gTypes[137]); + tp = &(gTypes[141]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[137]); + PyTypeObject * const tp = &(gTypes[141]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CommonAttr.cpp b/bindings/Python/Generated/AST/CommonAttr.cpp index b80171333..ab927e0c3 100644 --- a/bindings/Python/Generated/AST/CommonAttr.cpp +++ b/bindings/Python/Generated/AST/CommonAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[136]) || tp >= &(gTypes[137])) { + if (tp < &(gTypes[140]) || tp >= &(gTypes[141])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CommonAttr::static_kind(): - tp = &(gTypes[136]); + tp = &(gTypes[140]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[136]); + PyTypeObject * const tp = &(gTypes[140]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ComplexType.cpp b/bindings/Python/Generated/AST/ComplexType.cpp index 9f9ff75a5..fef2e5a06 100644 --- a/bindings/Python/Generated/AST/ComplexType.cpp +++ b/bindings/Python/Generated/AST/ComplexType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[447]) || tp >= &(gTypes[448])) { + if (tp < &(gTypes[451]) || tp >= &(gTypes[452])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ComplexType::static_kind(): - tp = &(gTypes[447]); + tp = &(gTypes[451]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[447]); + PyTypeObject * const tp = &(gTypes[451]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CompoundAssignOperator.cpp b/bindings/Python/Generated/AST/CompoundAssignOperator.cpp index 187950d3e..f69bdd6ad 100644 --- a/bindings/Python/Generated/AST/CompoundAssignOperator.cpp +++ b/bindings/Python/Generated/AST/CompoundAssignOperator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[643]) || tp >= &(gTypes[644])) { + if (tp < &(gTypes[647]) || tp >= &(gTypes[648])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CompoundAssignOperator::static_kind(): - tp = &(gTypes[643]); + tp = &(gTypes[647]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[643]); + PyTypeObject * const tp = &(gTypes[647]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[642].tp_hash; - tp->tp_richcompare = gTypes[642].tp_richcompare; + tp->tp_hash = gTypes[646].tp_hash; + tp->tp_richcompare = gTypes[646].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[642]); + tp->tp_base = &(gTypes[646]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp b/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp index 98789451d..1e1b1546c 100644 --- a/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp +++ b/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[597]) || tp >= &(gTypes[598])) { + if (tp < &(gTypes[601]) || tp >= &(gTypes[602])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CompoundLiteralExpr::static_kind(): - tp = &(gTypes[597]); + tp = &(gTypes[601]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[597]); + PyTypeObject * const tp = &(gTypes[601]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CompoundStmt.cpp b/bindings/Python/Generated/AST/CompoundStmt.cpp index d549f19a3..a2b67b67a 100644 --- a/bindings/Python/Generated/AST/CompoundStmt.cpp +++ b/bindings/Python/Generated/AST/CompoundStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[574]) || tp >= &(gTypes[575])) { + if (tp < &(gTypes[578]) || tp >= &(gTypes[579])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CompoundStmt::static_kind(): - tp = &(gTypes[574]); + tp = &(gTypes[578]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[574]); + PyTypeObject * const tp = &(gTypes[578]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConceptDecl.cpp b/bindings/Python/Generated/AST/ConceptDecl.cpp index 3c4075cfd..497d74535 100644 --- a/bindings/Python/Generated/AST/ConceptDecl.cpp +++ b/bindings/Python/Generated/AST/ConceptDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[798]) || tp >= &(gTypes[799])) { + if (tp < &(gTypes[802]) || tp >= &(gTypes[803])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConceptDecl::static_kind(): - tp = &(gTypes[798]); + tp = &(gTypes[802]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[798]); + PyTypeObject * const tp = &(gTypes[802]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[792].tp_hash; - tp->tp_richcompare = gTypes[792].tp_richcompare; + tp->tp_hash = gTypes[796].tp_hash; + tp->tp_richcompare = gTypes[796].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[792]); + tp->tp_base = &(gTypes[796]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp b/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp index b0f8ea03a..db9e52e23 100644 --- a/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp +++ b/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[596]) || tp >= &(gTypes[597])) { + if (tp < &(gTypes[600]) || tp >= &(gTypes[601])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConceptSpecializationExpr::static_kind(): - tp = &(gTypes[596]); + tp = &(gTypes[600]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -451,7 +451,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[596]); + PyTypeObject * const tp = &(gTypes[600]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -466,12 +466,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConditionalOperator.cpp b/bindings/Python/Generated/AST/ConditionalOperator.cpp index f40b5b743..808380489 100644 --- a/bindings/Python/Generated/AST/ConditionalOperator.cpp +++ b/bindings/Python/Generated/AST/ConditionalOperator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[652]) || tp >= &(gTypes[653])) { + if (tp < &(gTypes[656]) || tp >= &(gTypes[657])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConditionalOperator::static_kind(): - tp = &(gTypes[652]); + tp = &(gTypes[656]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[652]); + PyTypeObject * const tp = &(gTypes[656]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[651].tp_hash; - tp->tp_richcompare = gTypes[651].tp_richcompare; + tp->tp_hash = gTypes[655].tp_hash; + tp->tp_richcompare = gTypes[655].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[651]); + tp->tp_base = &(gTypes[655]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConstAttr.cpp b/bindings/Python/Generated/AST/ConstAttr.cpp index 0a758bef5..ca5638b99 100644 --- a/bindings/Python/Generated/AST/ConstAttr.cpp +++ b/bindings/Python/Generated/AST/ConstAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[135]) || tp >= &(gTypes[136])) { + if (tp < &(gTypes[139]) || tp >= &(gTypes[140])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConstAttr::static_kind(): - tp = &(gTypes[135]); + tp = &(gTypes[139]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[135]); + PyTypeObject * const tp = &(gTypes[139]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConstInitAttr.cpp b/bindings/Python/Generated/AST/ConstInitAttr.cpp index dd3b011e0..cc6eba075 100644 --- a/bindings/Python/Generated/AST/ConstInitAttr.cpp +++ b/bindings/Python/Generated/AST/ConstInitAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[134]) || tp >= &(gTypes[135])) { + if (tp < &(gTypes[138]) || tp >= &(gTypes[139])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConstInitAttr::static_kind(): - tp = &(gTypes[134]); + tp = &(gTypes[138]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[134]); + PyTypeObject * const tp = &(gTypes[138]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConstantArrayType.cpp b/bindings/Python/Generated/AST/ConstantArrayType.cpp index f7f9bb222..79cc7bac6 100644 --- a/bindings/Python/Generated/AST/ConstantArrayType.cpp +++ b/bindings/Python/Generated/AST/ConstantArrayType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[458]) || tp >= &(gTypes[459])) { + if (tp < &(gTypes[462]) || tp >= &(gTypes[463])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConstantArrayType::static_kind(): - tp = &(gTypes[458]); + tp = &(gTypes[462]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[458]); + PyTypeObject * const tp = &(gTypes[462]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[454].tp_hash; - tp->tp_richcompare = gTypes[454].tp_richcompare; + tp->tp_hash = gTypes[458].tp_hash; + tp->tp_richcompare = gTypes[458].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[454]); + tp->tp_base = &(gTypes[458]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConstantExpr.cpp b/bindings/Python/Generated/AST/ConstantExpr.cpp index a85f7e1af..457dfa633 100644 --- a/bindings/Python/Generated/AST/ConstantExpr.cpp +++ b/bindings/Python/Generated/AST/ConstantExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[713]) || tp >= &(gTypes[714])) { + if (tp < &(gTypes[717]) || tp >= &(gTypes[718])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConstantExpr::static_kind(): - tp = &(gTypes[713]); + tp = &(gTypes[717]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[713]); + PyTypeObject * const tp = &(gTypes[717]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[711].tp_hash; - tp->tp_richcompare = gTypes[711].tp_richcompare; + tp->tp_hash = gTypes[715].tp_hash; + tp->tp_richcompare = gTypes[715].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[711]); + tp->tp_base = &(gTypes[715]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConstantMatrixType.cpp b/bindings/Python/Generated/AST/ConstantMatrixType.cpp index 5eda08b3b..95b1c73cd 100644 --- a/bindings/Python/Generated/AST/ConstantMatrixType.cpp +++ b/bindings/Python/Generated/AST/ConstantMatrixType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[433]) || tp >= &(gTypes[434])) { + if (tp < &(gTypes[437]) || tp >= &(gTypes[438])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConstantMatrixType::static_kind(): - tp = &(gTypes[433]); + tp = &(gTypes[437]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[433]); + PyTypeObject * const tp = &(gTypes[437]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[431].tp_hash; - tp->tp_richcompare = gTypes[431].tp_richcompare; + tp->tp_hash = gTypes[435].tp_hash; + tp->tp_richcompare = gTypes[435].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[431]); + tp->tp_base = &(gTypes[435]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConstructorAttr.cpp b/bindings/Python/Generated/AST/ConstructorAttr.cpp index e34051a0f..3c1b3b08e 100644 --- a/bindings/Python/Generated/AST/ConstructorAttr.cpp +++ b/bindings/Python/Generated/AST/ConstructorAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[133]) || tp >= &(gTypes[134])) { + if (tp < &(gTypes[137]) || tp >= &(gTypes[138])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConstructorAttr::static_kind(): - tp = &(gTypes[133]); + tp = &(gTypes[137]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[133]); + PyTypeObject * const tp = &(gTypes[137]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp b/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp index 697641a67..a8a9e6b7a 100644 --- a/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp +++ b/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[775]) || tp >= &(gTypes[776])) { + if (tp < &(gTypes[779]) || tp >= &(gTypes[780])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConstructorUsingShadowDecl::static_kind(): - tp = &(gTypes[775]); + tp = &(gTypes[779]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[775]); + PyTypeObject * const tp = &(gTypes[779]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[774].tp_hash; - tp->tp_richcompare = gTypes[774].tp_richcompare; + tp->tp_hash = gTypes[778].tp_hash; + tp->tp_richcompare = gTypes[778].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[774]); + tp->tp_base = &(gTypes[778]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConsumableAttr.cpp b/bindings/Python/Generated/AST/ConsumableAttr.cpp index 68d9f727a..cf912422c 100644 --- a/bindings/Python/Generated/AST/ConsumableAttr.cpp +++ b/bindings/Python/Generated/AST/ConsumableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[132]) || tp >= &(gTypes[133])) { + if (tp < &(gTypes[136]) || tp >= &(gTypes[137])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConsumableAttr::static_kind(): - tp = &(gTypes[132]); + tp = &(gTypes[136]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[132]); + PyTypeObject * const tp = &(gTypes[136]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp b/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp index a2f278ece..953ace18a 100644 --- a/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp +++ b/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[131]) || tp >= &(gTypes[132])) { + if (tp < &(gTypes[135]) || tp >= &(gTypes[136])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConsumableAutoCastAttr::static_kind(): - tp = &(gTypes[131]); + tp = &(gTypes[135]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[131]); + PyTypeObject * const tp = &(gTypes[135]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp b/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp index efeacb335..e2692ed0b 100644 --- a/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp +++ b/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[130]) || tp >= &(gTypes[131])) { + if (tp < &(gTypes[134]) || tp >= &(gTypes[135])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConsumableSetOnReadAttr::static_kind(): - tp = &(gTypes[130]); + tp = &(gTypes[134]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[130]); + PyTypeObject * const tp = &(gTypes[134]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ContinueStmt.cpp b/bindings/Python/Generated/AST/ContinueStmt.cpp index f5a4f1567..b8bf2cefe 100644 --- a/bindings/Python/Generated/AST/ContinueStmt.cpp +++ b/bindings/Python/Generated/AST/ContinueStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[573]) || tp >= &(gTypes[574])) { + if (tp < &(gTypes[577]) || tp >= &(gTypes[578])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ContinueStmt::static_kind(): - tp = &(gTypes[573]); + tp = &(gTypes[577]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[573]); + PyTypeObject * const tp = &(gTypes[577]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConvergentAttr.cpp b/bindings/Python/Generated/AST/ConvergentAttr.cpp index 9a31a9df8..091744bc6 100644 --- a/bindings/Python/Generated/AST/ConvergentAttr.cpp +++ b/bindings/Python/Generated/AST/ConvergentAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[129]) || tp >= &(gTypes[130])) { + if (tp < &(gTypes[133]) || tp >= &(gTypes[134])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConvergentAttr::static_kind(): - tp = &(gTypes[129]); + tp = &(gTypes[133]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[129]); + PyTypeObject * const tp = &(gTypes[133]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ConvertVectorExpr.cpp b/bindings/Python/Generated/AST/ConvertVectorExpr.cpp index 1a30a8faa..7a86d1482 100644 --- a/bindings/Python/Generated/AST/ConvertVectorExpr.cpp +++ b/bindings/Python/Generated/AST/ConvertVectorExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[595]) || tp >= &(gTypes[596])) { + if (tp < &(gTypes[599]) || tp >= &(gTypes[600])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ConvertVectorExpr::static_kind(): - tp = &(gTypes[595]); + tp = &(gTypes[599]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[595]); + PyTypeObject * const tp = &(gTypes[599]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoreturnStmt.cpp b/bindings/Python/Generated/AST/CoreturnStmt.cpp index 4b7b560a6..76d0fa900 100644 --- a/bindings/Python/Generated/AST/CoreturnStmt.cpp +++ b/bindings/Python/Generated/AST/CoreturnStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[572]) || tp >= &(gTypes[573])) { + if (tp < &(gTypes[576]) || tp >= &(gTypes[577])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoreturnStmt::static_kind(): - tp = &(gTypes[572]); + tp = &(gTypes[576]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[572]); + PyTypeObject * const tp = &(gTypes[576]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp b/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp index 582c5c26d..b422b95af 100644 --- a/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp +++ b/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[128]) || tp >= &(gTypes[129])) { + if (tp < &(gTypes[132]) || tp >= &(gTypes[133])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoroDisableLifetimeBoundAttr::static_kind(): - tp = &(gTypes[128]); + tp = &(gTypes[132]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[128]); + PyTypeObject * const tp = &(gTypes[132]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp b/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp index 68bd39d6c..c039ee1f0 100644 --- a/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp +++ b/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[127]) || tp >= &(gTypes[128])) { + if (tp < &(gTypes[131]) || tp >= &(gTypes[132])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoroLifetimeBoundAttr::static_kind(): - tp = &(gTypes[127]); + tp = &(gTypes[131]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[127]); + PyTypeObject * const tp = &(gTypes[131]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp b/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp index 4db1ada35..2b3be740d 100644 --- a/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp +++ b/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[126]) || tp >= &(gTypes[127])) { + if (tp < &(gTypes[130]) || tp >= &(gTypes[131])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoroOnlyDestroyWhenCompleteAttr::static_kind(): - tp = &(gTypes[126]); + tp = &(gTypes[130]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[126]); + PyTypeObject * const tp = &(gTypes[130]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp b/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp index adbfe93d6..6d568a635 100644 --- a/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp +++ b/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[125]) || tp >= &(gTypes[126])) { + if (tp < &(gTypes[129]) || tp >= &(gTypes[130])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoroReturnTypeAttr::static_kind(): - tp = &(gTypes[125]); + tp = &(gTypes[129]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[125]); + PyTypeObject * const tp = &(gTypes[129]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoroWrapperAttr.cpp b/bindings/Python/Generated/AST/CoroWrapperAttr.cpp index f5f4cf5ac..e64b62994 100644 --- a/bindings/Python/Generated/AST/CoroWrapperAttr.cpp +++ b/bindings/Python/Generated/AST/CoroWrapperAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[124]) || tp >= &(gTypes[125])) { + if (tp < &(gTypes[128]) || tp >= &(gTypes[129])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoroWrapperAttr::static_kind(): - tp = &(gTypes[124]); + tp = &(gTypes[128]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[124]); + PyTypeObject * const tp = &(gTypes[128]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp b/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp index 5a5e617a9..1cac83ffb 100644 --- a/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp +++ b/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[571]) || tp >= &(gTypes[572])) { + if (tp < &(gTypes[575]) || tp >= &(gTypes[576])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoroutineBodyStmt::static_kind(): - tp = &(gTypes[571]); + tp = &(gTypes[575]); break; } @@ -499,7 +499,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -551,7 +551,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[571]); + PyTypeObject * const tp = &(gTypes[575]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -566,12 +566,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp b/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp index a9c6ccd95..510407663 100644 --- a/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp +++ b/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[592]) || tp >= &(gTypes[595])) { + if (tp < &(gTypes[596]) || tp >= &(gTypes[599])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoawaitExpr::static_kind(): - tp = &(gTypes[593]); + tp = &(gTypes[597]); break; case mx::CoyieldExpr::static_kind(): - tp = &(gTypes[594]); + tp = &(gTypes[598]); break; } @@ -376,7 +376,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -406,7 +406,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[592]); + PyTypeObject * const tp = &(gTypes[596]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -421,12 +421,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CountedByAttr.cpp b/bindings/Python/Generated/AST/CountedByAttr.cpp index 0d6c95c59..2b2a1f0aa 100644 --- a/bindings/Python/Generated/AST/CountedByAttr.cpp +++ b/bindings/Python/Generated/AST/CountedByAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[123]) || tp >= &(gTypes[124])) { + if (tp < &(gTypes[127]) || tp >= &(gTypes[128])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CountedByAttr::static_kind(): - tp = &(gTypes[123]); + tp = &(gTypes[127]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[123]); + PyTypeObject * const tp = &(gTypes[127]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/CoyieldExpr.cpp b/bindings/Python/Generated/AST/CoyieldExpr.cpp index 56daea894..5e5ac6c5b 100644 --- a/bindings/Python/Generated/AST/CoyieldExpr.cpp +++ b/bindings/Python/Generated/AST/CoyieldExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[594]) || tp >= &(gTypes[595])) { + if (tp < &(gTypes[598]) || tp >= &(gTypes[599])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CoyieldExpr::static_kind(): - tp = &(gTypes[594]); + tp = &(gTypes[598]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[594]); + PyTypeObject * const tp = &(gTypes[598]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[592].tp_hash; - tp->tp_richcompare = gTypes[592].tp_richcompare; + tp->tp_hash = gTypes[596].tp_hash; + tp->tp_richcompare = gTypes[596].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[592]); + tp->tp_base = &(gTypes[596]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DLLExportAttr.cpp b/bindings/Python/Generated/AST/DLLExportAttr.cpp index 5ee1c53ae..97d8eab87 100644 --- a/bindings/Python/Generated/AST/DLLExportAttr.cpp +++ b/bindings/Python/Generated/AST/DLLExportAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[122]) || tp >= &(gTypes[123])) { + if (tp < &(gTypes[126]) || tp >= &(gTypes[127])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DLLExportAttr::static_kind(): - tp = &(gTypes[122]); + tp = &(gTypes[126]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[122]); + PyTypeObject * const tp = &(gTypes[126]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp b/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp index b339d3276..f9e4a81f6 100644 --- a/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp +++ b/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[121]) || tp >= &(gTypes[122])) { + if (tp < &(gTypes[125]) || tp >= &(gTypes[126])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DLLExportStaticLocalAttr::static_kind(): - tp = &(gTypes[121]); + tp = &(gTypes[125]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[121]); + PyTypeObject * const tp = &(gTypes[125]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DLLImportAttr.cpp b/bindings/Python/Generated/AST/DLLImportAttr.cpp index fc9b79068..632173ea8 100644 --- a/bindings/Python/Generated/AST/DLLImportAttr.cpp +++ b/bindings/Python/Generated/AST/DLLImportAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[120]) || tp >= &(gTypes[121])) { + if (tp < &(gTypes[124]) || tp >= &(gTypes[125])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DLLImportAttr::static_kind(): - tp = &(gTypes[120]); + tp = &(gTypes[124]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[120]); + PyTypeObject * const tp = &(gTypes[124]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp b/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp index 063236856..e9953dbc7 100644 --- a/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp +++ b/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[119]) || tp >= &(gTypes[120])) { + if (tp < &(gTypes[123]) || tp >= &(gTypes[124])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DLLImportStaticLocalAttr::static_kind(): - tp = &(gTypes[119]); + tp = &(gTypes[123]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[119]); + PyTypeObject * const tp = &(gTypes[123]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DecayedType.cpp b/bindings/Python/Generated/AST/DecayedType.cpp index 014b0b149..d86f400f0 100644 --- a/bindings/Python/Generated/AST/DecayedType.cpp +++ b/bindings/Python/Generated/AST/DecayedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[460]) || tp >= &(gTypes[461])) { + if (tp < &(gTypes[464]) || tp >= &(gTypes[465])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DecayedType::static_kind(): - tp = &(gTypes[460]); + tp = &(gTypes[464]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[460]); + PyTypeObject * const tp = &(gTypes[464]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[459].tp_hash; - tp->tp_richcompare = gTypes[459].tp_richcompare; + tp->tp_hash = gTypes[463].tp_hash; + tp->tp_richcompare = gTypes[463].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[459]); + tp->tp_base = &(gTypes[463]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Decl.cpp b/bindings/Python/Generated/AST/Decl.cpp index e45be069d..79f760263 100644 --- a/bindings/Python/Generated/AST/Decl.cpp +++ b/bindings/Python/Generated/AST/Decl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[723]) || tp >= &(gTypes[823])) { + if (tp < &(gTypes[727]) || tp >= &(gTypes[827])) { return std::nullopt; } @@ -88,347 +88,347 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CapturedDecl::static_kind(): - tp = &(gTypes[724]); + tp = &(gTypes[728]); break; case mx::BlockDecl::static_kind(): - tp = &(gTypes[725]); + tp = &(gTypes[729]); break; case mx::AccessSpecDecl::static_kind(): - tp = &(gTypes[726]); + tp = &(gTypes[730]); break; case mx::OMPThreadPrivateDecl::static_kind(): - tp = &(gTypes[728]); + tp = &(gTypes[732]); break; case mx::OMPRequiresDecl::static_kind(): - tp = &(gTypes[729]); + tp = &(gTypes[733]); break; case mx::OMPAllocateDecl::static_kind(): - tp = &(gTypes[730]); + tp = &(gTypes[734]); break; case mx::TranslationUnitDecl::static_kind(): - tp = &(gTypes[731]); + tp = &(gTypes[735]); break; case mx::TopLevelStmtDecl::static_kind(): - tp = &(gTypes[732]); + tp = &(gTypes[736]); break; case mx::StaticAssertDecl::static_kind(): - tp = &(gTypes[733]); + tp = &(gTypes[737]); break; case mx::RequiresExprBodyDecl::static_kind(): - tp = &(gTypes[734]); + tp = &(gTypes[738]); break; case mx::PragmaDetectMismatchDecl::static_kind(): - tp = &(gTypes[735]); + tp = &(gTypes[739]); break; case mx::PragmaCommentDecl::static_kind(): - tp = &(gTypes[736]); + tp = &(gTypes[740]); break; case mx::ObjCPropertyImplDecl::static_kind(): - tp = &(gTypes[737]); + tp = &(gTypes[741]); break; case mx::LabelDecl::static_kind(): - tp = &(gTypes[739]); + tp = &(gTypes[743]); break; case mx::HLSLBufferDecl::static_kind(): - tp = &(gTypes[740]); + tp = &(gTypes[744]); break; case mx::UsingEnumDecl::static_kind(): - tp = &(gTypes[742]); + tp = &(gTypes[746]); break; case mx::UsingDecl::static_kind(): - tp = &(gTypes[743]); + tp = &(gTypes[747]); break; case mx::UnresolvedUsingValueDecl::static_kind(): - tp = &(gTypes[745]); + tp = &(gTypes[749]); break; case mx::UnnamedGlobalConstantDecl::static_kind(): - tp = &(gTypes[746]); + tp = &(gTypes[750]); break; case mx::TemplateParamObjectDecl::static_kind(): - tp = &(gTypes[747]); + tp = &(gTypes[751]); break; case mx::OMPDeclareReductionDecl::static_kind(): - tp = &(gTypes[748]); + tp = &(gTypes[752]); break; case mx::MSGuidDecl::static_kind(): - tp = &(gTypes[749]); + tp = &(gTypes[753]); break; case mx::IndirectFieldDecl::static_kind(): - tp = &(gTypes[750]); + tp = &(gTypes[754]); break; case mx::EnumConstantDecl::static_kind(): - tp = &(gTypes[751]); + tp = &(gTypes[755]); break; case mx::VarDecl::static_kind(): - tp = &(gTypes[753]); + tp = &(gTypes[757]); break; case mx::ParmVarDecl::static_kind(): - tp = &(gTypes[754]); + tp = &(gTypes[758]); break; case mx::OMPCapturedExprDecl::static_kind(): - tp = &(gTypes[755]); + tp = &(gTypes[759]); break; case mx::ImplicitParamDecl::static_kind(): - tp = &(gTypes[756]); + tp = &(gTypes[760]); break; case mx::DecompositionDecl::static_kind(): - tp = &(gTypes[757]); + tp = &(gTypes[761]); break; case mx::VarTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[758]); + tp = &(gTypes[762]); break; case mx::VarTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[759]); + tp = &(gTypes[763]); break; case mx::NonTypeTemplateParmDecl::static_kind(): - tp = &(gTypes[760]); + tp = &(gTypes[764]); break; case mx::MSPropertyDecl::static_kind(): - tp = &(gTypes[761]); + tp = &(gTypes[765]); break; case mx::FunctionDecl::static_kind(): - tp = &(gTypes[762]); + tp = &(gTypes[766]); break; case mx::CXXMethodDecl::static_kind(): - tp = &(gTypes[763]); + tp = &(gTypes[767]); break; case mx::CXXDestructorDecl::static_kind(): - tp = &(gTypes[764]); + tp = &(gTypes[768]); break; case mx::CXXConversionDecl::static_kind(): - tp = &(gTypes[765]); + tp = &(gTypes[769]); break; case mx::CXXConstructorDecl::static_kind(): - tp = &(gTypes[766]); + tp = &(gTypes[770]); break; case mx::CXXDeductionGuideDecl::static_kind(): - tp = &(gTypes[767]); + tp = &(gTypes[771]); break; case mx::FieldDecl::static_kind(): - tp = &(gTypes[768]); + tp = &(gTypes[772]); break; case mx::ObjCIvarDecl::static_kind(): - tp = &(gTypes[769]); + tp = &(gTypes[773]); break; case mx::ObjCAtDefsFieldDecl::static_kind(): - tp = &(gTypes[770]); + tp = &(gTypes[774]); break; case mx::BindingDecl::static_kind(): - tp = &(gTypes[771]); + tp = &(gTypes[775]); break; case mx::OMPDeclareMapperDecl::static_kind(): - tp = &(gTypes[773]); + tp = &(gTypes[777]); break; case mx::UsingShadowDecl::static_kind(): - tp = &(gTypes[774]); + tp = &(gTypes[778]); break; case mx::ConstructorUsingShadowDecl::static_kind(): - tp = &(gTypes[775]); + tp = &(gTypes[779]); break; case mx::UsingPackDecl::static_kind(): - tp = &(gTypes[776]); + tp = &(gTypes[780]); break; case mx::UsingDirectiveDecl::static_kind(): - tp = &(gTypes[777]); + tp = &(gTypes[781]); break; case mx::UnresolvedUsingIfExistsDecl::static_kind(): - tp = &(gTypes[778]); + tp = &(gTypes[782]); break; case mx::TemplateTypeParmDecl::static_kind(): - tp = &(gTypes[780]); + tp = &(gTypes[784]); break; case mx::RecordDecl::static_kind(): - tp = &(gTypes[782]); + tp = &(gTypes[786]); break; case mx::CXXRecordDecl::static_kind(): - tp = &(gTypes[783]); + tp = &(gTypes[787]); break; case mx::ClassTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[784]); + tp = &(gTypes[788]); break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; case mx::EnumDecl::static_kind(): - tp = &(gTypes[786]); + tp = &(gTypes[790]); break; case mx::UnresolvedUsingTypenameDecl::static_kind(): - tp = &(gTypes[787]); + tp = &(gTypes[791]); break; case mx::TypedefDecl::static_kind(): - tp = &(gTypes[789]); + tp = &(gTypes[793]); break; case mx::TypeAliasDecl::static_kind(): - tp = &(gTypes[790]); + tp = &(gTypes[794]); break; case mx::ObjCTypeParamDecl::static_kind(): - tp = &(gTypes[791]); + tp = &(gTypes[795]); break; case mx::FunctionTemplateDecl::static_kind(): - tp = &(gTypes[794]); + tp = &(gTypes[798]); break; case mx::ClassTemplateDecl::static_kind(): - tp = &(gTypes[795]); + tp = &(gTypes[799]); break; case mx::VarTemplateDecl::static_kind(): - tp = &(gTypes[796]); + tp = &(gTypes[800]); break; case mx::TypeAliasTemplateDecl::static_kind(): - tp = &(gTypes[797]); + tp = &(gTypes[801]); break; case mx::ConceptDecl::static_kind(): - tp = &(gTypes[798]); + tp = &(gTypes[802]); break; case mx::BuiltinTemplateDecl::static_kind(): - tp = &(gTypes[799]); + tp = &(gTypes[803]); break; case mx::TemplateTemplateParmDecl::static_kind(): - tp = &(gTypes[800]); + tp = &(gTypes[804]); break; case mx::ObjCPropertyDecl::static_kind(): - tp = &(gTypes[801]); + tp = &(gTypes[805]); break; case mx::ObjCMethodDecl::static_kind(): - tp = &(gTypes[802]); + tp = &(gTypes[806]); break; case mx::ObjCCategoryDecl::static_kind(): - tp = &(gTypes[804]); + tp = &(gTypes[808]); break; case mx::ObjCProtocolDecl::static_kind(): - tp = &(gTypes[805]); + tp = &(gTypes[809]); break; case mx::ObjCInterfaceDecl::static_kind(): - tp = &(gTypes[806]); + tp = &(gTypes[810]); break; case mx::ObjCCategoryImplDecl::static_kind(): - tp = &(gTypes[808]); + tp = &(gTypes[812]); break; case mx::ObjCImplementationDecl::static_kind(): - tp = &(gTypes[809]); + tp = &(gTypes[813]); break; case mx::ObjCCompatibleAliasDecl::static_kind(): - tp = &(gTypes[810]); + tp = &(gTypes[814]); break; case mx::NamespaceDecl::static_kind(): - tp = &(gTypes[811]); + tp = &(gTypes[815]); break; case mx::NamespaceAliasDecl::static_kind(): - tp = &(gTypes[812]); + tp = &(gTypes[816]); break; case mx::LinkageSpecDecl::static_kind(): - tp = &(gTypes[813]); + tp = &(gTypes[817]); break; case mx::LifetimeExtendedTemporaryDecl::static_kind(): - tp = &(gTypes[814]); + tp = &(gTypes[818]); break; case mx::ImportDecl::static_kind(): - tp = &(gTypes[815]); + tp = &(gTypes[819]); break; case mx::ImplicitConceptSpecializationDecl::static_kind(): - tp = &(gTypes[816]); + tp = &(gTypes[820]); break; case mx::FriendTemplateDecl::static_kind(): - tp = &(gTypes[817]); + tp = &(gTypes[821]); break; case mx::FriendDecl::static_kind(): - tp = &(gTypes[818]); + tp = &(gTypes[822]); break; case mx::FileScopeAsmDecl::static_kind(): - tp = &(gTypes[819]); + tp = &(gTypes[823]); break; case mx::ExternCContextDecl::static_kind(): - tp = &(gTypes[820]); + tp = &(gTypes[824]); break; case mx::ExportDecl::static_kind(): - tp = &(gTypes[821]); + tp = &(gTypes[825]); break; case mx::EmptyDecl::static_kind(): - tp = &(gTypes[822]); + tp = &(gTypes[826]); break; } @@ -1126,7 +1126,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -1178,7 +1178,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[723]); + PyTypeObject * const tp = &(gTypes[727]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp b/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp index 213375633..fea2e015d 100644 --- a/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp +++ b/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[114]) || tp >= &(gTypes[119])) { + if (tp < &(gTypes[118]) || tp >= &(gTypes[123])) { return std::nullopt; } @@ -88,19 +88,19 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::AlwaysInlineAttr::static_kind(): - tp = &(gTypes[115]); + tp = &(gTypes[119]); break; case mx::SuppressAttr::static_kind(): - tp = &(gTypes[116]); + tp = &(gTypes[120]); break; case mx::NoMergeAttr::static_kind(): - tp = &(gTypes[117]); + tp = &(gTypes[121]); break; case mx::NoInlineAttr::static_kind(): - tp = &(gTypes[118]); + tp = &(gTypes[122]); break; } @@ -274,7 +274,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -326,7 +326,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[114]); + PyTypeObject * const tp = &(gTypes[118]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -341,12 +341,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DeclRefExpr.cpp b/bindings/Python/Generated/AST/DeclRefExpr.cpp index f5206bf43..3e735fd6b 100644 --- a/bindings/Python/Generated/AST/DeclRefExpr.cpp +++ b/bindings/Python/Generated/AST/DeclRefExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[591]) || tp >= &(gTypes[592])) { + if (tp < &(gTypes[595]) || tp >= &(gTypes[596])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DeclRefExpr::static_kind(): - tp = &(gTypes[591]); + tp = &(gTypes[595]); break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[591]); + PyTypeObject * const tp = &(gTypes[595]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -474,12 +474,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DeclStmt.cpp b/bindings/Python/Generated/AST/DeclStmt.cpp index b38fa81d0..d9ac35be6 100644 --- a/bindings/Python/Generated/AST/DeclStmt.cpp +++ b/bindings/Python/Generated/AST/DeclStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[570]) || tp >= &(gTypes[571])) { + if (tp < &(gTypes[574]) || tp >= &(gTypes[575])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DeclStmt::static_kind(): - tp = &(gTypes[570]); + tp = &(gTypes[574]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -411,7 +411,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[570]); + PyTypeObject * const tp = &(gTypes[574]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -426,12 +426,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DeclaratorDecl.cpp b/bindings/Python/Generated/AST/DeclaratorDecl.cpp index 7c54103fe..4c5f9bf96 100644 --- a/bindings/Python/Generated/AST/DeclaratorDecl.cpp +++ b/bindings/Python/Generated/AST/DeclaratorDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[752]) || tp >= &(gTypes[771])) { + if (tp < &(gTypes[756]) || tp >= &(gTypes[775])) { return std::nullopt; } @@ -88,75 +88,75 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VarDecl::static_kind(): - tp = &(gTypes[753]); + tp = &(gTypes[757]); break; case mx::ParmVarDecl::static_kind(): - tp = &(gTypes[754]); + tp = &(gTypes[758]); break; case mx::OMPCapturedExprDecl::static_kind(): - tp = &(gTypes[755]); + tp = &(gTypes[759]); break; case mx::ImplicitParamDecl::static_kind(): - tp = &(gTypes[756]); + tp = &(gTypes[760]); break; case mx::DecompositionDecl::static_kind(): - tp = &(gTypes[757]); + tp = &(gTypes[761]); break; case mx::VarTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[758]); + tp = &(gTypes[762]); break; case mx::VarTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[759]); + tp = &(gTypes[763]); break; case mx::NonTypeTemplateParmDecl::static_kind(): - tp = &(gTypes[760]); + tp = &(gTypes[764]); break; case mx::MSPropertyDecl::static_kind(): - tp = &(gTypes[761]); + tp = &(gTypes[765]); break; case mx::FunctionDecl::static_kind(): - tp = &(gTypes[762]); + tp = &(gTypes[766]); break; case mx::CXXMethodDecl::static_kind(): - tp = &(gTypes[763]); + tp = &(gTypes[767]); break; case mx::CXXDestructorDecl::static_kind(): - tp = &(gTypes[764]); + tp = &(gTypes[768]); break; case mx::CXXConversionDecl::static_kind(): - tp = &(gTypes[765]); + tp = &(gTypes[769]); break; case mx::CXXConstructorDecl::static_kind(): - tp = &(gTypes[766]); + tp = &(gTypes[770]); break; case mx::CXXDeductionGuideDecl::static_kind(): - tp = &(gTypes[767]); + tp = &(gTypes[771]); break; case mx::FieldDecl::static_kind(): - tp = &(gTypes[768]); + tp = &(gTypes[772]); break; case mx::ObjCIvarDecl::static_kind(): - tp = &(gTypes[769]); + tp = &(gTypes[773]); break; case mx::ObjCAtDefsFieldDecl::static_kind(): - tp = &(gTypes[770]); + tp = &(gTypes[774]); break; } @@ -470,7 +470,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -522,7 +522,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[752]); + PyTypeObject * const tp = &(gTypes[756]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -537,12 +537,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DecltypeType.cpp b/bindings/Python/Generated/AST/DecltypeType.cpp index 60c857730..f6779bf98 100644 --- a/bindings/Python/Generated/AST/DecltypeType.cpp +++ b/bindings/Python/Generated/AST/DecltypeType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[446]) || tp >= &(gTypes[447])) { + if (tp < &(gTypes[450]) || tp >= &(gTypes[451])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DecltypeType::static_kind(): - tp = &(gTypes[446]); + tp = &(gTypes[450]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[446]); + PyTypeObject * const tp = &(gTypes[450]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DecompositionDecl.cpp b/bindings/Python/Generated/AST/DecompositionDecl.cpp index b021e39a7..22c0a4326 100644 --- a/bindings/Python/Generated/AST/DecompositionDecl.cpp +++ b/bindings/Python/Generated/AST/DecompositionDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[757]) || tp >= &(gTypes[758])) { + if (tp < &(gTypes[761]) || tp >= &(gTypes[762])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DecompositionDecl::static_kind(): - tp = &(gTypes[757]); + tp = &(gTypes[761]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[757]); + PyTypeObject * const tp = &(gTypes[761]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[753].tp_hash; - tp->tp_richcompare = gTypes[753].tp_richcompare; + tp->tp_hash = gTypes[757].tp_hash; + tp->tp_richcompare = gTypes[757].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[753]); + tp->tp_base = &(gTypes[757]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp b/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp index 2dc76a4e7..0f22023bb 100644 --- a/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp +++ b/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[444]) || tp >= &(gTypes[445])) { + if (tp < &(gTypes[448]) || tp >= &(gTypes[449])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DeducedTemplateSpecializationType::static_kind(): - tp = &(gTypes[444]); + tp = &(gTypes[448]); break; } @@ -263,7 +263,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -315,7 +315,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[444]); + PyTypeObject * const tp = &(gTypes[448]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -330,12 +330,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[443].tp_hash; - tp->tp_richcompare = gTypes[443].tp_richcompare; + tp->tp_hash = gTypes[447].tp_hash; + tp->tp_richcompare = gTypes[447].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[443]); + tp->tp_base = &(gTypes[447]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DeducedType.cpp b/bindings/Python/Generated/AST/DeducedType.cpp index 21f847e17..ed07960b9 100644 --- a/bindings/Python/Generated/AST/DeducedType.cpp +++ b/bindings/Python/Generated/AST/DeducedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[443]) || tp >= &(gTypes[446])) { + if (tp < &(gTypes[447]) || tp >= &(gTypes[450])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DeducedTemplateSpecializationType::static_kind(): - tp = &(gTypes[444]); + tp = &(gTypes[448]); break; case mx::AutoType::static_kind(): - tp = &(gTypes[445]); + tp = &(gTypes[449]); break; } @@ -280,7 +280,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -332,7 +332,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[443]); + PyTypeObject * const tp = &(gTypes[447]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -347,12 +347,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DefaultStmt.cpp b/bindings/Python/Generated/AST/DefaultStmt.cpp index 9621f9014..dee147833 100644 --- a/bindings/Python/Generated/AST/DefaultStmt.cpp +++ b/bindings/Python/Generated/AST/DefaultStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[721]) || tp >= &(gTypes[722])) { + if (tp < &(gTypes[725]) || tp >= &(gTypes[726])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DefaultStmt::static_kind(): - tp = &(gTypes[721]); + tp = &(gTypes[725]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[721]); + PyTypeObject * const tp = &(gTypes[725]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[720].tp_hash; - tp->tp_richcompare = gTypes[720].tp_richcompare; + tp->tp_hash = gTypes[724].tp_hash; + tp->tp_richcompare = gTypes[724].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[720]); + tp->tp_base = &(gTypes[724]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp b/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp index 16c5053f2..48ceb1218 100644 --- a/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp +++ b/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[442]) || tp >= &(gTypes[443])) { + if (tp < &(gTypes[446]) || tp >= &(gTypes[447])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentAddressSpaceType::static_kind(): - tp = &(gTypes[442]); + tp = &(gTypes[446]); break; } @@ -303,7 +303,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -355,7 +355,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[442]); + PyTypeObject * const tp = &(gTypes[446]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -370,12 +370,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentBitIntType.cpp b/bindings/Python/Generated/AST/DependentBitIntType.cpp index cddc4581c..4accf0547 100644 --- a/bindings/Python/Generated/AST/DependentBitIntType.cpp +++ b/bindings/Python/Generated/AST/DependentBitIntType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[441]) || tp >= &(gTypes[442])) { + if (tp < &(gTypes[445]) || tp >= &(gTypes[446])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentBitIntType::static_kind(): - tp = &(gTypes[441]); + tp = &(gTypes[445]); break; } @@ -303,7 +303,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -355,7 +355,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[441]); + PyTypeObject * const tp = &(gTypes[445]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -370,12 +370,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp b/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp index 9fe2f368a..2b221a23a 100644 --- a/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp +++ b/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[590]) || tp >= &(gTypes[591])) { + if (tp < &(gTypes[594]) || tp >= &(gTypes[595])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentCoawaitExpr::static_kind(): - tp = &(gTypes[590]); + tp = &(gTypes[594]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[590]); + PyTypeObject * const tp = &(gTypes[594]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentNameType.cpp b/bindings/Python/Generated/AST/DependentNameType.cpp index a12278b62..b947cc3a5 100644 --- a/bindings/Python/Generated/AST/DependentNameType.cpp +++ b/bindings/Python/Generated/AST/DependentNameType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[464]) || tp >= &(gTypes[465])) { + if (tp < &(gTypes[468]) || tp >= &(gTypes[469])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentNameType::static_kind(): - tp = &(gTypes[464]); + tp = &(gTypes[468]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[464]); + PyTypeObject * const tp = &(gTypes[468]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[461].tp_hash; - tp->tp_richcompare = gTypes[461].tp_richcompare; + tp->tp_hash = gTypes[465].tp_hash; + tp->tp_richcompare = gTypes[465].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[461]); + tp->tp_base = &(gTypes[465]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp b/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp index 12ab97415..a074a6d9c 100644 --- a/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp +++ b/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[589]) || tp >= &(gTypes[590])) { + if (tp < &(gTypes[593]) || tp >= &(gTypes[594])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentScopeDeclRefExpr::static_kind(): - tp = &(gTypes[589]); + tp = &(gTypes[593]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[589]); + PyTypeObject * const tp = &(gTypes[593]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentSizedArrayType.cpp b/bindings/Python/Generated/AST/DependentSizedArrayType.cpp index b90957b73..5dac5386e 100644 --- a/bindings/Python/Generated/AST/DependentSizedArrayType.cpp +++ b/bindings/Python/Generated/AST/DependentSizedArrayType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[457]) || tp >= &(gTypes[458])) { + if (tp < &(gTypes[461]) || tp >= &(gTypes[462])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentSizedArrayType::static_kind(): - tp = &(gTypes[457]); + tp = &(gTypes[461]); break; } @@ -313,7 +313,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -365,7 +365,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[457]); + PyTypeObject * const tp = &(gTypes[461]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -380,12 +380,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[454].tp_hash; - tp->tp_richcompare = gTypes[454].tp_richcompare; + tp->tp_hash = gTypes[458].tp_hash; + tp->tp_richcompare = gTypes[458].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[454]); + tp->tp_base = &(gTypes[458]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp b/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp index 1b1291fa7..ef5a3e86e 100644 --- a/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp +++ b/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[440]) || tp >= &(gTypes[441])) { + if (tp < &(gTypes[444]) || tp >= &(gTypes[445])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentSizedExtVectorType::static_kind(): - tp = &(gTypes[440]); + tp = &(gTypes[444]); break; } @@ -303,7 +303,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -355,7 +355,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[440]); + PyTypeObject * const tp = &(gTypes[444]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -370,12 +370,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp b/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp index f730eed1f..f1c4500e9 100644 --- a/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp +++ b/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[432]) || tp >= &(gTypes[433])) { + if (tp < &(gTypes[436]) || tp >= &(gTypes[437])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentSizedMatrixType::static_kind(): - tp = &(gTypes[432]); + tp = &(gTypes[436]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[432]); + PyTypeObject * const tp = &(gTypes[436]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[431].tp_hash; - tp->tp_richcompare = gTypes[431].tp_richcompare; + tp->tp_hash = gTypes[435].tp_hash; + tp->tp_richcompare = gTypes[435].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[431]); + tp->tp_base = &(gTypes[435]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp b/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp index ab5d04312..c1328f2ff 100644 --- a/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp +++ b/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[463]) || tp >= &(gTypes[464])) { + if (tp < &(gTypes[467]) || tp >= &(gTypes[468])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentTemplateSpecializationType::static_kind(): - tp = &(gTypes[463]); + tp = &(gTypes[467]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -367,7 +367,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[463]); + PyTypeObject * const tp = &(gTypes[467]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -382,12 +382,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[461].tp_hash; - tp->tp_richcompare = gTypes[461].tp_richcompare; + tp->tp_hash = gTypes[465].tp_hash; + tp->tp_richcompare = gTypes[465].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[461]); + tp->tp_base = &(gTypes[465]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DependentVectorType.cpp b/bindings/Python/Generated/AST/DependentVectorType.cpp index 30e4c5331..4d8f87d9b 100644 --- a/bindings/Python/Generated/AST/DependentVectorType.cpp +++ b/bindings/Python/Generated/AST/DependentVectorType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[439]) || tp >= &(gTypes[440])) { + if (tp < &(gTypes[443]) || tp >= &(gTypes[444])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentVectorType::static_kind(): - tp = &(gTypes[439]); + tp = &(gTypes[443]); break; } @@ -313,7 +313,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -365,7 +365,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[439]); + PyTypeObject * const tp = &(gTypes[443]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -380,12 +380,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DeprecatedAttr.cpp b/bindings/Python/Generated/AST/DeprecatedAttr.cpp index 142df8619..04a98b035 100644 --- a/bindings/Python/Generated/AST/DeprecatedAttr.cpp +++ b/bindings/Python/Generated/AST/DeprecatedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[113]) || tp >= &(gTypes[114])) { + if (tp < &(gTypes[117]) || tp >= &(gTypes[118])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DeprecatedAttr::static_kind(): - tp = &(gTypes[113]); + tp = &(gTypes[117]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[113]); + PyTypeObject * const tp = &(gTypes[117]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DesignatedInitExpr.cpp b/bindings/Python/Generated/AST/DesignatedInitExpr.cpp index 78292c1e5..e5ebb7571 100644 --- a/bindings/Python/Generated/AST/DesignatedInitExpr.cpp +++ b/bindings/Python/Generated/AST/DesignatedInitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[588]) || tp >= &(gTypes[589])) { + if (tp < &(gTypes[592]) || tp >= &(gTypes[593])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DesignatedInitExpr::static_kind(): - tp = &(gTypes[588]); + tp = &(gTypes[592]); break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -493,7 +493,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[588]); + PyTypeObject * const tp = &(gTypes[592]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -508,12 +508,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp b/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp index fffbfa069..718292cdd 100644 --- a/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp +++ b/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[587]) || tp >= &(gTypes[588])) { + if (tp < &(gTypes[591]) || tp >= &(gTypes[592])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DesignatedInitUpdateExpr::static_kind(): - tp = &(gTypes[587]); + tp = &(gTypes[591]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[587]); + PyTypeObject * const tp = &(gTypes[591]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Designator.cpp b/bindings/Python/Generated/AST/Designator.cpp index 93e923c8a..2263bdcc1 100644 --- a/bindings/Python/Generated/AST/Designator.cpp +++ b/bindings/Python/Generated/AST/Designator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[2]) || tp >= &(gTypes[3])) { + if (tp < &(gTypes[6]) || tp >= &(gTypes[7])) { return std::nullopt; } @@ -376,7 +376,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -428,7 +428,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[2]); + PyTypeObject * const tp = &(gTypes[6]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/DestructorAttr.cpp b/bindings/Python/Generated/AST/DestructorAttr.cpp index 17edff76f..fc5250142 100644 --- a/bindings/Python/Generated/AST/DestructorAttr.cpp +++ b/bindings/Python/Generated/AST/DestructorAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[112]) || tp >= &(gTypes[113])) { + if (tp < &(gTypes[116]) || tp >= &(gTypes[117])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DestructorAttr::static_kind(): - tp = &(gTypes[112]); + tp = &(gTypes[116]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[112]); + PyTypeObject * const tp = &(gTypes[116]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp b/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp index f6c329be7..5289d755a 100644 --- a/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp +++ b/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[111]) || tp >= &(gTypes[112])) { + if (tp < &(gTypes[115]) || tp >= &(gTypes[116])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DiagnoseAsBuiltinAttr::static_kind(): - tp = &(gTypes[111]); + tp = &(gTypes[115]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[111]); + PyTypeObject * const tp = &(gTypes[115]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp b/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp index 90a94e6db..8ad8a1660 100644 --- a/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp +++ b/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[110]) || tp >= &(gTypes[111])) { + if (tp < &(gTypes[114]) || tp >= &(gTypes[115])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DiagnoseIfAttr::static_kind(): - tp = &(gTypes[110]); + tp = &(gTypes[114]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -411,7 +411,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[110]); + PyTypeObject * const tp = &(gTypes[114]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -426,12 +426,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp b/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp index 8bf363489..ed78f6767 100644 --- a/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp +++ b/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[109]) || tp >= &(gTypes[110])) { + if (tp < &(gTypes[113]) || tp >= &(gTypes[114])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DisableSanitizerInstrumentationAttr::static_kind(): - tp = &(gTypes[109]); + tp = &(gTypes[113]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[109]); + PyTypeObject * const tp = &(gTypes[113]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp b/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp index 01d4d540c..e0f241f0e 100644 --- a/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp +++ b/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[108]) || tp >= &(gTypes[109])) { + if (tp < &(gTypes[112]) || tp >= &(gTypes[113])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DisableTailCallsAttr::static_kind(): - tp = &(gTypes[108]); + tp = &(gTypes[112]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[108]); + PyTypeObject * const tp = &(gTypes[112]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/DoStmt.cpp b/bindings/Python/Generated/AST/DoStmt.cpp index 711c0d615..14c0fd32d 100644 --- a/bindings/Python/Generated/AST/DoStmt.cpp +++ b/bindings/Python/Generated/AST/DoStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[569]) || tp >= &(gTypes[570])) { + if (tp < &(gTypes[573]) || tp >= &(gTypes[574])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DoStmt::static_kind(): - tp = &(gTypes[569]); + tp = &(gTypes[573]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[569]); + PyTypeObject * const tp = &(gTypes[573]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ElaboratedType.cpp b/bindings/Python/Generated/AST/ElaboratedType.cpp index 7e4586e39..af569bacf 100644 --- a/bindings/Python/Generated/AST/ElaboratedType.cpp +++ b/bindings/Python/Generated/AST/ElaboratedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[462]) || tp >= &(gTypes[463])) { + if (tp < &(gTypes[466]) || tp >= &(gTypes[467])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ElaboratedType::static_kind(): - tp = &(gTypes[462]); + tp = &(gTypes[466]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[462]); + PyTypeObject * const tp = &(gTypes[466]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[461].tp_hash; - tp->tp_richcompare = gTypes[461].tp_richcompare; + tp->tp_hash = gTypes[465].tp_hash; + tp->tp_richcompare = gTypes[465].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[461]); + tp->tp_base = &(gTypes[465]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EmptyBasesAttr.cpp b/bindings/Python/Generated/AST/EmptyBasesAttr.cpp index d699c1025..356f41b9e 100644 --- a/bindings/Python/Generated/AST/EmptyBasesAttr.cpp +++ b/bindings/Python/Generated/AST/EmptyBasesAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[107]) || tp >= &(gTypes[108])) { + if (tp < &(gTypes[111]) || tp >= &(gTypes[112])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EmptyBasesAttr::static_kind(): - tp = &(gTypes[107]); + tp = &(gTypes[111]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[107]); + PyTypeObject * const tp = &(gTypes[111]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EmptyDecl.cpp b/bindings/Python/Generated/AST/EmptyDecl.cpp index 8910d36d6..bdc55fa30 100644 --- a/bindings/Python/Generated/AST/EmptyDecl.cpp +++ b/bindings/Python/Generated/AST/EmptyDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[822]) || tp >= &(gTypes[823])) { + if (tp < &(gTypes[826]) || tp >= &(gTypes[827])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EmptyDecl::static_kind(): - tp = &(gTypes[822]); + tp = &(gTypes[826]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[822]); + PyTypeObject * const tp = &(gTypes[826]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EnableIfAttr.cpp b/bindings/Python/Generated/AST/EnableIfAttr.cpp index a3859c1c3..7aa590379 100644 --- a/bindings/Python/Generated/AST/EnableIfAttr.cpp +++ b/bindings/Python/Generated/AST/EnableIfAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[106]) || tp >= &(gTypes[107])) { + if (tp < &(gTypes[110]) || tp >= &(gTypes[111])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EnableIfAttr::static_kind(): - tp = &(gTypes[106]); + tp = &(gTypes[110]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[106]); + PyTypeObject * const tp = &(gTypes[110]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EnforceTCBAttr.cpp b/bindings/Python/Generated/AST/EnforceTCBAttr.cpp index 3a3caee27..466ed48cc 100644 --- a/bindings/Python/Generated/AST/EnforceTCBAttr.cpp +++ b/bindings/Python/Generated/AST/EnforceTCBAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[105]) || tp >= &(gTypes[106])) { + if (tp < &(gTypes[109]) || tp >= &(gTypes[110])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EnforceTCBAttr::static_kind(): - tp = &(gTypes[105]); + tp = &(gTypes[109]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[105]); + PyTypeObject * const tp = &(gTypes[109]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp b/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp index d40e9a82a..0d80bb00f 100644 --- a/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp +++ b/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[104]) || tp >= &(gTypes[105])) { + if (tp < &(gTypes[108]) || tp >= &(gTypes[109])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EnforceTCBLeafAttr::static_kind(): - tp = &(gTypes[104]); + tp = &(gTypes[108]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[104]); + PyTypeObject * const tp = &(gTypes[108]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EnumConstantDecl.cpp b/bindings/Python/Generated/AST/EnumConstantDecl.cpp index f2f490840..62524f833 100644 --- a/bindings/Python/Generated/AST/EnumConstantDecl.cpp +++ b/bindings/Python/Generated/AST/EnumConstantDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[751]) || tp >= &(gTypes[752])) { + if (tp < &(gTypes[755]) || tp >= &(gTypes[756])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EnumConstantDecl::static_kind(): - tp = &(gTypes[751]); + tp = &(gTypes[755]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[751]); + PyTypeObject * const tp = &(gTypes[755]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EnumDecl.cpp b/bindings/Python/Generated/AST/EnumDecl.cpp index 4b5579eb9..447323c0e 100644 --- a/bindings/Python/Generated/AST/EnumDecl.cpp +++ b/bindings/Python/Generated/AST/EnumDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[786]) || tp >= &(gTypes[787])) { + if (tp < &(gTypes[790]) || tp >= &(gTypes[791])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EnumDecl::static_kind(): - tp = &(gTypes[786]); + tp = &(gTypes[790]); break; } @@ -469,7 +469,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -521,7 +521,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[786]); + PyTypeObject * const tp = &(gTypes[790]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -536,12 +536,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[781].tp_hash; - tp->tp_richcompare = gTypes[781].tp_richcompare; + tp->tp_hash = gTypes[785].tp_hash; + tp->tp_richcompare = gTypes[785].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[781]); + tp->tp_base = &(gTypes[785]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp b/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp index 4b00875ef..e0062d8fa 100644 --- a/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp +++ b/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[103]) || tp >= &(gTypes[104])) { + if (tp < &(gTypes[107]) || tp >= &(gTypes[108])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EnumExtensibilityAttr::static_kind(): - tp = &(gTypes[103]); + tp = &(gTypes[107]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[103]); + PyTypeObject * const tp = &(gTypes[107]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/EnumType.cpp b/bindings/Python/Generated/AST/EnumType.cpp index 98e8f479e..61c2e835c 100644 --- a/bindings/Python/Generated/AST/EnumType.cpp +++ b/bindings/Python/Generated/AST/EnumType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[415]) || tp >= &(gTypes[416])) { + if (tp < &(gTypes[419]) || tp >= &(gTypes[420])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EnumType::static_kind(): - tp = &(gTypes[415]); + tp = &(gTypes[419]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[415]); + PyTypeObject * const tp = &(gTypes[419]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[413].tp_hash; - tp->tp_richcompare = gTypes[413].tp_richcompare; + tp->tp_hash = gTypes[417].tp_hash; + tp->tp_richcompare = gTypes[417].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[413]); + tp->tp_base = &(gTypes[417]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ErrorAttr.cpp b/bindings/Python/Generated/AST/ErrorAttr.cpp index 8155ee551..03fa9d0cf 100644 --- a/bindings/Python/Generated/AST/ErrorAttr.cpp +++ b/bindings/Python/Generated/AST/ErrorAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[102]) || tp >= &(gTypes[103])) { + if (tp < &(gTypes[106]) || tp >= &(gTypes[107])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ErrorAttr::static_kind(): - tp = &(gTypes[102]); + tp = &(gTypes[106]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -381,7 +381,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[102]); + PyTypeObject * const tp = &(gTypes[106]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -396,12 +396,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp b/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp index 08c1d65d6..01913205d 100644 --- a/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp +++ b/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[101]) || tp >= &(gTypes[102])) { + if (tp < &(gTypes[105]) || tp >= &(gTypes[106])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExcludeFromExplicitInstantiationAttr::static_kind(): - tp = &(gTypes[101]); + tp = &(gTypes[105]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[101]); + PyTypeObject * const tp = &(gTypes[105]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp b/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp index f9e073721..1dc392445 100644 --- a/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp +++ b/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[100]) || tp >= &(gTypes[101])) { + if (tp < &(gTypes[104]) || tp >= &(gTypes[105])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExclusiveTrylockFunctionAttr::static_kind(): - tp = &(gTypes[100]); + tp = &(gTypes[104]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[100]); + PyTypeObject * const tp = &(gTypes[104]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExplicitCastExpr.cpp b/bindings/Python/Generated/AST/ExplicitCastExpr.cpp index 1b31e77ca..87fb6fbe3 100644 --- a/bindings/Python/Generated/AST/ExplicitCastExpr.cpp +++ b/bindings/Python/Generated/AST/ExplicitCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[602]) || tp >= &(gTypes[613])) { + if (tp < &(gTypes[606]) || tp >= &(gTypes[617])) { return std::nullopt; } @@ -88,39 +88,39 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CXXDynamicCastExpr::static_kind(): - tp = &(gTypes[604]); + tp = &(gTypes[608]); break; case mx::CXXConstCastExpr::static_kind(): - tp = &(gTypes[605]); + tp = &(gTypes[609]); break; case mx::CXXAddrspaceCastExpr::static_kind(): - tp = &(gTypes[606]); + tp = &(gTypes[610]); break; case mx::CXXStaticCastExpr::static_kind(): - tp = &(gTypes[607]); + tp = &(gTypes[611]); break; case mx::CXXReinterpretCastExpr::static_kind(): - tp = &(gTypes[608]); + tp = &(gTypes[612]); break; case mx::CXXFunctionalCastExpr::static_kind(): - tp = &(gTypes[609]); + tp = &(gTypes[613]); break; case mx::CStyleCastExpr::static_kind(): - tp = &(gTypes[610]); + tp = &(gTypes[614]); break; case mx::BuiltinBitCastExpr::static_kind(): - tp = &(gTypes[611]); + tp = &(gTypes[615]); break; case mx::ObjCBridgedCastExpr::static_kind(): - tp = &(gTypes[612]); + tp = &(gTypes[616]); break; } @@ -344,7 +344,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -374,7 +374,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[602]); + PyTypeObject * const tp = &(gTypes[606]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -389,12 +389,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[600].tp_hash; - tp->tp_richcompare = gTypes[600].tp_richcompare; + tp->tp_hash = gTypes[604].tp_hash; + tp->tp_richcompare = gTypes[604].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[600]); + tp->tp_base = &(gTypes[604]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExportDecl.cpp b/bindings/Python/Generated/AST/ExportDecl.cpp index 264ecd639..5d6a30a8b 100644 --- a/bindings/Python/Generated/AST/ExportDecl.cpp +++ b/bindings/Python/Generated/AST/ExportDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[821]) || tp >= &(gTypes[822])) { + if (tp < &(gTypes[825]) || tp >= &(gTypes[826])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExportDecl::static_kind(): - tp = &(gTypes[821]); + tp = &(gTypes[825]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[821]); + PyTypeObject * const tp = &(gTypes[825]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Expr.cpp b/bindings/Python/Generated/AST/Expr.cpp index 5bfe95d03..984b9510c 100644 --- a/bindings/Python/Generated/AST/Expr.cpp +++ b/bindings/Python/Generated/AST/Expr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[586]) || tp >= &(gTypes[718])) { + if (tp < &(gTypes[590]) || tp >= &(gTypes[722])) { return std::nullopt; } @@ -88,499 +88,499 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DesignatedInitUpdateExpr::static_kind(): - tp = &(gTypes[587]); + tp = &(gTypes[591]); break; case mx::DesignatedInitExpr::static_kind(): - tp = &(gTypes[588]); + tp = &(gTypes[592]); break; case mx::DependentScopeDeclRefExpr::static_kind(): - tp = &(gTypes[589]); + tp = &(gTypes[593]); break; case mx::DependentCoawaitExpr::static_kind(): - tp = &(gTypes[590]); + tp = &(gTypes[594]); break; case mx::DeclRefExpr::static_kind(): - tp = &(gTypes[591]); + tp = &(gTypes[595]); break; case mx::CoawaitExpr::static_kind(): - tp = &(gTypes[593]); + tp = &(gTypes[597]); break; case mx::CoyieldExpr::static_kind(): - tp = &(gTypes[594]); + tp = &(gTypes[598]); break; case mx::ConvertVectorExpr::static_kind(): - tp = &(gTypes[595]); + tp = &(gTypes[599]); break; case mx::ConceptSpecializationExpr::static_kind(): - tp = &(gTypes[596]); + tp = &(gTypes[600]); break; case mx::CompoundLiteralExpr::static_kind(): - tp = &(gTypes[597]); + tp = &(gTypes[601]); break; case mx::ChooseExpr::static_kind(): - tp = &(gTypes[598]); + tp = &(gTypes[602]); break; case mx::CharacterLiteral::static_kind(): - tp = &(gTypes[599]); + tp = &(gTypes[603]); break; case mx::ImplicitCastExpr::static_kind(): - tp = &(gTypes[601]); + tp = &(gTypes[605]); break; case mx::CXXDynamicCastExpr::static_kind(): - tp = &(gTypes[604]); + tp = &(gTypes[608]); break; case mx::CXXConstCastExpr::static_kind(): - tp = &(gTypes[605]); + tp = &(gTypes[609]); break; case mx::CXXAddrspaceCastExpr::static_kind(): - tp = &(gTypes[606]); + tp = &(gTypes[610]); break; case mx::CXXStaticCastExpr::static_kind(): - tp = &(gTypes[607]); + tp = &(gTypes[611]); break; case mx::CXXReinterpretCastExpr::static_kind(): - tp = &(gTypes[608]); + tp = &(gTypes[612]); break; case mx::CXXFunctionalCastExpr::static_kind(): - tp = &(gTypes[609]); + tp = &(gTypes[613]); break; case mx::CStyleCastExpr::static_kind(): - tp = &(gTypes[610]); + tp = &(gTypes[614]); break; case mx::BuiltinBitCastExpr::static_kind(): - tp = &(gTypes[611]); + tp = &(gTypes[615]); break; case mx::ObjCBridgedCastExpr::static_kind(): - tp = &(gTypes[612]); + tp = &(gTypes[616]); break; case mx::CallExpr::static_kind(): - tp = &(gTypes[613]); + tp = &(gTypes[617]); break; case mx::CXXOperatorCallExpr::static_kind(): - tp = &(gTypes[614]); + tp = &(gTypes[618]); break; case mx::CXXMemberCallExpr::static_kind(): - tp = &(gTypes[615]); + tp = &(gTypes[619]); break; case mx::CUDAKernelCallExpr::static_kind(): - tp = &(gTypes[616]); + tp = &(gTypes[620]); break; case mx::UserDefinedLiteral::static_kind(): - tp = &(gTypes[617]); + tp = &(gTypes[621]); break; case mx::CXXUuidofExpr::static_kind(): - tp = &(gTypes[618]); + tp = &(gTypes[622]); break; case mx::CXXUnresolvedConstructExpr::static_kind(): - tp = &(gTypes[619]); + tp = &(gTypes[623]); break; case mx::CXXTypeidExpr::static_kind(): - tp = &(gTypes[620]); + tp = &(gTypes[624]); break; case mx::CXXThrowExpr::static_kind(): - tp = &(gTypes[621]); + tp = &(gTypes[625]); break; case mx::CXXThisExpr::static_kind(): - tp = &(gTypes[622]); + tp = &(gTypes[626]); break; case mx::CXXStdInitializerListExpr::static_kind(): - tp = &(gTypes[623]); + tp = &(gTypes[627]); break; case mx::CXXScalarValueInitExpr::static_kind(): - tp = &(gTypes[624]); + tp = &(gTypes[628]); break; case mx::CXXRewrittenBinaryOperator::static_kind(): - tp = &(gTypes[625]); + tp = &(gTypes[629]); break; case mx::CXXPseudoDestructorExpr::static_kind(): - tp = &(gTypes[626]); + tp = &(gTypes[630]); break; case mx::CXXParenListInitExpr::static_kind(): - tp = &(gTypes[627]); + tp = &(gTypes[631]); break; case mx::CXXNullPtrLiteralExpr::static_kind(): - tp = &(gTypes[628]); + tp = &(gTypes[632]); break; case mx::CXXNoexceptExpr::static_kind(): - tp = &(gTypes[629]); + tp = &(gTypes[633]); break; case mx::CXXNewExpr::static_kind(): - tp = &(gTypes[630]); + tp = &(gTypes[634]); break; case mx::CXXInheritedCtorInitExpr::static_kind(): - tp = &(gTypes[631]); + tp = &(gTypes[635]); break; case mx::CXXFoldExpr::static_kind(): - tp = &(gTypes[632]); + tp = &(gTypes[636]); break; case mx::CXXDependentScopeMemberExpr::static_kind(): - tp = &(gTypes[633]); + tp = &(gTypes[637]); break; case mx::CXXDeleteExpr::static_kind(): - tp = &(gTypes[634]); + tp = &(gTypes[638]); break; case mx::CXXDefaultInitExpr::static_kind(): - tp = &(gTypes[635]); + tp = &(gTypes[639]); break; case mx::CXXDefaultArgExpr::static_kind(): - tp = &(gTypes[636]); + tp = &(gTypes[640]); break; case mx::CXXConstructExpr::static_kind(): - tp = &(gTypes[637]); + tp = &(gTypes[641]); break; case mx::CXXTemporaryObjectExpr::static_kind(): - tp = &(gTypes[638]); + tp = &(gTypes[642]); break; case mx::CXXBoolLiteralExpr::static_kind(): - tp = &(gTypes[639]); + tp = &(gTypes[643]); break; case mx::CXXBindTemporaryExpr::static_kind(): - tp = &(gTypes[640]); + tp = &(gTypes[644]); break; case mx::BlockExpr::static_kind(): - tp = &(gTypes[641]); + tp = &(gTypes[645]); break; case mx::BinaryOperator::static_kind(): - tp = &(gTypes[642]); + tp = &(gTypes[646]); break; case mx::CompoundAssignOperator::static_kind(): - tp = &(gTypes[643]); + tp = &(gTypes[647]); break; case mx::AtomicExpr::static_kind(): - tp = &(gTypes[644]); + tp = &(gTypes[648]); break; case mx::AsTypeExpr::static_kind(): - tp = &(gTypes[645]); + tp = &(gTypes[649]); break; case mx::ArrayTypeTraitExpr::static_kind(): - tp = &(gTypes[646]); + tp = &(gTypes[650]); break; case mx::ArraySubscriptExpr::static_kind(): - tp = &(gTypes[647]); + tp = &(gTypes[651]); break; case mx::ArrayInitLoopExpr::static_kind(): - tp = &(gTypes[648]); + tp = &(gTypes[652]); break; case mx::ArrayInitIndexExpr::static_kind(): - tp = &(gTypes[649]); + tp = &(gTypes[653]); break; case mx::AddrLabelExpr::static_kind(): - tp = &(gTypes[650]); + tp = &(gTypes[654]); break; case mx::ConditionalOperator::static_kind(): - tp = &(gTypes[652]); + tp = &(gTypes[656]); break; case mx::BinaryConditionalOperator::static_kind(): - tp = &(gTypes[653]); + tp = &(gTypes[657]); break; case mx::VAArgExpr::static_kind(): - tp = &(gTypes[654]); + tp = &(gTypes[658]); break; case mx::UnaryOperator::static_kind(): - tp = &(gTypes[655]); + tp = &(gTypes[659]); break; case mx::UnaryExprOrTypeTraitExpr::static_kind(): - tp = &(gTypes[656]); + tp = &(gTypes[660]); break; case mx::TypoExpr::static_kind(): - tp = &(gTypes[657]); + tp = &(gTypes[661]); break; case mx::TypeTraitExpr::static_kind(): - tp = &(gTypes[658]); + tp = &(gTypes[662]); break; case mx::SubstNonTypeTemplateParmPackExpr::static_kind(): - tp = &(gTypes[659]); + tp = &(gTypes[663]); break; case mx::SubstNonTypeTemplateParmExpr::static_kind(): - tp = &(gTypes[660]); + tp = &(gTypes[664]); break; case mx::StringLiteral::static_kind(): - tp = &(gTypes[661]); + tp = &(gTypes[665]); break; case mx::StmtExpr::static_kind(): - tp = &(gTypes[662]); + tp = &(gTypes[666]); break; case mx::SourceLocExpr::static_kind(): - tp = &(gTypes[663]); + tp = &(gTypes[667]); break; case mx::SizeOfPackExpr::static_kind(): - tp = &(gTypes[664]); + tp = &(gTypes[668]); break; case mx::ShuffleVectorExpr::static_kind(): - tp = &(gTypes[665]); + tp = &(gTypes[669]); break; case mx::SYCLUniqueStableNameExpr::static_kind(): - tp = &(gTypes[666]); + tp = &(gTypes[670]); break; case mx::RequiresExpr::static_kind(): - tp = &(gTypes[667]); + tp = &(gTypes[671]); break; case mx::RecoveryExpr::static_kind(): - tp = &(gTypes[668]); + tp = &(gTypes[672]); break; case mx::PseudoObjectExpr::static_kind(): - tp = &(gTypes[669]); + tp = &(gTypes[673]); break; case mx::PredefinedExpr::static_kind(): - tp = &(gTypes[670]); + tp = &(gTypes[674]); break; case mx::ParenListExpr::static_kind(): - tp = &(gTypes[671]); + tp = &(gTypes[675]); break; case mx::ParenExpr::static_kind(): - tp = &(gTypes[672]); + tp = &(gTypes[676]); break; case mx::PackExpansionExpr::static_kind(): - tp = &(gTypes[673]); + tp = &(gTypes[677]); break; case mx::UnresolvedMemberExpr::static_kind(): - tp = &(gTypes[675]); + tp = &(gTypes[679]); break; case mx::UnresolvedLookupExpr::static_kind(): - tp = &(gTypes[676]); + tp = &(gTypes[680]); break; case mx::OpaqueValueExpr::static_kind(): - tp = &(gTypes[677]); + tp = &(gTypes[681]); break; case mx::OffsetOfExpr::static_kind(): - tp = &(gTypes[678]); + tp = &(gTypes[682]); break; case mx::ObjCSubscriptRefExpr::static_kind(): - tp = &(gTypes[679]); + tp = &(gTypes[683]); break; case mx::ObjCStringLiteral::static_kind(): - tp = &(gTypes[680]); + tp = &(gTypes[684]); break; case mx::ObjCSelectorExpr::static_kind(): - tp = &(gTypes[681]); + tp = &(gTypes[685]); break; case mx::ObjCProtocolExpr::static_kind(): - tp = &(gTypes[682]); + tp = &(gTypes[686]); break; case mx::ObjCPropertyRefExpr::static_kind(): - tp = &(gTypes[683]); + tp = &(gTypes[687]); break; case mx::ObjCMessageExpr::static_kind(): - tp = &(gTypes[684]); + tp = &(gTypes[688]); break; case mx::ObjCIvarRefExpr::static_kind(): - tp = &(gTypes[685]); + tp = &(gTypes[689]); break; case mx::ObjCIsaExpr::static_kind(): - tp = &(gTypes[686]); + tp = &(gTypes[690]); break; case mx::ObjCIndirectCopyRestoreExpr::static_kind(): - tp = &(gTypes[687]); + tp = &(gTypes[691]); break; case mx::ObjCEncodeExpr::static_kind(): - tp = &(gTypes[688]); + tp = &(gTypes[692]); break; case mx::ObjCDictionaryLiteral::static_kind(): - tp = &(gTypes[689]); + tp = &(gTypes[693]); break; case mx::ObjCBoxedExpr::static_kind(): - tp = &(gTypes[690]); + tp = &(gTypes[694]); break; case mx::ObjCBoolLiteralExpr::static_kind(): - tp = &(gTypes[691]); + tp = &(gTypes[695]); break; case mx::ObjCAvailabilityCheckExpr::static_kind(): - tp = &(gTypes[692]); + tp = &(gTypes[696]); break; case mx::ObjCArrayLiteral::static_kind(): - tp = &(gTypes[693]); + tp = &(gTypes[697]); break; case mx::OMPIteratorExpr::static_kind(): - tp = &(gTypes[694]); + tp = &(gTypes[698]); break; case mx::OMPArrayShapingExpr::static_kind(): - tp = &(gTypes[695]); + tp = &(gTypes[699]); break; case mx::OMPArraySectionExpr::static_kind(): - tp = &(gTypes[696]); + tp = &(gTypes[700]); break; case mx::NoInitExpr::static_kind(): - tp = &(gTypes[697]); + tp = &(gTypes[701]); break; case mx::MemberExpr::static_kind(): - tp = &(gTypes[698]); + tp = &(gTypes[702]); break; case mx::MatrixSubscriptExpr::static_kind(): - tp = &(gTypes[699]); + tp = &(gTypes[703]); break; case mx::MaterializeTemporaryExpr::static_kind(): - tp = &(gTypes[700]); + tp = &(gTypes[704]); break; case mx::MSPropertySubscriptExpr::static_kind(): - tp = &(gTypes[701]); + tp = &(gTypes[705]); break; case mx::MSPropertyRefExpr::static_kind(): - tp = &(gTypes[702]); + tp = &(gTypes[706]); break; case mx::LambdaExpr::static_kind(): - tp = &(gTypes[703]); + tp = &(gTypes[707]); break; case mx::IntegerLiteral::static_kind(): - tp = &(gTypes[704]); + tp = &(gTypes[708]); break; case mx::InitListExpr::static_kind(): - tp = &(gTypes[705]); + tp = &(gTypes[709]); break; case mx::ImplicitValueInitExpr::static_kind(): - tp = &(gTypes[706]); + tp = &(gTypes[710]); break; case mx::ImaginaryLiteral::static_kind(): - tp = &(gTypes[707]); + tp = &(gTypes[711]); break; case mx::GenericSelectionExpr::static_kind(): - tp = &(gTypes[708]); + tp = &(gTypes[712]); break; case mx::GNUNullExpr::static_kind(): - tp = &(gTypes[709]); + tp = &(gTypes[713]); break; case mx::FunctionParmPackExpr::static_kind(): - tp = &(gTypes[710]); + tp = &(gTypes[714]); break; case mx::ExprWithCleanups::static_kind(): - tp = &(gTypes[712]); + tp = &(gTypes[716]); break; case mx::ConstantExpr::static_kind(): - tp = &(gTypes[713]); + tp = &(gTypes[717]); break; case mx::FloatingLiteral::static_kind(): - tp = &(gTypes[714]); + tp = &(gTypes[718]); break; case mx::FixedPointLiteral::static_kind(): - tp = &(gTypes[715]); + tp = &(gTypes[719]); break; case mx::ExtVectorElementExpr::static_kind(): - tp = &(gTypes[716]); + tp = &(gTypes[720]); break; case mx::ExpressionTraitExpr::static_kind(): - tp = &(gTypes[717]); + tp = &(gTypes[721]); break; } @@ -1184,7 +1184,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -1214,7 +1214,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[586]); + PyTypeObject * const tp = &(gTypes[590]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -1229,12 +1229,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[584].tp_hash; - tp->tp_richcompare = gTypes[584].tp_richcompare; + tp->tp_hash = gTypes[588].tp_hash; + tp->tp_richcompare = gTypes[588].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[584]); + tp->tp_base = &(gTypes[588]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExprWithCleanups.cpp b/bindings/Python/Generated/AST/ExprWithCleanups.cpp index 45e8eb8f0..fa096952f 100644 --- a/bindings/Python/Generated/AST/ExprWithCleanups.cpp +++ b/bindings/Python/Generated/AST/ExprWithCleanups.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[712]) || tp >= &(gTypes[713])) { + if (tp < &(gTypes[716]) || tp >= &(gTypes[717])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExprWithCleanups::static_kind(): - tp = &(gTypes[712]); + tp = &(gTypes[716]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[712]); + PyTypeObject * const tp = &(gTypes[716]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[711].tp_hash; - tp->tp_richcompare = gTypes[711].tp_richcompare; + tp->tp_hash = gTypes[715].tp_hash; + tp->tp_richcompare = gTypes[715].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[711]); + tp->tp_base = &(gTypes[715]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp b/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp index 514346d1d..de909a991 100644 --- a/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp +++ b/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[717]) || tp >= &(gTypes[718])) { + if (tp < &(gTypes[721]) || tp >= &(gTypes[722])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExpressionTraitExpr::static_kind(): - tp = &(gTypes[717]); + tp = &(gTypes[721]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[717]); + PyTypeObject * const tp = &(gTypes[721]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp b/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp index 2a6be2599..5074e9d69 100644 --- a/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp +++ b/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[716]) || tp >= &(gTypes[717])) { + if (tp < &(gTypes[720]) || tp >= &(gTypes[721])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExtVectorElementExpr::static_kind(): - tp = &(gTypes[716]); + tp = &(gTypes[720]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[716]); + PyTypeObject * const tp = &(gTypes[720]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExtVectorType.cpp b/bindings/Python/Generated/AST/ExtVectorType.cpp index 763b57c50..feb3d0331 100644 --- a/bindings/Python/Generated/AST/ExtVectorType.cpp +++ b/bindings/Python/Generated/AST/ExtVectorType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[466]) || tp >= &(gTypes[467])) { + if (tp < &(gTypes[470]) || tp >= &(gTypes[471])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExtVectorType::static_kind(): - tp = &(gTypes[466]); + tp = &(gTypes[470]); break; } @@ -263,7 +263,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -315,7 +315,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[466]); + PyTypeObject * const tp = &(gTypes[470]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -330,12 +330,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[465].tp_hash; - tp->tp_richcompare = gTypes[465].tp_richcompare; + tp->tp_hash = gTypes[469].tp_hash; + tp->tp_richcompare = gTypes[469].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[465]); + tp->tp_base = &(gTypes[469]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExternCContextDecl.cpp b/bindings/Python/Generated/AST/ExternCContextDecl.cpp index 21ba4f3e1..284964c8c 100644 --- a/bindings/Python/Generated/AST/ExternCContextDecl.cpp +++ b/bindings/Python/Generated/AST/ExternCContextDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[820]) || tp >= &(gTypes[821])) { + if (tp < &(gTypes[824]) || tp >= &(gTypes[825])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExternCContextDecl::static_kind(): - tp = &(gTypes[820]); + tp = &(gTypes[824]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[820]); + PyTypeObject * const tp = &(gTypes[824]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp b/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp index dfabb8a70..34caea119 100644 --- a/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp +++ b/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[99]) || tp >= &(gTypes[100])) { + if (tp < &(gTypes[103]) || tp >= &(gTypes[104])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExternalSourceSymbolAttr::static_kind(): - tp = &(gTypes[99]); + tp = &(gTypes[103]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -401,7 +401,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[99]); + PyTypeObject * const tp = &(gTypes[103]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -416,12 +416,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FallThroughAttr.cpp b/bindings/Python/Generated/AST/FallThroughAttr.cpp index 40dd0eb4d..f6b0c2c68 100644 --- a/bindings/Python/Generated/AST/FallThroughAttr.cpp +++ b/bindings/Python/Generated/AST/FallThroughAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[52]) || tp >= &(gTypes[53])) { + if (tp < &(gTypes[56]) || tp >= &(gTypes[57])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FallThroughAttr::static_kind(): - tp = &(gTypes[52]); + tp = &(gTypes[56]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[52]); + PyTypeObject * const tp = &(gTypes[56]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[48].tp_hash; - tp->tp_richcompare = gTypes[48].tp_richcompare; + tp->tp_hash = gTypes[52].tp_hash; + tp->tp_richcompare = gTypes[52].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[48]); + tp->tp_base = &(gTypes[52]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FastCallAttr.cpp b/bindings/Python/Generated/AST/FastCallAttr.cpp index 8da428630..b76daa554 100644 --- a/bindings/Python/Generated/AST/FastCallAttr.cpp +++ b/bindings/Python/Generated/AST/FastCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[98]) || tp >= &(gTypes[99])) { + if (tp < &(gTypes[102]) || tp >= &(gTypes[103])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FastCallAttr::static_kind(): - tp = &(gTypes[98]); + tp = &(gTypes[102]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[98]); + PyTypeObject * const tp = &(gTypes[102]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FieldDecl.cpp b/bindings/Python/Generated/AST/FieldDecl.cpp index a45dfcfe0..d77cfa501 100644 --- a/bindings/Python/Generated/AST/FieldDecl.cpp +++ b/bindings/Python/Generated/AST/FieldDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[768]) || tp >= &(gTypes[771])) { + if (tp < &(gTypes[772]) || tp >= &(gTypes[775])) { return std::nullopt; } @@ -88,15 +88,15 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FieldDecl::static_kind(): - tp = &(gTypes[768]); + tp = &(gTypes[772]); break; case mx::ObjCIvarDecl::static_kind(): - tp = &(gTypes[769]); + tp = &(gTypes[773]); break; case mx::ObjCAtDefsFieldDecl::static_kind(): - tp = &(gTypes[770]); + tp = &(gTypes[774]); break; } @@ -517,7 +517,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -547,7 +547,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[768]); + PyTypeObject * const tp = &(gTypes[772]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -562,12 +562,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[752].tp_hash; - tp->tp_richcompare = gTypes[752].tp_richcompare; + tp->tp_hash = gTypes[756].tp_hash; + tp->tp_richcompare = gTypes[756].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[752]); + tp->tp_base = &(gTypes[756]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp b/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp index 1e3405bb8..0ccf6fd18 100644 --- a/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp +++ b/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[819]) || tp >= &(gTypes[820])) { + if (tp < &(gTypes[823]) || tp >= &(gTypes[824])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FileScopeAsmDecl::static_kind(): - tp = &(gTypes[819]); + tp = &(gTypes[823]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[819]); + PyTypeObject * const tp = &(gTypes[823]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FinalAttr.cpp b/bindings/Python/Generated/AST/FinalAttr.cpp index 3592dbf02..b4da9db4d 100644 --- a/bindings/Python/Generated/AST/FinalAttr.cpp +++ b/bindings/Python/Generated/AST/FinalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[97]) || tp >= &(gTypes[98])) { + if (tp < &(gTypes[101]) || tp >= &(gTypes[102])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FinalAttr::static_kind(): - tp = &(gTypes[97]); + tp = &(gTypes[101]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[97]); + PyTypeObject * const tp = &(gTypes[101]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FixedPointLiteral.cpp b/bindings/Python/Generated/AST/FixedPointLiteral.cpp index c8e4dd920..dc3c41bbf 100644 --- a/bindings/Python/Generated/AST/FixedPointLiteral.cpp +++ b/bindings/Python/Generated/AST/FixedPointLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[715]) || tp >= &(gTypes[716])) { + if (tp < &(gTypes[719]) || tp >= &(gTypes[720])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FixedPointLiteral::static_kind(): - tp = &(gTypes[715]); + tp = &(gTypes[719]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[715]); + PyTypeObject * const tp = &(gTypes[719]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FlagEnumAttr.cpp b/bindings/Python/Generated/AST/FlagEnumAttr.cpp index 53f37437a..ae0db258c 100644 --- a/bindings/Python/Generated/AST/FlagEnumAttr.cpp +++ b/bindings/Python/Generated/AST/FlagEnumAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[96]) || tp >= &(gTypes[97])) { + if (tp < &(gTypes[100]) || tp >= &(gTypes[101])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FlagEnumAttr::static_kind(): - tp = &(gTypes[96]); + tp = &(gTypes[100]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[96]); + PyTypeObject * const tp = &(gTypes[100]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FlattenAttr.cpp b/bindings/Python/Generated/AST/FlattenAttr.cpp index 5f6ee0889..eaa2edf12 100644 --- a/bindings/Python/Generated/AST/FlattenAttr.cpp +++ b/bindings/Python/Generated/AST/FlattenAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[95]) || tp >= &(gTypes[96])) { + if (tp < &(gTypes[99]) || tp >= &(gTypes[100])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FlattenAttr::static_kind(): - tp = &(gTypes[95]); + tp = &(gTypes[99]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[95]); + PyTypeObject * const tp = &(gTypes[99]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FloatingLiteral.cpp b/bindings/Python/Generated/AST/FloatingLiteral.cpp index dcecc8604..def86a4a9 100644 --- a/bindings/Python/Generated/AST/FloatingLiteral.cpp +++ b/bindings/Python/Generated/AST/FloatingLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[714]) || tp >= &(gTypes[715])) { + if (tp < &(gTypes[718]) || tp >= &(gTypes[719])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FloatingLiteral::static_kind(): - tp = &(gTypes[714]); + tp = &(gTypes[718]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[714]); + PyTypeObject * const tp = &(gTypes[718]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ForStmt.cpp b/bindings/Python/Generated/AST/ForStmt.cpp index 54868472a..6ab55ddb8 100644 --- a/bindings/Python/Generated/AST/ForStmt.cpp +++ b/bindings/Python/Generated/AST/ForStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[568]) || tp >= &(gTypes[569])) { + if (tp < &(gTypes[572]) || tp >= &(gTypes[573])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ForStmt::static_kind(): - tp = &(gTypes[568]); + tp = &(gTypes[572]); break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -439,7 +439,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[568]); + PyTypeObject * const tp = &(gTypes[572]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -454,12 +454,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FormatArgAttr.cpp b/bindings/Python/Generated/AST/FormatArgAttr.cpp index 271128c82..a81e905ff 100644 --- a/bindings/Python/Generated/AST/FormatArgAttr.cpp +++ b/bindings/Python/Generated/AST/FormatArgAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[94]) || tp >= &(gTypes[95])) { + if (tp < &(gTypes[98]) || tp >= &(gTypes[99])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FormatArgAttr::static_kind(): - tp = &(gTypes[94]); + tp = &(gTypes[98]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[94]); + PyTypeObject * const tp = &(gTypes[98]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FormatAttr.cpp b/bindings/Python/Generated/AST/FormatAttr.cpp index 650512ff6..8f13b7b56 100644 --- a/bindings/Python/Generated/AST/FormatAttr.cpp +++ b/bindings/Python/Generated/AST/FormatAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[93]) || tp >= &(gTypes[94])) { + if (tp < &(gTypes[97]) || tp >= &(gTypes[98])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FormatAttr::static_kind(): - tp = &(gTypes[93]); + tp = &(gTypes[97]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[93]); + PyTypeObject * const tp = &(gTypes[97]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FriendDecl.cpp b/bindings/Python/Generated/AST/FriendDecl.cpp index 0b913dc6f..a1e59cff7 100644 --- a/bindings/Python/Generated/AST/FriendDecl.cpp +++ b/bindings/Python/Generated/AST/FriendDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[818]) || tp >= &(gTypes[819])) { + if (tp < &(gTypes[822]) || tp >= &(gTypes[823])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FriendDecl::static_kind(): - tp = &(gTypes[818]); + tp = &(gTypes[822]); break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -471,7 +471,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[818]); + PyTypeObject * const tp = &(gTypes[822]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -486,12 +486,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FriendTemplateDecl.cpp b/bindings/Python/Generated/AST/FriendTemplateDecl.cpp index 8ffd6c201..0dc717339 100644 --- a/bindings/Python/Generated/AST/FriendTemplateDecl.cpp +++ b/bindings/Python/Generated/AST/FriendTemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[817]) || tp >= &(gTypes[818])) { + if (tp < &(gTypes[821]) || tp >= &(gTypes[822])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FriendTemplateDecl::static_kind(): - tp = &(gTypes[817]); + tp = &(gTypes[821]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -451,7 +451,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[817]); + PyTypeObject * const tp = &(gTypes[821]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -466,12 +466,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FullExpr.cpp b/bindings/Python/Generated/AST/FullExpr.cpp index 9d6c3502f..fe9b95eec 100644 --- a/bindings/Python/Generated/AST/FullExpr.cpp +++ b/bindings/Python/Generated/AST/FullExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[711]) || tp >= &(gTypes[714])) { + if (tp < &(gTypes[715]) || tp >= &(gTypes[718])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ExprWithCleanups::static_kind(): - tp = &(gTypes[712]); + tp = &(gTypes[716]); break; case mx::ConstantExpr::static_kind(): - tp = &(gTypes[713]); + tp = &(gTypes[717]); break; } @@ -316,7 +316,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -346,7 +346,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[711]); + PyTypeObject * const tp = &(gTypes[715]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -361,12 +361,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FunctionDecl.cpp b/bindings/Python/Generated/AST/FunctionDecl.cpp index fca780c83..878314991 100644 --- a/bindings/Python/Generated/AST/FunctionDecl.cpp +++ b/bindings/Python/Generated/AST/FunctionDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[762]) || tp >= &(gTypes[768])) { + if (tp < &(gTypes[766]) || tp >= &(gTypes[772])) { return std::nullopt; } @@ -88,27 +88,27 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionDecl::static_kind(): - tp = &(gTypes[762]); + tp = &(gTypes[766]); break; case mx::CXXMethodDecl::static_kind(): - tp = &(gTypes[763]); + tp = &(gTypes[767]); break; case mx::CXXDestructorDecl::static_kind(): - tp = &(gTypes[764]); + tp = &(gTypes[768]); break; case mx::CXXConversionDecl::static_kind(): - tp = &(gTypes[765]); + tp = &(gTypes[769]); break; case mx::CXXConstructorDecl::static_kind(): - tp = &(gTypes[766]); + tp = &(gTypes[770]); break; case mx::CXXDeductionGuideDecl::static_kind(): - tp = &(gTypes[767]); + tp = &(gTypes[771]); break; } @@ -1219,7 +1219,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -1293,7 +1293,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[762]); + PyTypeObject * const tp = &(gTypes[766]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -1308,12 +1308,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[752].tp_hash; - tp->tp_richcompare = gTypes[752].tp_richcompare; + tp->tp_hash = gTypes[756].tp_hash; + tp->tp_richcompare = gTypes[756].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[752]); + tp->tp_base = &(gTypes[756]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FunctionNoProtoType.cpp b/bindings/Python/Generated/AST/FunctionNoProtoType.cpp index d8be7a38f..3b0ab2d89 100644 --- a/bindings/Python/Generated/AST/FunctionNoProtoType.cpp +++ b/bindings/Python/Generated/AST/FunctionNoProtoType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[438]) || tp >= &(gTypes[439])) { + if (tp < &(gTypes[442]) || tp >= &(gTypes[443])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionNoProtoType::static_kind(): - tp = &(gTypes[438]); + tp = &(gTypes[442]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[438]); + PyTypeObject * const tp = &(gTypes[442]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[436].tp_hash; - tp->tp_richcompare = gTypes[436].tp_richcompare; + tp->tp_hash = gTypes[440].tp_hash; + tp->tp_richcompare = gTypes[440].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[436]); + tp->tp_base = &(gTypes[440]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp b/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp index 427833a3e..648548071 100644 --- a/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp +++ b/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[710]) || tp >= &(gTypes[711])) { + if (tp < &(gTypes[714]) || tp >= &(gTypes[715])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionParmPackExpr::static_kind(): - tp = &(gTypes[710]); + tp = &(gTypes[714]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -411,7 +411,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[710]); + PyTypeObject * const tp = &(gTypes[714]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -426,12 +426,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FunctionProtoType.cpp b/bindings/Python/Generated/AST/FunctionProtoType.cpp index 2f3c6f78d..3dfeb8d8e 100644 --- a/bindings/Python/Generated/AST/FunctionProtoType.cpp +++ b/bindings/Python/Generated/AST/FunctionProtoType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[437]) || tp >= &(gTypes[438])) { + if (tp < &(gTypes[441]) || tp >= &(gTypes[442])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionProtoType::static_kind(): - tp = &(gTypes[437]); + tp = &(gTypes[441]); break; } @@ -493,7 +493,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -589,7 +589,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[437]); + PyTypeObject * const tp = &(gTypes[441]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -604,12 +604,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[436].tp_hash; - tp->tp_richcompare = gTypes[436].tp_richcompare; + tp->tp_hash = gTypes[440].tp_hash; + tp->tp_richcompare = gTypes[440].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[436]); + tp->tp_base = &(gTypes[440]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp b/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp index ac3f5acaa..2557df9fc 100644 --- a/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp +++ b/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[92]) || tp >= &(gTypes[93])) { + if (tp < &(gTypes[96]) || tp >= &(gTypes[97])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionReturnThunksAttr::static_kind(): - tp = &(gTypes[92]); + tp = &(gTypes[96]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[92]); + PyTypeObject * const tp = &(gTypes[96]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp b/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp index e5937c2bb..35af3ef8d 100644 --- a/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp +++ b/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[794]) || tp >= &(gTypes[795])) { + if (tp < &(gTypes[798]) || tp >= &(gTypes[799])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionTemplateDecl::static_kind(): - tp = &(gTypes[794]); + tp = &(gTypes[798]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[794]); + PyTypeObject * const tp = &(gTypes[798]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[793].tp_hash; - tp->tp_richcompare = gTypes[793].tp_richcompare; + tp->tp_hash = gTypes[797].tp_hash; + tp->tp_richcompare = gTypes[797].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[793]); + tp->tp_base = &(gTypes[797]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/FunctionType.cpp b/bindings/Python/Generated/AST/FunctionType.cpp index 032479ca0..b1e3352ac 100644 --- a/bindings/Python/Generated/AST/FunctionType.cpp +++ b/bindings/Python/Generated/AST/FunctionType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[436]) || tp >= &(gTypes[439])) { + if (tp < &(gTypes[440]) || tp >= &(gTypes[443])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionProtoType::static_kind(): - tp = &(gTypes[437]); + tp = &(gTypes[441]); break; case mx::FunctionNoProtoType::static_kind(): - tp = &(gTypes[438]); + tp = &(gTypes[442]); break; } @@ -350,7 +350,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -402,7 +402,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[436]); + PyTypeObject * const tp = &(gTypes[440]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -417,12 +417,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/GCCAsmStmt.cpp b/bindings/Python/Generated/AST/GCCAsmStmt.cpp index c0bdf55ca..5a4f5cd6b 100644 --- a/bindings/Python/Generated/AST/GCCAsmStmt.cpp +++ b/bindings/Python/Generated/AST/GCCAsmStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[582]) || tp >= &(gTypes[583])) { + if (tp < &(gTypes[586]) || tp >= &(gTypes[587])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::GCCAsmStmt::static_kind(): - tp = &(gTypes[582]); + tp = &(gTypes[586]); break; } @@ -479,7 +479,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -619,7 +619,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[582]); + PyTypeObject * const tp = &(gTypes[586]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -634,12 +634,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[580].tp_hash; - tp->tp_richcompare = gTypes[580].tp_richcompare; + tp->tp_hash = gTypes[584].tp_hash; + tp->tp_richcompare = gTypes[584].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[580]); + tp->tp_base = &(gTypes[584]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/GNUInlineAttr.cpp b/bindings/Python/Generated/AST/GNUInlineAttr.cpp index c5ba8428d..5eb1db257 100644 --- a/bindings/Python/Generated/AST/GNUInlineAttr.cpp +++ b/bindings/Python/Generated/AST/GNUInlineAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[91]) || tp >= &(gTypes[92])) { + if (tp < &(gTypes[95]) || tp >= &(gTypes[96])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::GNUInlineAttr::static_kind(): - tp = &(gTypes[91]); + tp = &(gTypes[95]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[91]); + PyTypeObject * const tp = &(gTypes[95]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/GNUNullExpr.cpp b/bindings/Python/Generated/AST/GNUNullExpr.cpp index b8e348799..7c4a778e2 100644 --- a/bindings/Python/Generated/AST/GNUNullExpr.cpp +++ b/bindings/Python/Generated/AST/GNUNullExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[709]) || tp >= &(gTypes[710])) { + if (tp < &(gTypes[713]) || tp >= &(gTypes[714])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::GNUNullExpr::static_kind(): - tp = &(gTypes[709]); + tp = &(gTypes[713]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[709]); + PyTypeObject * const tp = &(gTypes[713]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/GenericSelectionExpr.cpp b/bindings/Python/Generated/AST/GenericSelectionExpr.cpp index 9cdd5b189..190e670d2 100644 --- a/bindings/Python/Generated/AST/GenericSelectionExpr.cpp +++ b/bindings/Python/Generated/AST/GenericSelectionExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[708]) || tp >= &(gTypes[709])) { + if (tp < &(gTypes[712]) || tp >= &(gTypes[713])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::GenericSelectionExpr::static_kind(): - tp = &(gTypes[708]); + tp = &(gTypes[712]); break; } @@ -439,7 +439,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -491,7 +491,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[708]); + PyTypeObject * const tp = &(gTypes[712]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -506,12 +506,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/GotoStmt.cpp b/bindings/Python/Generated/AST/GotoStmt.cpp index 37f0af8d6..30c252fde 100644 --- a/bindings/Python/Generated/AST/GotoStmt.cpp +++ b/bindings/Python/Generated/AST/GotoStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[567]) || tp >= &(gTypes[568])) { + if (tp < &(gTypes[571]) || tp >= &(gTypes[572])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::GotoStmt::static_kind(): - tp = &(gTypes[567]); + tp = &(gTypes[571]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[567]); + PyTypeObject * const tp = &(gTypes[571]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/GuardedByAttr.cpp b/bindings/Python/Generated/AST/GuardedByAttr.cpp index 01ef30d33..bc857c4f8 100644 --- a/bindings/Python/Generated/AST/GuardedByAttr.cpp +++ b/bindings/Python/Generated/AST/GuardedByAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[90]) || tp >= &(gTypes[91])) { + if (tp < &(gTypes[94]) || tp >= &(gTypes[95])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::GuardedByAttr::static_kind(): - tp = &(gTypes[90]); + tp = &(gTypes[94]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[90]); + PyTypeObject * const tp = &(gTypes[94]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/GuardedVarAttr.cpp b/bindings/Python/Generated/AST/GuardedVarAttr.cpp index 4c052e0a9..81a7f0480 100644 --- a/bindings/Python/Generated/AST/GuardedVarAttr.cpp +++ b/bindings/Python/Generated/AST/GuardedVarAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[89]) || tp >= &(gTypes[90])) { + if (tp < &(gTypes[93]) || tp >= &(gTypes[94])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::GuardedVarAttr::static_kind(): - tp = &(gTypes[89]); + tp = &(gTypes[93]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[89]); + PyTypeObject * const tp = &(gTypes[93]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HIPManagedAttr.cpp b/bindings/Python/Generated/AST/HIPManagedAttr.cpp index 1ccc34eff..c3f6a732b 100644 --- a/bindings/Python/Generated/AST/HIPManagedAttr.cpp +++ b/bindings/Python/Generated/AST/HIPManagedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[88]) || tp >= &(gTypes[89])) { + if (tp < &(gTypes[92]) || tp >= &(gTypes[93])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HIPManagedAttr::static_kind(): - tp = &(gTypes[88]); + tp = &(gTypes[92]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[88]); + PyTypeObject * const tp = &(gTypes[92]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp b/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp index 8a4b9a880..b6cf93ebc 100644 --- a/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[85]) || tp >= &(gTypes[88])) { + if (tp < &(gTypes[89]) || tp >= &(gTypes[92])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLSV_GroupIndexAttr::static_kind(): - tp = &(gTypes[86]); + tp = &(gTypes[90]); break; case mx::HLSLSV_DispatchThreadIDAttr::static_kind(): - tp = &(gTypes[87]); + tp = &(gTypes[91]); break; } @@ -266,7 +266,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -318,7 +318,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[85]); + PyTypeObject * const tp = &(gTypes[89]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -333,12 +333,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLBufferDecl.cpp b/bindings/Python/Generated/AST/HLSLBufferDecl.cpp index cc14b686f..c7ad78332 100644 --- a/bindings/Python/Generated/AST/HLSLBufferDecl.cpp +++ b/bindings/Python/Generated/AST/HLSLBufferDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[740]) || tp >= &(gTypes[741])) { + if (tp < &(gTypes[744]) || tp >= &(gTypes[745])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLBufferDecl::static_kind(): - tp = &(gTypes[740]); + tp = &(gTypes[744]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[740]); + PyTypeObject * const tp = &(gTypes[744]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp index bbf9df8a6..7d6cc5706 100644 --- a/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[26]) || tp >= &(gTypes[27])) { + if (tp < &(gTypes[30]) || tp >= &(gTypes[31])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLGroupSharedAddressSpaceAttr::static_kind(): - tp = &(gTypes[26]); + tp = &(gTypes[30]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[26]); + PyTypeObject * const tp = &(gTypes[30]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp b/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp index e7e00ee60..3a9e73f32 100644 --- a/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[84]) || tp >= &(gTypes[85])) { + if (tp < &(gTypes[88]) || tp >= &(gTypes[89])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLNumThreadsAttr::static_kind(): - tp = &(gTypes[84]); + tp = &(gTypes[88]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[84]); + PyTypeObject * const tp = &(gTypes[88]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp b/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp index a54f43967..fee0b5e73 100644 --- a/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[25]) || tp >= &(gTypes[26])) { + if (tp < &(gTypes[29]) || tp >= &(gTypes[30])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLParamModifierAttr::static_kind(): - tp = &(gTypes[25]); + tp = &(gTypes[29]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -401,7 +401,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[25]); + PyTypeObject * const tp = &(gTypes[29]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -416,12 +416,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLResourceAttr.cpp b/bindings/Python/Generated/AST/HLSLResourceAttr.cpp index c1a81256a..c84acf3c5 100644 --- a/bindings/Python/Generated/AST/HLSLResourceAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLResourceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[83]) || tp >= &(gTypes[84])) { + if (tp < &(gTypes[87]) || tp >= &(gTypes[88])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLResourceAttr::static_kind(): - tp = &(gTypes[83]); + tp = &(gTypes[87]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[83]); + PyTypeObject * const tp = &(gTypes[87]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp b/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp index 8d36ea176..cc8e84713 100644 --- a/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[82]) || tp >= &(gTypes[83])) { + if (tp < &(gTypes[86]) || tp >= &(gTypes[87])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLResourceBindingAttr::static_kind(): - tp = &(gTypes[82]); + tp = &(gTypes[86]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[82]); + PyTypeObject * const tp = &(gTypes[86]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp b/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp index c3f37c031..ddb55b0cd 100644 --- a/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[87]) || tp >= &(gTypes[88])) { + if (tp < &(gTypes[91]) || tp >= &(gTypes[92])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLSV_DispatchThreadIDAttr::static_kind(): - tp = &(gTypes[87]); + tp = &(gTypes[91]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[87]); + PyTypeObject * const tp = &(gTypes[91]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[85].tp_hash; - tp->tp_richcompare = gTypes[85].tp_richcompare; + tp->tp_hash = gTypes[89].tp_hash; + tp->tp_richcompare = gTypes[89].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[85]); + tp->tp_base = &(gTypes[89]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp b/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp index 53f4511f4..0fed1fa7e 100644 --- a/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[86]) || tp >= &(gTypes[87])) { + if (tp < &(gTypes[90]) || tp >= &(gTypes[91])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLSV_GroupIndexAttr::static_kind(): - tp = &(gTypes[86]); + tp = &(gTypes[90]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[86]); + PyTypeObject * const tp = &(gTypes[90]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[85].tp_hash; - tp->tp_richcompare = gTypes[85].tp_richcompare; + tp->tp_hash = gTypes[89].tp_hash; + tp->tp_richcompare = gTypes[89].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[85]); + tp->tp_base = &(gTypes[89]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HLSLShaderAttr.cpp b/bindings/Python/Generated/AST/HLSLShaderAttr.cpp index 3cafcad79..c39ff0621 100644 --- a/bindings/Python/Generated/AST/HLSLShaderAttr.cpp +++ b/bindings/Python/Generated/AST/HLSLShaderAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[81]) || tp >= &(gTypes[82])) { + if (tp < &(gTypes[85]) || tp >= &(gTypes[86])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HLSLShaderAttr::static_kind(): - tp = &(gTypes[81]); + tp = &(gTypes[85]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[81]); + PyTypeObject * const tp = &(gTypes[85]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/HotAttr.cpp b/bindings/Python/Generated/AST/HotAttr.cpp index 4150ec382..f2f601048 100644 --- a/bindings/Python/Generated/AST/HotAttr.cpp +++ b/bindings/Python/Generated/AST/HotAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[80]) || tp >= &(gTypes[81])) { + if (tp < &(gTypes[84]) || tp >= &(gTypes[85])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::HotAttr::static_kind(): - tp = &(gTypes[80]); + tp = &(gTypes[84]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[80]); + PyTypeObject * const tp = &(gTypes[84]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IBActionAttr.cpp b/bindings/Python/Generated/AST/IBActionAttr.cpp index d858e9343..5e18a3d1e 100644 --- a/bindings/Python/Generated/AST/IBActionAttr.cpp +++ b/bindings/Python/Generated/AST/IBActionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[79]) || tp >= &(gTypes[80])) { + if (tp < &(gTypes[83]) || tp >= &(gTypes[84])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IBActionAttr::static_kind(): - tp = &(gTypes[79]); + tp = &(gTypes[83]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[79]); + PyTypeObject * const tp = &(gTypes[83]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IBOutletAttr.cpp b/bindings/Python/Generated/AST/IBOutletAttr.cpp index e1114a784..23909716f 100644 --- a/bindings/Python/Generated/AST/IBOutletAttr.cpp +++ b/bindings/Python/Generated/AST/IBOutletAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[78]) || tp >= &(gTypes[79])) { + if (tp < &(gTypes[82]) || tp >= &(gTypes[83])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IBOutletAttr::static_kind(): - tp = &(gTypes[78]); + tp = &(gTypes[82]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[78]); + PyTypeObject * const tp = &(gTypes[82]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp b/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp index 3d9f2ebd8..8a2d4258a 100644 --- a/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp +++ b/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[77]) || tp >= &(gTypes[78])) { + if (tp < &(gTypes[81]) || tp >= &(gTypes[82])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IBOutletCollectionAttr::static_kind(): - tp = &(gTypes[77]); + tp = &(gTypes[81]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[77]); + PyTypeObject * const tp = &(gTypes[81]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IFuncAttr.cpp b/bindings/Python/Generated/AST/IFuncAttr.cpp index dfa251388..4338cea76 100644 --- a/bindings/Python/Generated/AST/IFuncAttr.cpp +++ b/bindings/Python/Generated/AST/IFuncAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[407]) || tp >= &(gTypes[408])) { + if (tp < &(gTypes[411]) || tp >= &(gTypes[412])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IFuncAttr::static_kind(): - tp = &(gTypes[407]); + tp = &(gTypes[411]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[407]); + PyTypeObject * const tp = &(gTypes[411]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IfStmt.cpp b/bindings/Python/Generated/AST/IfStmt.cpp index c53dc09e1..0730f38fb 100644 --- a/bindings/Python/Generated/AST/IfStmt.cpp +++ b/bindings/Python/Generated/AST/IfStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[566]) || tp >= &(gTypes[567])) { + if (tp < &(gTypes[570]) || tp >= &(gTypes[571])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IfStmt::static_kind(): - tp = &(gTypes[566]); + tp = &(gTypes[570]); break; } @@ -519,7 +519,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -549,7 +549,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[566]); + PyTypeObject * const tp = &(gTypes[570]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -564,12 +564,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ImaginaryLiteral.cpp b/bindings/Python/Generated/AST/ImaginaryLiteral.cpp index 07318eca5..0646eb4e9 100644 --- a/bindings/Python/Generated/AST/ImaginaryLiteral.cpp +++ b/bindings/Python/Generated/AST/ImaginaryLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[707]) || tp >= &(gTypes[708])) { + if (tp < &(gTypes[711]) || tp >= &(gTypes[712])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImaginaryLiteral::static_kind(): - tp = &(gTypes[707]); + tp = &(gTypes[711]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[707]); + PyTypeObject * const tp = &(gTypes[711]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ImplicitCastExpr.cpp b/bindings/Python/Generated/AST/ImplicitCastExpr.cpp index 61d362978..e74ef7bbe 100644 --- a/bindings/Python/Generated/AST/ImplicitCastExpr.cpp +++ b/bindings/Python/Generated/AST/ImplicitCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[601]) || tp >= &(gTypes[602])) { + if (tp < &(gTypes[605]) || tp >= &(gTypes[606])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImplicitCastExpr::static_kind(): - tp = &(gTypes[601]); + tp = &(gTypes[605]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[601]); + PyTypeObject * const tp = &(gTypes[605]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[600].tp_hash; - tp->tp_richcompare = gTypes[600].tp_richcompare; + tp->tp_hash = gTypes[604].tp_hash; + tp->tp_richcompare = gTypes[604].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[600]); + tp->tp_base = &(gTypes[604]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp b/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp index da63ff7d4..c65cabbee 100644 --- a/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp +++ b/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[816]) || tp >= &(gTypes[817])) { + if (tp < &(gTypes[820]) || tp >= &(gTypes[821])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImplicitConceptSpecializationDecl::static_kind(): - tp = &(gTypes[816]); + tp = &(gTypes[820]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[816]); + PyTypeObject * const tp = &(gTypes[820]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ImplicitParamDecl.cpp b/bindings/Python/Generated/AST/ImplicitParamDecl.cpp index 1089f2c3b..08497dc57 100644 --- a/bindings/Python/Generated/AST/ImplicitParamDecl.cpp +++ b/bindings/Python/Generated/AST/ImplicitParamDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[756]) || tp >= &(gTypes[757])) { + if (tp < &(gTypes[760]) || tp >= &(gTypes[761])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImplicitParamDecl::static_kind(): - tp = &(gTypes[756]); + tp = &(gTypes[760]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[756]); + PyTypeObject * const tp = &(gTypes[760]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[753].tp_hash; - tp->tp_richcompare = gTypes[753].tp_richcompare; + tp->tp_hash = gTypes[757].tp_hash; + tp->tp_richcompare = gTypes[757].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[753]); + tp->tp_base = &(gTypes[757]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp b/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp index 576ec164b..00ef4b5e2 100644 --- a/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp +++ b/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[706]) || tp >= &(gTypes[707])) { + if (tp < &(gTypes[710]) || tp >= &(gTypes[711])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImplicitValueInitExpr::static_kind(): - tp = &(gTypes[706]); + tp = &(gTypes[710]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[706]); + PyTypeObject * const tp = &(gTypes[710]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ImportDecl.cpp b/bindings/Python/Generated/AST/ImportDecl.cpp index c307ae87a..f9fe85611 100644 --- a/bindings/Python/Generated/AST/ImportDecl.cpp +++ b/bindings/Python/Generated/AST/ImportDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[815]) || tp >= &(gTypes[816])) { + if (tp < &(gTypes[819]) || tp >= &(gTypes[820])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImportDecl::static_kind(): - tp = &(gTypes[815]); + tp = &(gTypes[819]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[815]); + PyTypeObject * const tp = &(gTypes[819]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IncompleteArrayType.cpp b/bindings/Python/Generated/AST/IncompleteArrayType.cpp index 4a77d9134..9d6149ee0 100644 --- a/bindings/Python/Generated/AST/IncompleteArrayType.cpp +++ b/bindings/Python/Generated/AST/IncompleteArrayType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[456]) || tp >= &(gTypes[457])) { + if (tp < &(gTypes[460]) || tp >= &(gTypes[461])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IncompleteArrayType::static_kind(): - tp = &(gTypes[456]); + tp = &(gTypes[460]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[456]); + PyTypeObject * const tp = &(gTypes[460]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[454].tp_hash; - tp->tp_richcompare = gTypes[454].tp_richcompare; + tp->tp_hash = gTypes[458].tp_hash; + tp->tp_richcompare = gTypes[458].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[454]); + tp->tp_base = &(gTypes[458]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IndirectFieldDecl.cpp b/bindings/Python/Generated/AST/IndirectFieldDecl.cpp index cc4ae3433..9234974e3 100644 --- a/bindings/Python/Generated/AST/IndirectFieldDecl.cpp +++ b/bindings/Python/Generated/AST/IndirectFieldDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[750]) || tp >= &(gTypes[751])) { + if (tp < &(gTypes[754]) || tp >= &(gTypes[755])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IndirectFieldDecl::static_kind(): - tp = &(gTypes[750]); + tp = &(gTypes[754]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[750]); + PyTypeObject * const tp = &(gTypes[754]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IndirectGotoStmt.cpp b/bindings/Python/Generated/AST/IndirectGotoStmt.cpp index 4c4281ede..4f7d46da8 100644 --- a/bindings/Python/Generated/AST/IndirectGotoStmt.cpp +++ b/bindings/Python/Generated/AST/IndirectGotoStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[565]) || tp >= &(gTypes[566])) { + if (tp < &(gTypes[569]) || tp >= &(gTypes[570])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IndirectGotoStmt::static_kind(): - tp = &(gTypes[565]); + tp = &(gTypes[569]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[565]); + PyTypeObject * const tp = &(gTypes[569]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/InheritableAttr.cpp b/bindings/Python/Generated/AST/InheritableAttr.cpp index cf8edbc3d..da78dcb5e 100644 --- a/bindings/Python/Generated/AST/InheritableAttr.cpp +++ b/bindings/Python/Generated/AST/InheritableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[76]) || tp >= &(gTypes[407])) { + if (tp < &(gTypes[80]) || tp >= &(gTypes[411])) { return std::nullopt; } @@ -88,1307 +88,1307 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IBOutletCollectionAttr::static_kind(): - tp = &(gTypes[77]); + tp = &(gTypes[81]); break; case mx::IBOutletAttr::static_kind(): - tp = &(gTypes[78]); + tp = &(gTypes[82]); break; case mx::IBActionAttr::static_kind(): - tp = &(gTypes[79]); + tp = &(gTypes[83]); break; case mx::HotAttr::static_kind(): - tp = &(gTypes[80]); + tp = &(gTypes[84]); break; case mx::HLSLShaderAttr::static_kind(): - tp = &(gTypes[81]); + tp = &(gTypes[85]); break; case mx::HLSLResourceBindingAttr::static_kind(): - tp = &(gTypes[82]); + tp = &(gTypes[86]); break; case mx::HLSLResourceAttr::static_kind(): - tp = &(gTypes[83]); + tp = &(gTypes[87]); break; case mx::HLSLNumThreadsAttr::static_kind(): - tp = &(gTypes[84]); + tp = &(gTypes[88]); break; case mx::HLSLSV_GroupIndexAttr::static_kind(): - tp = &(gTypes[86]); + tp = &(gTypes[90]); break; case mx::HLSLSV_DispatchThreadIDAttr::static_kind(): - tp = &(gTypes[87]); + tp = &(gTypes[91]); break; case mx::HIPManagedAttr::static_kind(): - tp = &(gTypes[88]); + tp = &(gTypes[92]); break; case mx::GuardedVarAttr::static_kind(): - tp = &(gTypes[89]); + tp = &(gTypes[93]); break; case mx::GuardedByAttr::static_kind(): - tp = &(gTypes[90]); + tp = &(gTypes[94]); break; case mx::GNUInlineAttr::static_kind(): - tp = &(gTypes[91]); + tp = &(gTypes[95]); break; case mx::FunctionReturnThunksAttr::static_kind(): - tp = &(gTypes[92]); + tp = &(gTypes[96]); break; case mx::FormatAttr::static_kind(): - tp = &(gTypes[93]); + tp = &(gTypes[97]); break; case mx::FormatArgAttr::static_kind(): - tp = &(gTypes[94]); + tp = &(gTypes[98]); break; case mx::FlattenAttr::static_kind(): - tp = &(gTypes[95]); + tp = &(gTypes[99]); break; case mx::FlagEnumAttr::static_kind(): - tp = &(gTypes[96]); + tp = &(gTypes[100]); break; case mx::FinalAttr::static_kind(): - tp = &(gTypes[97]); + tp = &(gTypes[101]); break; case mx::FastCallAttr::static_kind(): - tp = &(gTypes[98]); + tp = &(gTypes[102]); break; case mx::ExternalSourceSymbolAttr::static_kind(): - tp = &(gTypes[99]); + tp = &(gTypes[103]); break; case mx::ExclusiveTrylockFunctionAttr::static_kind(): - tp = &(gTypes[100]); + tp = &(gTypes[104]); break; case mx::ExcludeFromExplicitInstantiationAttr::static_kind(): - tp = &(gTypes[101]); + tp = &(gTypes[105]); break; case mx::ErrorAttr::static_kind(): - tp = &(gTypes[102]); + tp = &(gTypes[106]); break; case mx::EnumExtensibilityAttr::static_kind(): - tp = &(gTypes[103]); + tp = &(gTypes[107]); break; case mx::EnforceTCBLeafAttr::static_kind(): - tp = &(gTypes[104]); + tp = &(gTypes[108]); break; case mx::EnforceTCBAttr::static_kind(): - tp = &(gTypes[105]); + tp = &(gTypes[109]); break; case mx::EnableIfAttr::static_kind(): - tp = &(gTypes[106]); + tp = &(gTypes[110]); break; case mx::EmptyBasesAttr::static_kind(): - tp = &(gTypes[107]); + tp = &(gTypes[111]); break; case mx::DisableTailCallsAttr::static_kind(): - tp = &(gTypes[108]); + tp = &(gTypes[112]); break; case mx::DisableSanitizerInstrumentationAttr::static_kind(): - tp = &(gTypes[109]); + tp = &(gTypes[113]); break; case mx::DiagnoseIfAttr::static_kind(): - tp = &(gTypes[110]); + tp = &(gTypes[114]); break; case mx::DiagnoseAsBuiltinAttr::static_kind(): - tp = &(gTypes[111]); + tp = &(gTypes[115]); break; case mx::DestructorAttr::static_kind(): - tp = &(gTypes[112]); + tp = &(gTypes[116]); break; case mx::DeprecatedAttr::static_kind(): - tp = &(gTypes[113]); + tp = &(gTypes[117]); break; case mx::AlwaysInlineAttr::static_kind(): - tp = &(gTypes[115]); + tp = &(gTypes[119]); break; case mx::SuppressAttr::static_kind(): - tp = &(gTypes[116]); + tp = &(gTypes[120]); break; case mx::NoMergeAttr::static_kind(): - tp = &(gTypes[117]); + tp = &(gTypes[121]); break; case mx::NoInlineAttr::static_kind(): - tp = &(gTypes[118]); + tp = &(gTypes[122]); break; case mx::DLLImportStaticLocalAttr::static_kind(): - tp = &(gTypes[119]); + tp = &(gTypes[123]); break; case mx::DLLImportAttr::static_kind(): - tp = &(gTypes[120]); + tp = &(gTypes[124]); break; case mx::DLLExportStaticLocalAttr::static_kind(): - tp = &(gTypes[121]); + tp = &(gTypes[125]); break; case mx::DLLExportAttr::static_kind(): - tp = &(gTypes[122]); + tp = &(gTypes[126]); break; case mx::CountedByAttr::static_kind(): - tp = &(gTypes[123]); + tp = &(gTypes[127]); break; case mx::CoroWrapperAttr::static_kind(): - tp = &(gTypes[124]); + tp = &(gTypes[128]); break; case mx::CoroReturnTypeAttr::static_kind(): - tp = &(gTypes[125]); + tp = &(gTypes[129]); break; case mx::CoroOnlyDestroyWhenCompleteAttr::static_kind(): - tp = &(gTypes[126]); + tp = &(gTypes[130]); break; case mx::CoroLifetimeBoundAttr::static_kind(): - tp = &(gTypes[127]); + tp = &(gTypes[131]); break; case mx::CoroDisableLifetimeBoundAttr::static_kind(): - tp = &(gTypes[128]); + tp = &(gTypes[132]); break; case mx::ConvergentAttr::static_kind(): - tp = &(gTypes[129]); + tp = &(gTypes[133]); break; case mx::ConsumableSetOnReadAttr::static_kind(): - tp = &(gTypes[130]); + tp = &(gTypes[134]); break; case mx::ConsumableAutoCastAttr::static_kind(): - tp = &(gTypes[131]); + tp = &(gTypes[135]); break; case mx::ConsumableAttr::static_kind(): - tp = &(gTypes[132]); + tp = &(gTypes[136]); break; case mx::ConstructorAttr::static_kind(): - tp = &(gTypes[133]); + tp = &(gTypes[137]); break; case mx::ConstInitAttr::static_kind(): - tp = &(gTypes[134]); + tp = &(gTypes[138]); break; case mx::ConstAttr::static_kind(): - tp = &(gTypes[135]); + tp = &(gTypes[139]); break; case mx::CommonAttr::static_kind(): - tp = &(gTypes[136]); + tp = &(gTypes[140]); break; case mx::ColdAttr::static_kind(): - tp = &(gTypes[137]); + tp = &(gTypes[141]); break; case mx::CodeSegAttr::static_kind(): - tp = &(gTypes[138]); + tp = &(gTypes[142]); break; case mx::CodeModelAttr::static_kind(): - tp = &(gTypes[139]); + tp = &(gTypes[143]); break; case mx::CmseNSEntryAttr::static_kind(): - tp = &(gTypes[140]); + tp = &(gTypes[144]); break; case mx::CleanupAttr::static_kind(): - tp = &(gTypes[141]); + tp = &(gTypes[145]); break; case mx::CapturedRecordAttr::static_kind(): - tp = &(gTypes[142]); + tp = &(gTypes[146]); break; case mx::CapabilityAttr::static_kind(): - tp = &(gTypes[143]); + tp = &(gTypes[147]); break; case mx::CallbackAttr::static_kind(): - tp = &(gTypes[144]); + tp = &(gTypes[148]); break; case mx::CallableWhenAttr::static_kind(): - tp = &(gTypes[145]); + tp = &(gTypes[149]); break; case mx::CXX11NoReturnAttr::static_kind(): - tp = &(gTypes[146]); + tp = &(gTypes[150]); break; case mx::CUDASharedAttr::static_kind(): - tp = &(gTypes[147]); + tp = &(gTypes[151]); break; case mx::CUDALaunchBoundsAttr::static_kind(): - tp = &(gTypes[148]); + tp = &(gTypes[152]); break; case mx::CUDAInvalidTargetAttr::static_kind(): - tp = &(gTypes[149]); + tp = &(gTypes[153]); break; case mx::CUDAHostAttr::static_kind(): - tp = &(gTypes[150]); + tp = &(gTypes[154]); break; case mx::CUDAGlobalAttr::static_kind(): - tp = &(gTypes[151]); + tp = &(gTypes[155]); break; case mx::CUDADeviceBuiltinTextureTypeAttr::static_kind(): - tp = &(gTypes[152]); + tp = &(gTypes[156]); break; case mx::CUDADeviceBuiltinSurfaceTypeAttr::static_kind(): - tp = &(gTypes[153]); + tp = &(gTypes[157]); break; case mx::CUDADeviceAttr::static_kind(): - tp = &(gTypes[154]); + tp = &(gTypes[158]); break; case mx::CUDAConstantAttr::static_kind(): - tp = &(gTypes[155]); + tp = &(gTypes[159]); break; case mx::CPUSpecificAttr::static_kind(): - tp = &(gTypes[156]); + tp = &(gTypes[160]); break; case mx::CPUDispatchAttr::static_kind(): - tp = &(gTypes[157]); + tp = &(gTypes[161]); break; case mx::CFUnknownTransferAttr::static_kind(): - tp = &(gTypes[158]); + tp = &(gTypes[162]); break; case mx::CFReturnsRetainedAttr::static_kind(): - tp = &(gTypes[159]); + tp = &(gTypes[163]); break; case mx::CFReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[160]); + tp = &(gTypes[164]); break; case mx::CFICanonicalJumpTableAttr::static_kind(): - tp = &(gTypes[161]); + tp = &(gTypes[165]); break; case mx::CFGuardAttr::static_kind(): - tp = &(gTypes[162]); + tp = &(gTypes[166]); break; case mx::CFAuditedTransferAttr::static_kind(): - tp = &(gTypes[163]); + tp = &(gTypes[167]); break; case mx::CDeclAttr::static_kind(): - tp = &(gTypes[164]); + tp = &(gTypes[168]); break; case mx::C11NoReturnAttr::static_kind(): - tp = &(gTypes[165]); + tp = &(gTypes[169]); break; case mx::BuiltinAttr::static_kind(): - tp = &(gTypes[166]); + tp = &(gTypes[170]); break; case mx::BlocksAttr::static_kind(): - tp = &(gTypes[167]); + tp = &(gTypes[171]); break; case mx::BTFDeclTagAttr::static_kind(): - tp = &(gTypes[168]); + tp = &(gTypes[172]); break; case mx::BPFPreserveStaticOffsetAttr::static_kind(): - tp = &(gTypes[169]); + tp = &(gTypes[173]); break; case mx::BPFPreserveAccessIndexAttr::static_kind(): - tp = &(gTypes[170]); + tp = &(gTypes[174]); break; case mx::AvailableOnlyInDefaultEvalMethodAttr::static_kind(): - tp = &(gTypes[171]); + tp = &(gTypes[175]); break; case mx::AvailabilityAttr::static_kind(): - tp = &(gTypes[172]); + tp = &(gTypes[176]); break; case mx::AssumptionAttr::static_kind(): - tp = &(gTypes[173]); + tp = &(gTypes[177]); break; case mx::AssumeAlignedAttr::static_kind(): - tp = &(gTypes[174]); + tp = &(gTypes[178]); break; case mx::AssertSharedLockAttr::static_kind(): - tp = &(gTypes[175]); + tp = &(gTypes[179]); break; case mx::AssertExclusiveLockAttr::static_kind(): - tp = &(gTypes[176]); + tp = &(gTypes[180]); break; case mx::AssertCapabilityAttr::static_kind(): - tp = &(gTypes[177]); + tp = &(gTypes[181]); break; case mx::AsmLabelAttr::static_kind(): - tp = &(gTypes[178]); + tp = &(gTypes[182]); break; case mx::ArtificialAttr::static_kind(): - tp = &(gTypes[179]); + tp = &(gTypes[183]); break; case mx::ArmNewAttr::static_kind(): - tp = &(gTypes[180]); + tp = &(gTypes[184]); break; case mx::ArmLocallyStreamingAttr::static_kind(): - tp = &(gTypes[181]); + tp = &(gTypes[185]); break; case mx::ArmBuiltinAliasAttr::static_kind(): - tp = &(gTypes[182]); + tp = &(gTypes[186]); break; case mx::ArgumentWithTypeTagAttr::static_kind(): - tp = &(gTypes[183]); + tp = &(gTypes[187]); break; case mx::ArcWeakrefUnavailableAttr::static_kind(): - tp = &(gTypes[184]); + tp = &(gTypes[188]); break; case mx::AnyX86NoCfCheckAttr::static_kind(): - tp = &(gTypes[185]); + tp = &(gTypes[189]); break; case mx::AnyX86NoCallerSavedRegistersAttr::static_kind(): - tp = &(gTypes[186]); + tp = &(gTypes[190]); break; case mx::AnyX86InterruptAttr::static_kind(): - tp = &(gTypes[187]); + tp = &(gTypes[191]); break; case mx::AnalyzerNoReturnAttr::static_kind(): - tp = &(gTypes[188]); + tp = &(gTypes[192]); break; case mx::AlwaysDestroyAttr::static_kind(): - tp = &(gTypes[189]); + tp = &(gTypes[193]); break; case mx::AllocSizeAttr::static_kind(): - tp = &(gTypes[190]); + tp = &(gTypes[194]); break; case mx::AllocAlignAttr::static_kind(): - tp = &(gTypes[191]); + tp = &(gTypes[195]); break; case mx::AlignedAttr::static_kind(): - tp = &(gTypes[192]); + tp = &(gTypes[196]); break; case mx::AlignNaturalAttr::static_kind(): - tp = &(gTypes[193]); + tp = &(gTypes[197]); break; case mx::AlignMac68kAttr::static_kind(): - tp = &(gTypes[194]); + tp = &(gTypes[198]); break; case mx::AcquiredBeforeAttr::static_kind(): - tp = &(gTypes[195]); + tp = &(gTypes[199]); break; case mx::AcquiredAfterAttr::static_kind(): - tp = &(gTypes[196]); + tp = &(gTypes[200]); break; case mx::AcquireHandleAttr::static_kind(): - tp = &(gTypes[197]); + tp = &(gTypes[201]); break; case mx::AcquireCapabilityAttr::static_kind(): - tp = &(gTypes[198]); + tp = &(gTypes[202]); break; case mx::AVRSignalAttr::static_kind(): - tp = &(gTypes[199]); + tp = &(gTypes[203]); break; case mx::AVRInterruptAttr::static_kind(): - tp = &(gTypes[200]); + tp = &(gTypes[204]); break; case mx::ARMInterruptAttr::static_kind(): - tp = &(gTypes[201]); + tp = &(gTypes[205]); break; case mx::AMDGPUWavesPerEUAttr::static_kind(): - tp = &(gTypes[202]); + tp = &(gTypes[206]); break; case mx::AMDGPUNumVGPRAttr::static_kind(): - tp = &(gTypes[203]); + tp = &(gTypes[207]); break; case mx::AMDGPUNumSGPRAttr::static_kind(): - tp = &(gTypes[204]); + tp = &(gTypes[208]); break; case mx::AMDGPUKernelCallAttr::static_kind(): - tp = &(gTypes[205]); + tp = &(gTypes[209]); break; case mx::AMDGPUFlatWorkGroupSizeAttr::static_kind(): - tp = &(gTypes[206]); + tp = &(gTypes[210]); break; case mx::AArch64VectorPcsAttr::static_kind(): - tp = &(gTypes[207]); + tp = &(gTypes[211]); break; case mx::AArch64SVEPcsAttr::static_kind(): - tp = &(gTypes[208]); + tp = &(gTypes[212]); break; case mx::ZeroCallUsedRegsAttr::static_kind(): - tp = &(gTypes[209]); + tp = &(gTypes[213]); break; case mx::XRayLogArgsAttr::static_kind(): - tp = &(gTypes[210]); + tp = &(gTypes[214]); break; case mx::XRayInstrumentAttr::static_kind(): - tp = &(gTypes[211]); + tp = &(gTypes[215]); break; case mx::X86ForceAlignArgPointerAttr::static_kind(): - tp = &(gTypes[212]); + tp = &(gTypes[216]); break; case mx::WorkGroupSizeHintAttr::static_kind(): - tp = &(gTypes[213]); + tp = &(gTypes[217]); break; case mx::WebAssemblyImportNameAttr::static_kind(): - tp = &(gTypes[214]); + tp = &(gTypes[218]); break; case mx::WebAssemblyImportModuleAttr::static_kind(): - tp = &(gTypes[215]); + tp = &(gTypes[219]); break; case mx::WebAssemblyExportNameAttr::static_kind(): - tp = &(gTypes[216]); + tp = &(gTypes[220]); break; case mx::WeakRefAttr::static_kind(): - tp = &(gTypes[217]); + tp = &(gTypes[221]); break; case mx::WeakImportAttr::static_kind(): - tp = &(gTypes[218]); + tp = &(gTypes[222]); break; case mx::WeakAttr::static_kind(): - tp = &(gTypes[219]); + tp = &(gTypes[223]); break; case mx::WarnUnusedResultAttr::static_kind(): - tp = &(gTypes[220]); + tp = &(gTypes[224]); break; case mx::WarnUnusedAttr::static_kind(): - tp = &(gTypes[221]); + tp = &(gTypes[225]); break; case mx::VisibilityAttr::static_kind(): - tp = &(gTypes[222]); + tp = &(gTypes[226]); break; case mx::VectorCallAttr::static_kind(): - tp = &(gTypes[223]); + tp = &(gTypes[227]); break; case mx::VecTypeHintAttr::static_kind(): - tp = &(gTypes[224]); + tp = &(gTypes[228]); break; case mx::VecReturnAttr::static_kind(): - tp = &(gTypes[225]); + tp = &(gTypes[229]); break; case mx::UuidAttr::static_kind(): - tp = &(gTypes[226]); + tp = &(gTypes[230]); break; case mx::UsingIfExistsAttr::static_kind(): - tp = &(gTypes[227]); + tp = &(gTypes[231]); break; case mx::UsedAttr::static_kind(): - tp = &(gTypes[228]); + tp = &(gTypes[232]); break; case mx::UnusedAttr::static_kind(): - tp = &(gTypes[229]); + tp = &(gTypes[233]); break; case mx::UnsafeBufferUsageAttr::static_kind(): - tp = &(gTypes[230]); + tp = &(gTypes[234]); break; case mx::UninitializedAttr::static_kind(): - tp = &(gTypes[231]); + tp = &(gTypes[235]); break; case mx::UnavailableAttr::static_kind(): - tp = &(gTypes[232]); + tp = &(gTypes[236]); break; case mx::TypeVisibilityAttr::static_kind(): - tp = &(gTypes[233]); + tp = &(gTypes[237]); break; case mx::TypeTagForDatatypeAttr::static_kind(): - tp = &(gTypes[234]); + tp = &(gTypes[238]); break; case mx::TryAcquireCapabilityAttr::static_kind(): - tp = &(gTypes[235]); + tp = &(gTypes[239]); break; case mx::TrivialABIAttr::static_kind(): - tp = &(gTypes[236]); + tp = &(gTypes[240]); break; case mx::TransparentUnionAttr::static_kind(): - tp = &(gTypes[237]); + tp = &(gTypes[241]); break; case mx::ThisCallAttr::static_kind(): - tp = &(gTypes[238]); + tp = &(gTypes[242]); break; case mx::TestTypestateAttr::static_kind(): - tp = &(gTypes[239]); + tp = &(gTypes[243]); break; case mx::TargetVersionAttr::static_kind(): - tp = &(gTypes[240]); + tp = &(gTypes[244]); break; case mx::TargetClonesAttr::static_kind(): - tp = &(gTypes[241]); + tp = &(gTypes[245]); break; case mx::TargetAttr::static_kind(): - tp = &(gTypes[242]); + tp = &(gTypes[246]); break; case mx::TLSModelAttr::static_kind(): - tp = &(gTypes[243]); + tp = &(gTypes[247]); break; case mx::SysVABIAttr::static_kind(): - tp = &(gTypes[244]); + tp = &(gTypes[248]); break; case mx::SwiftPrivateAttr::static_kind(): - tp = &(gTypes[245]); + tp = &(gTypes[249]); break; case mx::SwiftNewTypeAttr::static_kind(): - tp = &(gTypes[246]); + tp = &(gTypes[250]); break; case mx::SwiftNameAttr::static_kind(): - tp = &(gTypes[247]); + tp = &(gTypes[251]); break; case mx::SwiftImportPropertyAsAccessorsAttr::static_kind(): - tp = &(gTypes[248]); + tp = &(gTypes[252]); break; case mx::SwiftImportAsNonGenericAttr::static_kind(): - tp = &(gTypes[249]); + tp = &(gTypes[253]); break; case mx::SwiftErrorAttr::static_kind(): - tp = &(gTypes[250]); + tp = &(gTypes[254]); break; case mx::SwiftCallAttr::static_kind(): - tp = &(gTypes[251]); + tp = &(gTypes[255]); break; case mx::SwiftBridgedTypedefAttr::static_kind(): - tp = &(gTypes[252]); + tp = &(gTypes[256]); break; case mx::SwiftBridgeAttr::static_kind(): - tp = &(gTypes[253]); + tp = &(gTypes[257]); break; case mx::SwiftAttrAttr::static_kind(): - tp = &(gTypes[254]); + tp = &(gTypes[258]); break; case mx::SwiftAsyncNameAttr::static_kind(): - tp = &(gTypes[255]); + tp = &(gTypes[259]); break; case mx::SwiftAsyncErrorAttr::static_kind(): - tp = &(gTypes[256]); + tp = &(gTypes[260]); break; case mx::SwiftAsyncCallAttr::static_kind(): - tp = &(gTypes[257]); + tp = &(gTypes[261]); break; case mx::SwiftAsyncAttr::static_kind(): - tp = &(gTypes[258]); + tp = &(gTypes[262]); break; case mx::StrictGuardStackCheckAttr::static_kind(): - tp = &(gTypes[259]); + tp = &(gTypes[263]); break; case mx::StrictFPAttr::static_kind(): - tp = &(gTypes[260]); + tp = &(gTypes[264]); break; case mx::StdCallAttr::static_kind(): - tp = &(gTypes[261]); + tp = &(gTypes[265]); break; case mx::StandaloneDebugAttr::static_kind(): - tp = &(gTypes[262]); + tp = &(gTypes[266]); break; case mx::SpeculativeLoadHardeningAttr::static_kind(): - tp = &(gTypes[263]); + tp = &(gTypes[267]); break; case mx::SharedTrylockFunctionAttr::static_kind(): - tp = &(gTypes[264]); + tp = &(gTypes[268]); break; case mx::SetTypestateAttr::static_kind(): - tp = &(gTypes[265]); + tp = &(gTypes[269]); break; case mx::SentinelAttr::static_kind(): - tp = &(gTypes[266]); + tp = &(gTypes[270]); break; case mx::SelectAnyAttr::static_kind(): - tp = &(gTypes[267]); + tp = &(gTypes[271]); break; case mx::SectionAttr::static_kind(): - tp = &(gTypes[268]); + tp = &(gTypes[272]); break; case mx::ScopedLockableAttr::static_kind(): - tp = &(gTypes[269]); + tp = &(gTypes[273]); break; case mx::SYCLSpecialClassAttr::static_kind(): - tp = &(gTypes[270]); + tp = &(gTypes[274]); break; case mx::SYCLKernelAttr::static_kind(): - tp = &(gTypes[271]); + tp = &(gTypes[275]); break; case mx::ReturnsTwiceAttr::static_kind(): - tp = &(gTypes[272]); + tp = &(gTypes[276]); break; case mx::ReturnsNonNullAttr::static_kind(): - tp = &(gTypes[273]); + tp = &(gTypes[277]); break; case mx::ReturnTypestateAttr::static_kind(): - tp = &(gTypes[274]); + tp = &(gTypes[278]); break; case mx::RetainAttr::static_kind(): - tp = &(gTypes[275]); + tp = &(gTypes[279]); break; case mx::RestrictAttr::static_kind(): - tp = &(gTypes[276]); + tp = &(gTypes[280]); break; case mx::RequiresCapabilityAttr::static_kind(): - tp = &(gTypes[277]); + tp = &(gTypes[281]); break; case mx::ReqdWorkGroupSizeAttr::static_kind(): - tp = &(gTypes[278]); + tp = &(gTypes[282]); break; case mx::ReleaseCapabilityAttr::static_kind(): - tp = &(gTypes[279]); + tp = &(gTypes[283]); break; case mx::ReinitializesAttr::static_kind(): - tp = &(gTypes[280]); + tp = &(gTypes[284]); break; case mx::RegCallAttr::static_kind(): - tp = &(gTypes[281]); + tp = &(gTypes[285]); break; case mx::ReadOnlyPlacementAttr::static_kind(): - tp = &(gTypes[282]); + tp = &(gTypes[286]); break; case mx::RandomizeLayoutAttr::static_kind(): - tp = &(gTypes[283]); + tp = &(gTypes[287]); break; case mx::RISCVInterruptAttr::static_kind(): - tp = &(gTypes[284]); + tp = &(gTypes[288]); break; case mx::PureAttr::static_kind(): - tp = &(gTypes[285]); + tp = &(gTypes[289]); break; case mx::PtGuardedVarAttr::static_kind(): - tp = &(gTypes[286]); + tp = &(gTypes[290]); break; case mx::PtGuardedByAttr::static_kind(): - tp = &(gTypes[287]); + tp = &(gTypes[291]); break; case mx::PreserveMostAttr::static_kind(): - tp = &(gTypes[288]); + tp = &(gTypes[292]); break; case mx::PreserveAllAttr::static_kind(): - tp = &(gTypes[289]); + tp = &(gTypes[293]); break; case mx::PreferredTypeAttr::static_kind(): - tp = &(gTypes[290]); + tp = &(gTypes[294]); break; case mx::PreferredNameAttr::static_kind(): - tp = &(gTypes[291]); + tp = &(gTypes[295]); break; case mx::PragmaClangTextSectionAttr::static_kind(): - tp = &(gTypes[292]); + tp = &(gTypes[296]); break; case mx::PragmaClangRodataSectionAttr::static_kind(): - tp = &(gTypes[293]); + tp = &(gTypes[297]); break; case mx::PragmaClangRelroSectionAttr::static_kind(): - tp = &(gTypes[294]); + tp = &(gTypes[298]); break; case mx::PragmaClangDataSectionAttr::static_kind(): - tp = &(gTypes[295]); + tp = &(gTypes[299]); break; case mx::PragmaClangBSSSectionAttr::static_kind(): - tp = &(gTypes[296]); + tp = &(gTypes[300]); break; case mx::PointerAttr::static_kind(): - tp = &(gTypes[297]); + tp = &(gTypes[301]); break; case mx::PcsAttr::static_kind(): - tp = &(gTypes[298]); + tp = &(gTypes[302]); break; case mx::PatchableFunctionEntryAttr::static_kind(): - tp = &(gTypes[299]); + tp = &(gTypes[303]); break; case mx::PascalAttr::static_kind(): - tp = &(gTypes[300]); + tp = &(gTypes[304]); break; case mx::ParamTypestateAttr::static_kind(): - tp = &(gTypes[301]); + tp = &(gTypes[305]); break; case mx::PackedAttr::static_kind(): - tp = &(gTypes[302]); + tp = &(gTypes[306]); break; case mx::OwnershipAttr::static_kind(): - tp = &(gTypes[303]); + tp = &(gTypes[307]); break; case mx::OwnerAttr::static_kind(): - tp = &(gTypes[304]); + tp = &(gTypes[308]); break; case mx::OverrideAttr::static_kind(): - tp = &(gTypes[305]); + tp = &(gTypes[309]); break; case mx::OptimizeNoneAttr::static_kind(): - tp = &(gTypes[306]); + tp = &(gTypes[310]); break; case mx::OpenCLKernelAttr::static_kind(): - tp = &(gTypes[307]); + tp = &(gTypes[311]); break; case mx::OpenCLIntelReqdSubGroupSizeAttr::static_kind(): - tp = &(gTypes[308]); + tp = &(gTypes[312]); break; case mx::ObjCSubclassingRestrictedAttr::static_kind(): - tp = &(gTypes[309]); + tp = &(gTypes[313]); break; case mx::ObjCRootClassAttr::static_kind(): - tp = &(gTypes[310]); + tp = &(gTypes[314]); break; case mx::ObjCReturnsInnerPointerAttr::static_kind(): - tp = &(gTypes[311]); + tp = &(gTypes[315]); break; case mx::ObjCRequiresSuperAttr::static_kind(): - tp = &(gTypes[312]); + tp = &(gTypes[316]); break; case mx::ObjCRequiresPropertyDefsAttr::static_kind(): - tp = &(gTypes[313]); + tp = &(gTypes[317]); break; case mx::ObjCPreciseLifetimeAttr::static_kind(): - tp = &(gTypes[314]); + tp = &(gTypes[318]); break; case mx::ObjCOwnershipAttr::static_kind(): - tp = &(gTypes[315]); + tp = &(gTypes[319]); break; case mx::ObjCNSObjectAttr::static_kind(): - tp = &(gTypes[316]); + tp = &(gTypes[320]); break; case mx::ObjCMethodFamilyAttr::static_kind(): - tp = &(gTypes[317]); + tp = &(gTypes[321]); break; case mx::ObjCIndependentClassAttr::static_kind(): - tp = &(gTypes[318]); + tp = &(gTypes[322]); break; case mx::ObjCExternallyRetainedAttr::static_kind(): - tp = &(gTypes[319]); + tp = &(gTypes[323]); break; case mx::ObjCExplicitProtocolImplAttr::static_kind(): - tp = &(gTypes[320]); + tp = &(gTypes[324]); break; case mx::ObjCExceptionAttr::static_kind(): - tp = &(gTypes[321]); + tp = &(gTypes[325]); break; case mx::ObjCBridgeRelatedAttr::static_kind(): - tp = &(gTypes[322]); + tp = &(gTypes[326]); break; case mx::ObjCBridgeMutableAttr::static_kind(): - tp = &(gTypes[323]); + tp = &(gTypes[327]); break; case mx::ObjCBridgeAttr::static_kind(): - tp = &(gTypes[324]); + tp = &(gTypes[328]); break; case mx::OSReturnsRetainedOnZeroAttr::static_kind(): - tp = &(gTypes[325]); + tp = &(gTypes[329]); break; case mx::OSReturnsRetainedOnNonZeroAttr::static_kind(): - tp = &(gTypes[326]); + tp = &(gTypes[330]); break; case mx::OSReturnsRetainedAttr::static_kind(): - tp = &(gTypes[327]); + tp = &(gTypes[331]); break; case mx::OSReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[328]); + tp = &(gTypes[332]); break; case mx::OSConsumesThisAttr::static_kind(): - tp = &(gTypes[329]); + tp = &(gTypes[333]); break; case mx::OMPThreadPrivateDeclAttr::static_kind(): - tp = &(gTypes[330]); + tp = &(gTypes[334]); break; case mx::OMPDeclareVariantAttr::static_kind(): - tp = &(gTypes[331]); + tp = &(gTypes[335]); break; case mx::OMPDeclareTargetDeclAttr::static_kind(): - tp = &(gTypes[332]); + tp = &(gTypes[336]); break; case mx::OMPCaptureNoInitAttr::static_kind(): - tp = &(gTypes[333]); + tp = &(gTypes[337]); break; case mx::OMPAllocateDeclAttr::static_kind(): - tp = &(gTypes[334]); + tp = &(gTypes[338]); break; case mx::NotTailCalledAttr::static_kind(): - tp = &(gTypes[335]); + tp = &(gTypes[339]); break; case mx::NoUwtableAttr::static_kind(): - tp = &(gTypes[336]); + tp = &(gTypes[340]); break; case mx::NoUniqueAddressAttr::static_kind(): - tp = &(gTypes[337]); + tp = &(gTypes[341]); break; case mx::NoThrowAttr::static_kind(): - tp = &(gTypes[338]); + tp = &(gTypes[342]); break; case mx::NoThreadSafetyAnalysisAttr::static_kind(): - tp = &(gTypes[339]); + tp = &(gTypes[343]); break; case mx::NoStackProtectorAttr::static_kind(): - tp = &(gTypes[340]); + tp = &(gTypes[344]); break; case mx::NoSplitStackAttr::static_kind(): - tp = &(gTypes[341]); + tp = &(gTypes[345]); break; case mx::NoSpeculativeLoadHardeningAttr::static_kind(): - tp = &(gTypes[342]); + tp = &(gTypes[346]); break; case mx::NoSanitizeAttr::static_kind(): - tp = &(gTypes[343]); + tp = &(gTypes[347]); break; case mx::NoReturnAttr::static_kind(): - tp = &(gTypes[344]); + tp = &(gTypes[348]); break; case mx::NoRandomizeLayoutAttr::static_kind(): - tp = &(gTypes[345]); + tp = &(gTypes[349]); break; case mx::NoProfileFunctionAttr::static_kind(): - tp = &(gTypes[346]); + tp = &(gTypes[350]); break; case mx::NoMips16Attr::static_kind(): - tp = &(gTypes[347]); + tp = &(gTypes[351]); break; case mx::NoMicroMipsAttr::static_kind(): - tp = &(gTypes[348]); + tp = &(gTypes[352]); break; case mx::NoInstrumentFunctionAttr::static_kind(): - tp = &(gTypes[349]); + tp = &(gTypes[353]); break; case mx::NoDuplicateAttr::static_kind(): - tp = &(gTypes[350]); + tp = &(gTypes[354]); break; case mx::NoDestroyAttr::static_kind(): - tp = &(gTypes[351]); + tp = &(gTypes[355]); break; case mx::NoDebugAttr::static_kind(): - tp = &(gTypes[352]); + tp = &(gTypes[356]); break; case mx::NoCommonAttr::static_kind(): - tp = &(gTypes[353]); + tp = &(gTypes[357]); break; case mx::NoAliasAttr::static_kind(): - tp = &(gTypes[354]); + tp = &(gTypes[358]); break; case mx::NakedAttr::static_kind(): - tp = &(gTypes[355]); + tp = &(gTypes[359]); break; case mx::NVPTXKernelAttr::static_kind(): - tp = &(gTypes[356]); + tp = &(gTypes[360]); break; case mx::NSReturnsRetainedAttr::static_kind(): - tp = &(gTypes[357]); + tp = &(gTypes[361]); break; case mx::NSReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[358]); + tp = &(gTypes[362]); break; case mx::NSReturnsAutoreleasedAttr::static_kind(): - tp = &(gTypes[359]); + tp = &(gTypes[363]); break; case mx::NSErrorDomainAttr::static_kind(): - tp = &(gTypes[360]); + tp = &(gTypes[364]); break; case mx::NSConsumesSelfAttr::static_kind(): - tp = &(gTypes[361]); + tp = &(gTypes[365]); break; case mx::MipsShortCallAttr::static_kind(): - tp = &(gTypes[362]); + tp = &(gTypes[366]); break; case mx::MipsLongCallAttr::static_kind(): - tp = &(gTypes[363]); + tp = &(gTypes[367]); break; case mx::MipsInterruptAttr::static_kind(): - tp = &(gTypes[364]); + tp = &(gTypes[368]); break; case mx::Mips16Attr::static_kind(): - tp = &(gTypes[365]); + tp = &(gTypes[369]); break; case mx::MinVectorWidthAttr::static_kind(): - tp = &(gTypes[366]); + tp = &(gTypes[370]); break; case mx::MinSizeAttr::static_kind(): - tp = &(gTypes[367]); + tp = &(gTypes[371]); break; case mx::MicroMipsAttr::static_kind(): - tp = &(gTypes[368]); + tp = &(gTypes[372]); break; case mx::MaybeUndefAttr::static_kind(): - tp = &(gTypes[369]); + tp = &(gTypes[373]); break; case mx::MayAliasAttr::static_kind(): - tp = &(gTypes[370]); + tp = &(gTypes[374]); break; case mx::MaxFieldAlignmentAttr::static_kind(): - tp = &(gTypes[371]); + tp = &(gTypes[375]); break; case mx::MSVtorDispAttr::static_kind(): - tp = &(gTypes[372]); + tp = &(gTypes[376]); break; case mx::MSStructAttr::static_kind(): - tp = &(gTypes[373]); + tp = &(gTypes[377]); break; case mx::MSP430InterruptAttr::static_kind(): - tp = &(gTypes[374]); + tp = &(gTypes[378]); break; case mx::MSNoVTableAttr::static_kind(): - tp = &(gTypes[375]); + tp = &(gTypes[379]); break; case mx::MSInheritanceAttr::static_kind(): - tp = &(gTypes[376]); + tp = &(gTypes[380]); break; case mx::MSConstexprAttr::static_kind(): - tp = &(gTypes[377]); + tp = &(gTypes[381]); break; case mx::MSAllocatorAttr::static_kind(): - tp = &(gTypes[378]); + tp = &(gTypes[382]); break; case mx::MSABIAttr::static_kind(): - tp = &(gTypes[379]); + tp = &(gTypes[383]); break; case mx::MIGServerRoutineAttr::static_kind(): - tp = &(gTypes[380]); + tp = &(gTypes[384]); break; case mx::M68kRTDAttr::static_kind(): - tp = &(gTypes[381]); + tp = &(gTypes[385]); break; case mx::M68kInterruptAttr::static_kind(): - tp = &(gTypes[382]); + tp = &(gTypes[386]); break; case mx::LocksExcludedAttr::static_kind(): - tp = &(gTypes[383]); + tp = &(gTypes[387]); break; case mx::LockReturnedAttr::static_kind(): - tp = &(gTypes[384]); + tp = &(gTypes[388]); break; case mx::LifetimeBoundAttr::static_kind(): - tp = &(gTypes[385]); + tp = &(gTypes[389]); break; case mx::LeafAttr::static_kind(): - tp = &(gTypes[386]); + tp = &(gTypes[390]); break; case mx::LayoutVersionAttr::static_kind(): - tp = &(gTypes[387]); + tp = &(gTypes[391]); break; case mx::LTOVisibilityPublicAttr::static_kind(): - tp = &(gTypes[388]); + tp = &(gTypes[392]); break; case mx::InternalLinkageAttr::static_kind(): - tp = &(gTypes[389]); + tp = &(gTypes[393]); break; case mx::IntelOclBiccAttr::static_kind(): - tp = &(gTypes[390]); + tp = &(gTypes[394]); break; case mx::InitPriorityAttr::static_kind(): - tp = &(gTypes[391]); + tp = &(gTypes[395]); break; case mx::CarriesDependencyAttr::static_kind(): - tp = &(gTypes[393]); + tp = &(gTypes[397]); break; case mx::CFConsumedAttr::static_kind(): - tp = &(gTypes[394]); + tp = &(gTypes[398]); break; case mx::AnnotateAttr::static_kind(): - tp = &(gTypes[395]); + tp = &(gTypes[399]); break; case mx::UseHandleAttr::static_kind(): - tp = &(gTypes[396]); + tp = &(gTypes[400]); break; case mx::ReleaseHandleAttr::static_kind(): - tp = &(gTypes[397]); + tp = &(gTypes[401]); break; case mx::PassObjectSizeAttr::static_kind(): - tp = &(gTypes[398]); + tp = &(gTypes[402]); break; case mx::SwiftIndirectResultAttr::static_kind(): - tp = &(gTypes[400]); + tp = &(gTypes[404]); break; case mx::SwiftErrorResultAttr::static_kind(): - tp = &(gTypes[401]); + tp = &(gTypes[405]); break; case mx::SwiftContextAttr::static_kind(): - tp = &(gTypes[402]); + tp = &(gTypes[406]); break; case mx::SwiftAsyncContextAttr::static_kind(): - tp = &(gTypes[403]); + tp = &(gTypes[407]); break; case mx::OSConsumedAttr::static_kind(): - tp = &(gTypes[404]); + tp = &(gTypes[408]); break; case mx::NonNullAttr::static_kind(): - tp = &(gTypes[405]); + tp = &(gTypes[409]); break; case mx::NSConsumedAttr::static_kind(): - tp = &(gTypes[406]); + tp = &(gTypes[410]); break; } @@ -1572,7 +1572,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -1624,7 +1624,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[76]); + PyTypeObject * const tp = &(gTypes[80]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -1639,12 +1639,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/InheritableParamAttr.cpp b/bindings/Python/Generated/AST/InheritableParamAttr.cpp index a04b1bc1f..a11764a55 100644 --- a/bindings/Python/Generated/AST/InheritableParamAttr.cpp +++ b/bindings/Python/Generated/AST/InheritableParamAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[392]) || tp >= &(gTypes[407])) { + if (tp < &(gTypes[396]) || tp >= &(gTypes[411])) { return std::nullopt; } @@ -88,55 +88,55 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::CarriesDependencyAttr::static_kind(): - tp = &(gTypes[393]); + tp = &(gTypes[397]); break; case mx::CFConsumedAttr::static_kind(): - tp = &(gTypes[394]); + tp = &(gTypes[398]); break; case mx::AnnotateAttr::static_kind(): - tp = &(gTypes[395]); + tp = &(gTypes[399]); break; case mx::UseHandleAttr::static_kind(): - tp = &(gTypes[396]); + tp = &(gTypes[400]); break; case mx::ReleaseHandleAttr::static_kind(): - tp = &(gTypes[397]); + tp = &(gTypes[401]); break; case mx::PassObjectSizeAttr::static_kind(): - tp = &(gTypes[398]); + tp = &(gTypes[402]); break; case mx::SwiftIndirectResultAttr::static_kind(): - tp = &(gTypes[400]); + tp = &(gTypes[404]); break; case mx::SwiftErrorResultAttr::static_kind(): - tp = &(gTypes[401]); + tp = &(gTypes[405]); break; case mx::SwiftContextAttr::static_kind(): - tp = &(gTypes[402]); + tp = &(gTypes[406]); break; case mx::SwiftAsyncContextAttr::static_kind(): - tp = &(gTypes[403]); + tp = &(gTypes[407]); break; case mx::OSConsumedAttr::static_kind(): - tp = &(gTypes[404]); + tp = &(gTypes[408]); break; case mx::NonNullAttr::static_kind(): - tp = &(gTypes[405]); + tp = &(gTypes[409]); break; case mx::NSConsumedAttr::static_kind(): - tp = &(gTypes[406]); + tp = &(gTypes[410]); break; } @@ -310,7 +310,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -362,7 +362,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[392]); + PyTypeObject * const tp = &(gTypes[396]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -377,12 +377,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/InitListExpr.cpp b/bindings/Python/Generated/AST/InitListExpr.cpp index 9a77de5f3..df59e727e 100644 --- a/bindings/Python/Generated/AST/InitListExpr.cpp +++ b/bindings/Python/Generated/AST/InitListExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[705]) || tp >= &(gTypes[706])) { + if (tp < &(gTypes[709]) || tp >= &(gTypes[710])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::InitListExpr::static_kind(): - tp = &(gTypes[705]); + tp = &(gTypes[709]); break; } @@ -479,7 +479,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -531,7 +531,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[705]); + PyTypeObject * const tp = &(gTypes[709]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -546,12 +546,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/InitPriorityAttr.cpp b/bindings/Python/Generated/AST/InitPriorityAttr.cpp index 86a163a0c..81c1fa536 100644 --- a/bindings/Python/Generated/AST/InitPriorityAttr.cpp +++ b/bindings/Python/Generated/AST/InitPriorityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[391]) || tp >= &(gTypes[392])) { + if (tp < &(gTypes[395]) || tp >= &(gTypes[396])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::InitPriorityAttr::static_kind(): - tp = &(gTypes[391]); + tp = &(gTypes[395]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[391]); + PyTypeObject * const tp = &(gTypes[395]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/InitSegAttr.cpp b/bindings/Python/Generated/AST/InitSegAttr.cpp index 3311d2a77..c3719f95c 100644 --- a/bindings/Python/Generated/AST/InitSegAttr.cpp +++ b/bindings/Python/Generated/AST/InitSegAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[75]) || tp >= &(gTypes[76])) { + if (tp < &(gTypes[79]) || tp >= &(gTypes[80])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::InitSegAttr::static_kind(): - tp = &(gTypes[75]); + tp = &(gTypes[79]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[75]); + PyTypeObject * const tp = &(gTypes[79]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/InjectedClassNameType.cpp b/bindings/Python/Generated/AST/InjectedClassNameType.cpp index 1162b081d..572dee4b0 100644 --- a/bindings/Python/Generated/AST/InjectedClassNameType.cpp +++ b/bindings/Python/Generated/AST/InjectedClassNameType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[435]) || tp >= &(gTypes[436])) { + if (tp < &(gTypes[439]) || tp >= &(gTypes[440])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::InjectedClassNameType::static_kind(): - tp = &(gTypes[435]); + tp = &(gTypes[439]); break; } @@ -303,7 +303,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -355,7 +355,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[435]); + PyTypeObject * const tp = &(gTypes[439]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -370,12 +370,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IntegerLiteral.cpp b/bindings/Python/Generated/AST/IntegerLiteral.cpp index 7fb1e5369..9bdbef6a9 100644 --- a/bindings/Python/Generated/AST/IntegerLiteral.cpp +++ b/bindings/Python/Generated/AST/IntegerLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[704]) || tp >= &(gTypes[705])) { + if (tp < &(gTypes[708]) || tp >= &(gTypes[709])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IntegerLiteral::static_kind(): - tp = &(gTypes[704]); + tp = &(gTypes[708]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[704]); + PyTypeObject * const tp = &(gTypes[708]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp b/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp index 91d0beb23..ca276d60d 100644 --- a/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp +++ b/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[390]) || tp >= &(gTypes[391])) { + if (tp < &(gTypes[394]) || tp >= &(gTypes[395])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IntelOclBiccAttr::static_kind(): - tp = &(gTypes[390]); + tp = &(gTypes[394]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[390]); + PyTypeObject * const tp = &(gTypes[394]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/InternalLinkageAttr.cpp b/bindings/Python/Generated/AST/InternalLinkageAttr.cpp index e88115233..d09fbe831 100644 --- a/bindings/Python/Generated/AST/InternalLinkageAttr.cpp +++ b/bindings/Python/Generated/AST/InternalLinkageAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[389]) || tp >= &(gTypes[390])) { + if (tp < &(gTypes[393]) || tp >= &(gTypes[394])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::InternalLinkageAttr::static_kind(): - tp = &(gTypes[389]); + tp = &(gTypes[393]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[389]); + PyTypeObject * const tp = &(gTypes[393]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp b/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp index 6c39c1b78..48b08d210 100644 --- a/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp +++ b/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[388]) || tp >= &(gTypes[389])) { + if (tp < &(gTypes[392]) || tp >= &(gTypes[393])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LTOVisibilityPublicAttr::static_kind(): - tp = &(gTypes[388]); + tp = &(gTypes[392]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[388]); + PyTypeObject * const tp = &(gTypes[392]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LValueReferenceType.cpp b/bindings/Python/Generated/AST/LValueReferenceType.cpp index 4eeb5b2e7..91798478c 100644 --- a/bindings/Python/Generated/AST/LValueReferenceType.cpp +++ b/bindings/Python/Generated/AST/LValueReferenceType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[420]) || tp >= &(gTypes[421])) { + if (tp < &(gTypes[424]) || tp >= &(gTypes[425])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LValueReferenceType::static_kind(): - tp = &(gTypes[420]); + tp = &(gTypes[424]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[420]); + PyTypeObject * const tp = &(gTypes[424]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[418].tp_hash; - tp->tp_richcompare = gTypes[418].tp_richcompare; + tp->tp_hash = gTypes[422].tp_hash; + tp->tp_richcompare = gTypes[422].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[418]); + tp->tp_base = &(gTypes[422]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LabelDecl.cpp b/bindings/Python/Generated/AST/LabelDecl.cpp index b6be347c3..0e7c13d52 100644 --- a/bindings/Python/Generated/AST/LabelDecl.cpp +++ b/bindings/Python/Generated/AST/LabelDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[739]) || tp >= &(gTypes[740])) { + if (tp < &(gTypes[743]) || tp >= &(gTypes[744])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LabelDecl::static_kind(): - tp = &(gTypes[739]); + tp = &(gTypes[743]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[739]); + PyTypeObject * const tp = &(gTypes[743]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LabelStmt.cpp b/bindings/Python/Generated/AST/LabelStmt.cpp index 3a44beef9..23bf51f9f 100644 --- a/bindings/Python/Generated/AST/LabelStmt.cpp +++ b/bindings/Python/Generated/AST/LabelStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[585]) || tp >= &(gTypes[586])) { + if (tp < &(gTypes[589]) || tp >= &(gTypes[590])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LabelStmt::static_kind(): - tp = &(gTypes[585]); + tp = &(gTypes[589]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[585]); + PyTypeObject * const tp = &(gTypes[589]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[584].tp_hash; - tp->tp_richcompare = gTypes[584].tp_richcompare; + tp->tp_hash = gTypes[588].tp_hash; + tp->tp_richcompare = gTypes[588].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[584]); + tp->tp_base = &(gTypes[588]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LambdaExpr.cpp b/bindings/Python/Generated/AST/LambdaExpr.cpp index 68fa0a5c2..90c05824c 100644 --- a/bindings/Python/Generated/AST/LambdaExpr.cpp +++ b/bindings/Python/Generated/AST/LambdaExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[703]) || tp >= &(gTypes[704])) { + if (tp < &(gTypes[707]) || tp >= &(gTypes[708])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LambdaExpr::static_kind(): - tp = &(gTypes[703]); + tp = &(gTypes[707]); break; } @@ -479,7 +479,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -531,7 +531,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[703]); + PyTypeObject * const tp = &(gTypes[707]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -546,12 +546,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LayoutVersionAttr.cpp b/bindings/Python/Generated/AST/LayoutVersionAttr.cpp index 663dffe6c..f6881de10 100644 --- a/bindings/Python/Generated/AST/LayoutVersionAttr.cpp +++ b/bindings/Python/Generated/AST/LayoutVersionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[387]) || tp >= &(gTypes[388])) { + if (tp < &(gTypes[391]) || tp >= &(gTypes[392])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LayoutVersionAttr::static_kind(): - tp = &(gTypes[387]); + tp = &(gTypes[391]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[387]); + PyTypeObject * const tp = &(gTypes[391]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LeafAttr.cpp b/bindings/Python/Generated/AST/LeafAttr.cpp index 27c387739..f46578b11 100644 --- a/bindings/Python/Generated/AST/LeafAttr.cpp +++ b/bindings/Python/Generated/AST/LeafAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[386]) || tp >= &(gTypes[387])) { + if (tp < &(gTypes[390]) || tp >= &(gTypes[391])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LeafAttr::static_kind(): - tp = &(gTypes[386]); + tp = &(gTypes[390]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[386]); + PyTypeObject * const tp = &(gTypes[390]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp b/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp index 7177f7071..73a9a2979 100644 --- a/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp +++ b/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[385]) || tp >= &(gTypes[386])) { + if (tp < &(gTypes[389]) || tp >= &(gTypes[390])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LifetimeBoundAttr::static_kind(): - tp = &(gTypes[385]); + tp = &(gTypes[389]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[385]); + PyTypeObject * const tp = &(gTypes[389]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp b/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp index 28d81f34f..f3bf6107c 100644 --- a/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp +++ b/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[814]) || tp >= &(gTypes[815])) { + if (tp < &(gTypes[818]) || tp >= &(gTypes[819])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LifetimeExtendedTemporaryDecl::static_kind(): - tp = &(gTypes[814]); + tp = &(gTypes[818]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[814]); + PyTypeObject * const tp = &(gTypes[818]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LikelyAttr.cpp b/bindings/Python/Generated/AST/LikelyAttr.cpp index 5a033964c..9390b9fe0 100644 --- a/bindings/Python/Generated/AST/LikelyAttr.cpp +++ b/bindings/Python/Generated/AST/LikelyAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[51]) || tp >= &(gTypes[52])) { + if (tp < &(gTypes[55]) || tp >= &(gTypes[56])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LikelyAttr::static_kind(): - tp = &(gTypes[51]); + tp = &(gTypes[55]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[51]); + PyTypeObject * const tp = &(gTypes[55]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[48].tp_hash; - tp->tp_richcompare = gTypes[48].tp_richcompare; + tp->tp_hash = gTypes[52].tp_hash; + tp->tp_richcompare = gTypes[52].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[48]); + tp->tp_base = &(gTypes[52]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LinkageSpecDecl.cpp b/bindings/Python/Generated/AST/LinkageSpecDecl.cpp index 58a66d12a..3d03970af 100644 --- a/bindings/Python/Generated/AST/LinkageSpecDecl.cpp +++ b/bindings/Python/Generated/AST/LinkageSpecDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[813]) || tp >= &(gTypes[814])) { + if (tp < &(gTypes[817]) || tp >= &(gTypes[818])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LinkageSpecDecl::static_kind(): - tp = &(gTypes[813]); + tp = &(gTypes[817]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[813]); + PyTypeObject * const tp = &(gTypes[817]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp b/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp index 04bf23625..d87b217fb 100644 --- a/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp +++ b/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[74]) || tp >= &(gTypes[75])) { + if (tp < &(gTypes[78]) || tp >= &(gTypes[79])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LoaderUninitializedAttr::static_kind(): - tp = &(gTypes[74]); + tp = &(gTypes[78]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[74]); + PyTypeObject * const tp = &(gTypes[78]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LockReturnedAttr.cpp b/bindings/Python/Generated/AST/LockReturnedAttr.cpp index dbddcd465..4ae29b55b 100644 --- a/bindings/Python/Generated/AST/LockReturnedAttr.cpp +++ b/bindings/Python/Generated/AST/LockReturnedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[384]) || tp >= &(gTypes[385])) { + if (tp < &(gTypes[388]) || tp >= &(gTypes[389])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LockReturnedAttr::static_kind(): - tp = &(gTypes[384]); + tp = &(gTypes[388]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[384]); + PyTypeObject * const tp = &(gTypes[388]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LocksExcludedAttr.cpp b/bindings/Python/Generated/AST/LocksExcludedAttr.cpp index a086e3463..0ad3a4b4c 100644 --- a/bindings/Python/Generated/AST/LocksExcludedAttr.cpp +++ b/bindings/Python/Generated/AST/LocksExcludedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[383]) || tp >= &(gTypes[384])) { + if (tp < &(gTypes[387]) || tp >= &(gTypes[388])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LocksExcludedAttr::static_kind(): - tp = &(gTypes[383]); + tp = &(gTypes[387]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[383]); + PyTypeObject * const tp = &(gTypes[387]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/LoopHintAttr.cpp b/bindings/Python/Generated/AST/LoopHintAttr.cpp index cb0c667e8..2870860f9 100644 --- a/bindings/Python/Generated/AST/LoopHintAttr.cpp +++ b/bindings/Python/Generated/AST/LoopHintAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[73]) || tp >= &(gTypes[74])) { + if (tp < &(gTypes[77]) || tp >= &(gTypes[78])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LoopHintAttr::static_kind(): - tp = &(gTypes[73]); + tp = &(gTypes[77]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[73]); + PyTypeObject * const tp = &(gTypes[77]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/M68kInterruptAttr.cpp b/bindings/Python/Generated/AST/M68kInterruptAttr.cpp index 66e9d0d5f..379c4225f 100644 --- a/bindings/Python/Generated/AST/M68kInterruptAttr.cpp +++ b/bindings/Python/Generated/AST/M68kInterruptAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[382]) || tp >= &(gTypes[383])) { + if (tp < &(gTypes[386]) || tp >= &(gTypes[387])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::M68kInterruptAttr::static_kind(): - tp = &(gTypes[382]); + tp = &(gTypes[386]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[382]); + PyTypeObject * const tp = &(gTypes[386]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/M68kRTDAttr.cpp b/bindings/Python/Generated/AST/M68kRTDAttr.cpp index ff6186695..225eb97fa 100644 --- a/bindings/Python/Generated/AST/M68kRTDAttr.cpp +++ b/bindings/Python/Generated/AST/M68kRTDAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[381]) || tp >= &(gTypes[382])) { + if (tp < &(gTypes[385]) || tp >= &(gTypes[386])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::M68kRTDAttr::static_kind(): - tp = &(gTypes[381]); + tp = &(gTypes[385]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[381]); + PyTypeObject * const tp = &(gTypes[385]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp b/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp index 97646ff7b..d77607085 100644 --- a/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp +++ b/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[380]) || tp >= &(gTypes[381])) { + if (tp < &(gTypes[384]) || tp >= &(gTypes[385])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MIGServerRoutineAttr::static_kind(): - tp = &(gTypes[380]); + tp = &(gTypes[384]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[380]); + PyTypeObject * const tp = &(gTypes[384]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSABIAttr.cpp b/bindings/Python/Generated/AST/MSABIAttr.cpp index d6cdcb5c4..76d9907bc 100644 --- a/bindings/Python/Generated/AST/MSABIAttr.cpp +++ b/bindings/Python/Generated/AST/MSABIAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[379]) || tp >= &(gTypes[380])) { + if (tp < &(gTypes[383]) || tp >= &(gTypes[384])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSABIAttr::static_kind(): - tp = &(gTypes[379]); + tp = &(gTypes[383]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[379]); + PyTypeObject * const tp = &(gTypes[383]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSAllocatorAttr.cpp b/bindings/Python/Generated/AST/MSAllocatorAttr.cpp index 475163e38..247be9b05 100644 --- a/bindings/Python/Generated/AST/MSAllocatorAttr.cpp +++ b/bindings/Python/Generated/AST/MSAllocatorAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[378]) || tp >= &(gTypes[379])) { + if (tp < &(gTypes[382]) || tp >= &(gTypes[383])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSAllocatorAttr::static_kind(): - tp = &(gTypes[378]); + tp = &(gTypes[382]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[378]); + PyTypeObject * const tp = &(gTypes[382]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSAsmStmt.cpp b/bindings/Python/Generated/AST/MSAsmStmt.cpp index f9ca841c3..c6f0f76ad 100644 --- a/bindings/Python/Generated/AST/MSAsmStmt.cpp +++ b/bindings/Python/Generated/AST/MSAsmStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[581]) || tp >= &(gTypes[582])) { + if (tp < &(gTypes[585]) || tp >= &(gTypes[586])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSAsmStmt::static_kind(): - tp = &(gTypes[581]); + tp = &(gTypes[585]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -431,7 +431,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[581]); + PyTypeObject * const tp = &(gTypes[585]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -446,12 +446,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[580].tp_hash; - tp->tp_richcompare = gTypes[580].tp_richcompare; + tp->tp_hash = gTypes[584].tp_hash; + tp->tp_richcompare = gTypes[584].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[580]); + tp->tp_base = &(gTypes[584]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSConstexprAttr.cpp b/bindings/Python/Generated/AST/MSConstexprAttr.cpp index 2be370cab..b9dd1e9fb 100644 --- a/bindings/Python/Generated/AST/MSConstexprAttr.cpp +++ b/bindings/Python/Generated/AST/MSConstexprAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[377]) || tp >= &(gTypes[378])) { + if (tp < &(gTypes[381]) || tp >= &(gTypes[382])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSConstexprAttr::static_kind(): - tp = &(gTypes[377]); + tp = &(gTypes[381]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[377]); + PyTypeObject * const tp = &(gTypes[381]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp b/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp index 45b0401c2..a82b00faa 100644 --- a/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp +++ b/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[564]) || tp >= &(gTypes[565])) { + if (tp < &(gTypes[568]) || tp >= &(gTypes[569])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSDependentExistsStmt::static_kind(): - tp = &(gTypes[564]); + tp = &(gTypes[568]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[564]); + PyTypeObject * const tp = &(gTypes[568]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSGuidDecl.cpp b/bindings/Python/Generated/AST/MSGuidDecl.cpp index c84c99106..9aa104fd4 100644 --- a/bindings/Python/Generated/AST/MSGuidDecl.cpp +++ b/bindings/Python/Generated/AST/MSGuidDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[749]) || tp >= &(gTypes[750])) { + if (tp < &(gTypes[753]) || tp >= &(gTypes[754])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSGuidDecl::static_kind(): - tp = &(gTypes[749]); + tp = &(gTypes[753]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[749]); + PyTypeObject * const tp = &(gTypes[753]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSInheritanceAttr.cpp b/bindings/Python/Generated/AST/MSInheritanceAttr.cpp index 8e747f70a..7eac73b37 100644 --- a/bindings/Python/Generated/AST/MSInheritanceAttr.cpp +++ b/bindings/Python/Generated/AST/MSInheritanceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[376]) || tp >= &(gTypes[377])) { + if (tp < &(gTypes[380]) || tp >= &(gTypes[381])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSInheritanceAttr::static_kind(): - tp = &(gTypes[376]); + tp = &(gTypes[380]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[376]); + PyTypeObject * const tp = &(gTypes[380]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSNoVTableAttr.cpp b/bindings/Python/Generated/AST/MSNoVTableAttr.cpp index 144ed003a..555d7d3fb 100644 --- a/bindings/Python/Generated/AST/MSNoVTableAttr.cpp +++ b/bindings/Python/Generated/AST/MSNoVTableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[375]) || tp >= &(gTypes[376])) { + if (tp < &(gTypes[379]) || tp >= &(gTypes[380])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSNoVTableAttr::static_kind(): - tp = &(gTypes[375]); + tp = &(gTypes[379]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[375]); + PyTypeObject * const tp = &(gTypes[379]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp b/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp index af9e7d087..459145512 100644 --- a/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp +++ b/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[374]) || tp >= &(gTypes[375])) { + if (tp < &(gTypes[378]) || tp >= &(gTypes[379])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSP430InterruptAttr::static_kind(): - tp = &(gTypes[374]); + tp = &(gTypes[378]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[374]); + PyTypeObject * const tp = &(gTypes[378]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSPropertyDecl.cpp b/bindings/Python/Generated/AST/MSPropertyDecl.cpp index baf9499f2..39a49bd81 100644 --- a/bindings/Python/Generated/AST/MSPropertyDecl.cpp +++ b/bindings/Python/Generated/AST/MSPropertyDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[761]) || tp >= &(gTypes[762])) { + if (tp < &(gTypes[765]) || tp >= &(gTypes[766])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSPropertyDecl::static_kind(): - tp = &(gTypes[761]); + tp = &(gTypes[765]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[761]); + PyTypeObject * const tp = &(gTypes[765]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[752].tp_hash; - tp->tp_richcompare = gTypes[752].tp_richcompare; + tp->tp_hash = gTypes[756].tp_hash; + tp->tp_richcompare = gTypes[756].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[752]); + tp->tp_base = &(gTypes[756]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp b/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp index fa0ac9808..67fd4e42c 100644 --- a/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp +++ b/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[702]) || tp >= &(gTypes[703])) { + if (tp < &(gTypes[706]) || tp >= &(gTypes[707])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSPropertyRefExpr::static_kind(): - tp = &(gTypes[702]); + tp = &(gTypes[706]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[702]); + PyTypeObject * const tp = &(gTypes[706]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp b/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp index d944c6a5e..44a624bac 100644 --- a/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp +++ b/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[701]) || tp >= &(gTypes[702])) { + if (tp < &(gTypes[705]) || tp >= &(gTypes[706])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSPropertySubscriptExpr::static_kind(): - tp = &(gTypes[701]); + tp = &(gTypes[705]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[701]); + PyTypeObject * const tp = &(gTypes[705]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSStructAttr.cpp b/bindings/Python/Generated/AST/MSStructAttr.cpp index 5591d4265..d97a6ba1e 100644 --- a/bindings/Python/Generated/AST/MSStructAttr.cpp +++ b/bindings/Python/Generated/AST/MSStructAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[373]) || tp >= &(gTypes[374])) { + if (tp < &(gTypes[377]) || tp >= &(gTypes[378])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSStructAttr::static_kind(): - tp = &(gTypes[373]); + tp = &(gTypes[377]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[373]); + PyTypeObject * const tp = &(gTypes[377]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MSVtorDispAttr.cpp b/bindings/Python/Generated/AST/MSVtorDispAttr.cpp index d5083b37b..bed7f8bf2 100644 --- a/bindings/Python/Generated/AST/MSVtorDispAttr.cpp +++ b/bindings/Python/Generated/AST/MSVtorDispAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[372]) || tp >= &(gTypes[373])) { + if (tp < &(gTypes[376]) || tp >= &(gTypes[377])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MSVtorDispAttr::static_kind(): - tp = &(gTypes[372]); + tp = &(gTypes[376]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[372]); + PyTypeObject * const tp = &(gTypes[376]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MacroQualifiedType.cpp b/bindings/Python/Generated/AST/MacroQualifiedType.cpp index 0fa38a2c1..0a105242c 100644 --- a/bindings/Python/Generated/AST/MacroQualifiedType.cpp +++ b/bindings/Python/Generated/AST/MacroQualifiedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[434]) || tp >= &(gTypes[435])) { + if (tp < &(gTypes[438]) || tp >= &(gTypes[439])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroQualifiedType::static_kind(): - tp = &(gTypes[434]); + tp = &(gTypes[438]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[434]); + PyTypeObject * const tp = &(gTypes[438]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp b/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp index 951cbd218..acb81071a 100644 --- a/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp +++ b/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[700]) || tp >= &(gTypes[701])) { + if (tp < &(gTypes[704]) || tp >= &(gTypes[705])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MaterializeTemporaryExpr::static_kind(): - tp = &(gTypes[700]); + tp = &(gTypes[704]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[700]); + PyTypeObject * const tp = &(gTypes[704]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp b/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp index 0850de0ab..7738c2ee9 100644 --- a/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp +++ b/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[699]) || tp >= &(gTypes[700])) { + if (tp < &(gTypes[703]) || tp >= &(gTypes[704])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MatrixSubscriptExpr::static_kind(): - tp = &(gTypes[699]); + tp = &(gTypes[703]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[699]); + PyTypeObject * const tp = &(gTypes[703]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MatrixType.cpp b/bindings/Python/Generated/AST/MatrixType.cpp index 5609712af..141739cc9 100644 --- a/bindings/Python/Generated/AST/MatrixType.cpp +++ b/bindings/Python/Generated/AST/MatrixType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[431]) || tp >= &(gTypes[434])) { + if (tp < &(gTypes[435]) || tp >= &(gTypes[438])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DependentSizedMatrixType::static_kind(): - tp = &(gTypes[432]); + tp = &(gTypes[436]); break; case mx::ConstantMatrixType::static_kind(): - tp = &(gTypes[433]); + tp = &(gTypes[437]); break; } @@ -270,7 +270,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -322,7 +322,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[431]); + PyTypeObject * const tp = &(gTypes[435]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -337,12 +337,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp b/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp index 5b6914699..7620b6ddf 100644 --- a/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp +++ b/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[371]) || tp >= &(gTypes[372])) { + if (tp < &(gTypes[375]) || tp >= &(gTypes[376])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MaxFieldAlignmentAttr::static_kind(): - tp = &(gTypes[371]); + tp = &(gTypes[375]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[371]); + PyTypeObject * const tp = &(gTypes[375]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MayAliasAttr.cpp b/bindings/Python/Generated/AST/MayAliasAttr.cpp index fc3259cde..3573621b7 100644 --- a/bindings/Python/Generated/AST/MayAliasAttr.cpp +++ b/bindings/Python/Generated/AST/MayAliasAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[370]) || tp >= &(gTypes[371])) { + if (tp < &(gTypes[374]) || tp >= &(gTypes[375])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MayAliasAttr::static_kind(): - tp = &(gTypes[370]); + tp = &(gTypes[374]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[370]); + PyTypeObject * const tp = &(gTypes[374]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MaybeUndefAttr.cpp b/bindings/Python/Generated/AST/MaybeUndefAttr.cpp index 6e747dc3a..3ab3ab995 100644 --- a/bindings/Python/Generated/AST/MaybeUndefAttr.cpp +++ b/bindings/Python/Generated/AST/MaybeUndefAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[369]) || tp >= &(gTypes[370])) { + if (tp < &(gTypes[373]) || tp >= &(gTypes[374])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MaybeUndefAttr::static_kind(): - tp = &(gTypes[369]); + tp = &(gTypes[373]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[369]); + PyTypeObject * const tp = &(gTypes[373]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MemberExpr.cpp b/bindings/Python/Generated/AST/MemberExpr.cpp index 94507b778..a3332215b 100644 --- a/bindings/Python/Generated/AST/MemberExpr.cpp +++ b/bindings/Python/Generated/AST/MemberExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[698]) || tp >= &(gTypes[699])) { + if (tp < &(gTypes[702]) || tp >= &(gTypes[703])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MemberExpr::static_kind(): - tp = &(gTypes[698]); + tp = &(gTypes[702]); break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -489,7 +489,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[698]); + PyTypeObject * const tp = &(gTypes[702]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -504,12 +504,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MemberPointerType.cpp b/bindings/Python/Generated/AST/MemberPointerType.cpp index f2f4474ce..21caa4b4d 100644 --- a/bindings/Python/Generated/AST/MemberPointerType.cpp +++ b/bindings/Python/Generated/AST/MemberPointerType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[430]) || tp >= &(gTypes[431])) { + if (tp < &(gTypes[434]) || tp >= &(gTypes[435])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MemberPointerType::static_kind(): - tp = &(gTypes[430]); + tp = &(gTypes[434]); break; } @@ -313,7 +313,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -365,7 +365,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[430]); + PyTypeObject * const tp = &(gTypes[434]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -380,12 +380,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MicroMipsAttr.cpp b/bindings/Python/Generated/AST/MicroMipsAttr.cpp index ffc7c0706..b0992e661 100644 --- a/bindings/Python/Generated/AST/MicroMipsAttr.cpp +++ b/bindings/Python/Generated/AST/MicroMipsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[368]) || tp >= &(gTypes[369])) { + if (tp < &(gTypes[372]) || tp >= &(gTypes[373])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MicroMipsAttr::static_kind(): - tp = &(gTypes[368]); + tp = &(gTypes[372]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[368]); + PyTypeObject * const tp = &(gTypes[372]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MinSizeAttr.cpp b/bindings/Python/Generated/AST/MinSizeAttr.cpp index 38e146ab5..be87bd61a 100644 --- a/bindings/Python/Generated/AST/MinSizeAttr.cpp +++ b/bindings/Python/Generated/AST/MinSizeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[367]) || tp >= &(gTypes[368])) { + if (tp < &(gTypes[371]) || tp >= &(gTypes[372])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MinSizeAttr::static_kind(): - tp = &(gTypes[367]); + tp = &(gTypes[371]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[367]); + PyTypeObject * const tp = &(gTypes[371]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp b/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp index b877214ce..29aa1719b 100644 --- a/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp +++ b/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[366]) || tp >= &(gTypes[367])) { + if (tp < &(gTypes[370]) || tp >= &(gTypes[371])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MinVectorWidthAttr::static_kind(): - tp = &(gTypes[366]); + tp = &(gTypes[370]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[366]); + PyTypeObject * const tp = &(gTypes[370]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Mips16Attr.cpp b/bindings/Python/Generated/AST/Mips16Attr.cpp index 34ea66831..3cc4d293f 100644 --- a/bindings/Python/Generated/AST/Mips16Attr.cpp +++ b/bindings/Python/Generated/AST/Mips16Attr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[365]) || tp >= &(gTypes[366])) { + if (tp < &(gTypes[369]) || tp >= &(gTypes[370])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::Mips16Attr::static_kind(): - tp = &(gTypes[365]); + tp = &(gTypes[369]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[365]); + PyTypeObject * const tp = &(gTypes[369]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MipsInterruptAttr.cpp b/bindings/Python/Generated/AST/MipsInterruptAttr.cpp index ca8ed6dfb..e5ef384f0 100644 --- a/bindings/Python/Generated/AST/MipsInterruptAttr.cpp +++ b/bindings/Python/Generated/AST/MipsInterruptAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[364]) || tp >= &(gTypes[365])) { + if (tp < &(gTypes[368]) || tp >= &(gTypes[369])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MipsInterruptAttr::static_kind(): - tp = &(gTypes[364]); + tp = &(gTypes[368]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[364]); + PyTypeObject * const tp = &(gTypes[368]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MipsLongCallAttr.cpp b/bindings/Python/Generated/AST/MipsLongCallAttr.cpp index a316415d9..17b76dab5 100644 --- a/bindings/Python/Generated/AST/MipsLongCallAttr.cpp +++ b/bindings/Python/Generated/AST/MipsLongCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[363]) || tp >= &(gTypes[364])) { + if (tp < &(gTypes[367]) || tp >= &(gTypes[368])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MipsLongCallAttr::static_kind(): - tp = &(gTypes[363]); + tp = &(gTypes[367]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[363]); + PyTypeObject * const tp = &(gTypes[367]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MipsShortCallAttr.cpp b/bindings/Python/Generated/AST/MipsShortCallAttr.cpp index ad4a1a99a..4f4e4d126 100644 --- a/bindings/Python/Generated/AST/MipsShortCallAttr.cpp +++ b/bindings/Python/Generated/AST/MipsShortCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[362]) || tp >= &(gTypes[363])) { + if (tp < &(gTypes[366]) || tp >= &(gTypes[367])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MipsShortCallAttr::static_kind(): - tp = &(gTypes[362]); + tp = &(gTypes[366]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[362]); + PyTypeObject * const tp = &(gTypes[366]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ModeAttr.cpp b/bindings/Python/Generated/AST/ModeAttr.cpp index 5f09a8aa9..afb49f313 100644 --- a/bindings/Python/Generated/AST/ModeAttr.cpp +++ b/bindings/Python/Generated/AST/ModeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[72]) || tp >= &(gTypes[73])) { + if (tp < &(gTypes[76]) || tp >= &(gTypes[77])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ModeAttr::static_kind(): - tp = &(gTypes[72]); + tp = &(gTypes[76]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[72]); + PyTypeObject * const tp = &(gTypes[76]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/MustTailAttr.cpp b/bindings/Python/Generated/AST/MustTailAttr.cpp index 2a76f7787..d83f2fc8d 100644 --- a/bindings/Python/Generated/AST/MustTailAttr.cpp +++ b/bindings/Python/Generated/AST/MustTailAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[50]) || tp >= &(gTypes[51])) { + if (tp < &(gTypes[54]) || tp >= &(gTypes[55])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MustTailAttr::static_kind(): - tp = &(gTypes[50]); + tp = &(gTypes[54]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[50]); + PyTypeObject * const tp = &(gTypes[54]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[48].tp_hash; - tp->tp_richcompare = gTypes[48].tp_richcompare; + tp->tp_hash = gTypes[52].tp_hash; + tp->tp_richcompare = gTypes[52].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[48]); + tp->tp_base = &(gTypes[52]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NSConsumedAttr.cpp b/bindings/Python/Generated/AST/NSConsumedAttr.cpp index 97ad7446d..2903074f2 100644 --- a/bindings/Python/Generated/AST/NSConsumedAttr.cpp +++ b/bindings/Python/Generated/AST/NSConsumedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[406]) || tp >= &(gTypes[407])) { + if (tp < &(gTypes[410]) || tp >= &(gTypes[411])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NSConsumedAttr::static_kind(): - tp = &(gTypes[406]); + tp = &(gTypes[410]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[406]); + PyTypeObject * const tp = &(gTypes[410]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp b/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp index ab2050f30..d13ef9467 100644 --- a/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp +++ b/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[361]) || tp >= &(gTypes[362])) { + if (tp < &(gTypes[365]) || tp >= &(gTypes[366])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NSConsumesSelfAttr::static_kind(): - tp = &(gTypes[361]); + tp = &(gTypes[365]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[361]); + PyTypeObject * const tp = &(gTypes[365]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp b/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp index 2fda123df..df618be26 100644 --- a/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp +++ b/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[360]) || tp >= &(gTypes[361])) { + if (tp < &(gTypes[364]) || tp >= &(gTypes[365])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NSErrorDomainAttr::static_kind(): - tp = &(gTypes[360]); + tp = &(gTypes[364]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[360]); + PyTypeObject * const tp = &(gTypes[364]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp b/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp index 8ce149705..c9f75095a 100644 --- a/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp +++ b/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[359]) || tp >= &(gTypes[360])) { + if (tp < &(gTypes[363]) || tp >= &(gTypes[364])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NSReturnsAutoreleasedAttr::static_kind(): - tp = &(gTypes[359]); + tp = &(gTypes[363]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[359]); + PyTypeObject * const tp = &(gTypes[363]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp b/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp index f99f38b58..0a6f2a63f 100644 --- a/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp +++ b/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[358]) || tp >= &(gTypes[359])) { + if (tp < &(gTypes[362]) || tp >= &(gTypes[363])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NSReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[358]); + tp = &(gTypes[362]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[358]); + PyTypeObject * const tp = &(gTypes[362]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp b/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp index 3b36582e0..786efdc51 100644 --- a/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp +++ b/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[357]) || tp >= &(gTypes[358])) { + if (tp < &(gTypes[361]) || tp >= &(gTypes[362])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NSReturnsRetainedAttr::static_kind(): - tp = &(gTypes[357]); + tp = &(gTypes[361]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[357]); + PyTypeObject * const tp = &(gTypes[361]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp b/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp index 6b3b086d5..3db746724 100644 --- a/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp +++ b/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[356]) || tp >= &(gTypes[357])) { + if (tp < &(gTypes[360]) || tp >= &(gTypes[361])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NVPTXKernelAttr::static_kind(): - tp = &(gTypes[356]); + tp = &(gTypes[360]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[356]); + PyTypeObject * const tp = &(gTypes[360]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NakedAttr.cpp b/bindings/Python/Generated/AST/NakedAttr.cpp index fedad026e..ba84483da 100644 --- a/bindings/Python/Generated/AST/NakedAttr.cpp +++ b/bindings/Python/Generated/AST/NakedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[355]) || tp >= &(gTypes[356])) { + if (tp < &(gTypes[359]) || tp >= &(gTypes[360])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NakedAttr::static_kind(): - tp = &(gTypes[355]); + tp = &(gTypes[359]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[355]); + PyTypeObject * const tp = &(gTypes[359]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NamedDecl.cpp b/bindings/Python/Generated/AST/NamedDecl.cpp index 7eeaa0c8f..7119e7e2d 100644 --- a/bindings/Python/Generated/AST/NamedDecl.cpp +++ b/bindings/Python/Generated/AST/NamedDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[738]) || tp >= &(gTypes[813])) { + if (tp < &(gTypes[742]) || tp >= &(gTypes[817])) { return std::nullopt; } @@ -88,255 +88,255 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LabelDecl::static_kind(): - tp = &(gTypes[739]); + tp = &(gTypes[743]); break; case mx::HLSLBufferDecl::static_kind(): - tp = &(gTypes[740]); + tp = &(gTypes[744]); break; case mx::UsingEnumDecl::static_kind(): - tp = &(gTypes[742]); + tp = &(gTypes[746]); break; case mx::UsingDecl::static_kind(): - tp = &(gTypes[743]); + tp = &(gTypes[747]); break; case mx::UnresolvedUsingValueDecl::static_kind(): - tp = &(gTypes[745]); + tp = &(gTypes[749]); break; case mx::UnnamedGlobalConstantDecl::static_kind(): - tp = &(gTypes[746]); + tp = &(gTypes[750]); break; case mx::TemplateParamObjectDecl::static_kind(): - tp = &(gTypes[747]); + tp = &(gTypes[751]); break; case mx::OMPDeclareReductionDecl::static_kind(): - tp = &(gTypes[748]); + tp = &(gTypes[752]); break; case mx::MSGuidDecl::static_kind(): - tp = &(gTypes[749]); + tp = &(gTypes[753]); break; case mx::IndirectFieldDecl::static_kind(): - tp = &(gTypes[750]); + tp = &(gTypes[754]); break; case mx::EnumConstantDecl::static_kind(): - tp = &(gTypes[751]); + tp = &(gTypes[755]); break; case mx::VarDecl::static_kind(): - tp = &(gTypes[753]); + tp = &(gTypes[757]); break; case mx::ParmVarDecl::static_kind(): - tp = &(gTypes[754]); + tp = &(gTypes[758]); break; case mx::OMPCapturedExprDecl::static_kind(): - tp = &(gTypes[755]); + tp = &(gTypes[759]); break; case mx::ImplicitParamDecl::static_kind(): - tp = &(gTypes[756]); + tp = &(gTypes[760]); break; case mx::DecompositionDecl::static_kind(): - tp = &(gTypes[757]); + tp = &(gTypes[761]); break; case mx::VarTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[758]); + tp = &(gTypes[762]); break; case mx::VarTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[759]); + tp = &(gTypes[763]); break; case mx::NonTypeTemplateParmDecl::static_kind(): - tp = &(gTypes[760]); + tp = &(gTypes[764]); break; case mx::MSPropertyDecl::static_kind(): - tp = &(gTypes[761]); + tp = &(gTypes[765]); break; case mx::FunctionDecl::static_kind(): - tp = &(gTypes[762]); + tp = &(gTypes[766]); break; case mx::CXXMethodDecl::static_kind(): - tp = &(gTypes[763]); + tp = &(gTypes[767]); break; case mx::CXXDestructorDecl::static_kind(): - tp = &(gTypes[764]); + tp = &(gTypes[768]); break; case mx::CXXConversionDecl::static_kind(): - tp = &(gTypes[765]); + tp = &(gTypes[769]); break; case mx::CXXConstructorDecl::static_kind(): - tp = &(gTypes[766]); + tp = &(gTypes[770]); break; case mx::CXXDeductionGuideDecl::static_kind(): - tp = &(gTypes[767]); + tp = &(gTypes[771]); break; case mx::FieldDecl::static_kind(): - tp = &(gTypes[768]); + tp = &(gTypes[772]); break; case mx::ObjCIvarDecl::static_kind(): - tp = &(gTypes[769]); + tp = &(gTypes[773]); break; case mx::ObjCAtDefsFieldDecl::static_kind(): - tp = &(gTypes[770]); + tp = &(gTypes[774]); break; case mx::BindingDecl::static_kind(): - tp = &(gTypes[771]); + tp = &(gTypes[775]); break; case mx::OMPDeclareMapperDecl::static_kind(): - tp = &(gTypes[773]); + tp = &(gTypes[777]); break; case mx::UsingShadowDecl::static_kind(): - tp = &(gTypes[774]); + tp = &(gTypes[778]); break; case mx::ConstructorUsingShadowDecl::static_kind(): - tp = &(gTypes[775]); + tp = &(gTypes[779]); break; case mx::UsingPackDecl::static_kind(): - tp = &(gTypes[776]); + tp = &(gTypes[780]); break; case mx::UsingDirectiveDecl::static_kind(): - tp = &(gTypes[777]); + tp = &(gTypes[781]); break; case mx::UnresolvedUsingIfExistsDecl::static_kind(): - tp = &(gTypes[778]); + tp = &(gTypes[782]); break; case mx::TemplateTypeParmDecl::static_kind(): - tp = &(gTypes[780]); + tp = &(gTypes[784]); break; case mx::RecordDecl::static_kind(): - tp = &(gTypes[782]); + tp = &(gTypes[786]); break; case mx::CXXRecordDecl::static_kind(): - tp = &(gTypes[783]); + tp = &(gTypes[787]); break; case mx::ClassTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[784]); + tp = &(gTypes[788]); break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; case mx::EnumDecl::static_kind(): - tp = &(gTypes[786]); + tp = &(gTypes[790]); break; case mx::UnresolvedUsingTypenameDecl::static_kind(): - tp = &(gTypes[787]); + tp = &(gTypes[791]); break; case mx::TypedefDecl::static_kind(): - tp = &(gTypes[789]); + tp = &(gTypes[793]); break; case mx::TypeAliasDecl::static_kind(): - tp = &(gTypes[790]); + tp = &(gTypes[794]); break; case mx::ObjCTypeParamDecl::static_kind(): - tp = &(gTypes[791]); + tp = &(gTypes[795]); break; case mx::FunctionTemplateDecl::static_kind(): - tp = &(gTypes[794]); + tp = &(gTypes[798]); break; case mx::ClassTemplateDecl::static_kind(): - tp = &(gTypes[795]); + tp = &(gTypes[799]); break; case mx::VarTemplateDecl::static_kind(): - tp = &(gTypes[796]); + tp = &(gTypes[800]); break; case mx::TypeAliasTemplateDecl::static_kind(): - tp = &(gTypes[797]); + tp = &(gTypes[801]); break; case mx::ConceptDecl::static_kind(): - tp = &(gTypes[798]); + tp = &(gTypes[802]); break; case mx::BuiltinTemplateDecl::static_kind(): - tp = &(gTypes[799]); + tp = &(gTypes[803]); break; case mx::TemplateTemplateParmDecl::static_kind(): - tp = &(gTypes[800]); + tp = &(gTypes[804]); break; case mx::ObjCPropertyDecl::static_kind(): - tp = &(gTypes[801]); + tp = &(gTypes[805]); break; case mx::ObjCMethodDecl::static_kind(): - tp = &(gTypes[802]); + tp = &(gTypes[806]); break; case mx::ObjCCategoryDecl::static_kind(): - tp = &(gTypes[804]); + tp = &(gTypes[808]); break; case mx::ObjCProtocolDecl::static_kind(): - tp = &(gTypes[805]); + tp = &(gTypes[809]); break; case mx::ObjCInterfaceDecl::static_kind(): - tp = &(gTypes[806]); + tp = &(gTypes[810]); break; case mx::ObjCCategoryImplDecl::static_kind(): - tp = &(gTypes[808]); + tp = &(gTypes[812]); break; case mx::ObjCImplementationDecl::static_kind(): - tp = &(gTypes[809]); + tp = &(gTypes[813]); break; case mx::ObjCCompatibleAliasDecl::static_kind(): - tp = &(gTypes[810]); + tp = &(gTypes[814]); break; case mx::NamespaceDecl::static_kind(): - tp = &(gTypes[811]); + tp = &(gTypes[815]); break; case mx::NamespaceAliasDecl::static_kind(): - tp = &(gTypes[812]); + tp = &(gTypes[816]); break; } @@ -710,7 +710,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -762,7 +762,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[738]); + PyTypeObject * const tp = &(gTypes[742]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -777,12 +777,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp b/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp index 7b5f52f60..62d4f51cf 100644 --- a/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp +++ b/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[812]) || tp >= &(gTypes[813])) { + if (tp < &(gTypes[816]) || tp >= &(gTypes[817])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NamespaceAliasDecl::static_kind(): - tp = &(gTypes[812]); + tp = &(gTypes[816]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[812]); + PyTypeObject * const tp = &(gTypes[816]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NamespaceDecl.cpp b/bindings/Python/Generated/AST/NamespaceDecl.cpp index 6f1f5629e..db33307bd 100644 --- a/bindings/Python/Generated/AST/NamespaceDecl.cpp +++ b/bindings/Python/Generated/AST/NamespaceDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[811]) || tp >= &(gTypes[812])) { + if (tp < &(gTypes[815]) || tp >= &(gTypes[816])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NamespaceDecl::static_kind(): - tp = &(gTypes[811]); + tp = &(gTypes[815]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[811]); + PyTypeObject * const tp = &(gTypes[815]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoAliasAttr.cpp b/bindings/Python/Generated/AST/NoAliasAttr.cpp index ea1673e8a..06f882759 100644 --- a/bindings/Python/Generated/AST/NoAliasAttr.cpp +++ b/bindings/Python/Generated/AST/NoAliasAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[354]) || tp >= &(gTypes[355])) { + if (tp < &(gTypes[358]) || tp >= &(gTypes[359])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoAliasAttr::static_kind(): - tp = &(gTypes[354]); + tp = &(gTypes[358]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[354]); + PyTypeObject * const tp = &(gTypes[358]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoBuiltinAttr.cpp b/bindings/Python/Generated/AST/NoBuiltinAttr.cpp index a4078b7e4..06be7319e 100644 --- a/bindings/Python/Generated/AST/NoBuiltinAttr.cpp +++ b/bindings/Python/Generated/AST/NoBuiltinAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[71]) || tp >= &(gTypes[72])) { + if (tp < &(gTypes[75]) || tp >= &(gTypes[76])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoBuiltinAttr::static_kind(): - tp = &(gTypes[71]); + tp = &(gTypes[75]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[71]); + PyTypeObject * const tp = &(gTypes[75]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoCommonAttr.cpp b/bindings/Python/Generated/AST/NoCommonAttr.cpp index 99e15e056..c303ac1b9 100644 --- a/bindings/Python/Generated/AST/NoCommonAttr.cpp +++ b/bindings/Python/Generated/AST/NoCommonAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[353]) || tp >= &(gTypes[354])) { + if (tp < &(gTypes[357]) || tp >= &(gTypes[358])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoCommonAttr::static_kind(): - tp = &(gTypes[353]); + tp = &(gTypes[357]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[353]); + PyTypeObject * const tp = &(gTypes[357]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoDebugAttr.cpp b/bindings/Python/Generated/AST/NoDebugAttr.cpp index 2354e43cd..9ab29ff05 100644 --- a/bindings/Python/Generated/AST/NoDebugAttr.cpp +++ b/bindings/Python/Generated/AST/NoDebugAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[352]) || tp >= &(gTypes[353])) { + if (tp < &(gTypes[356]) || tp >= &(gTypes[357])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoDebugAttr::static_kind(): - tp = &(gTypes[352]); + tp = &(gTypes[356]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[352]); + PyTypeObject * const tp = &(gTypes[356]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoDerefAttr.cpp b/bindings/Python/Generated/AST/NoDerefAttr.cpp index 5cfa275a4..da15af490 100644 --- a/bindings/Python/Generated/AST/NoDerefAttr.cpp +++ b/bindings/Python/Generated/AST/NoDerefAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[24]) || tp >= &(gTypes[25])) { + if (tp < &(gTypes[28]) || tp >= &(gTypes[29])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoDerefAttr::static_kind(): - tp = &(gTypes[24]); + tp = &(gTypes[28]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[24]); + PyTypeObject * const tp = &(gTypes[28]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoDestroyAttr.cpp b/bindings/Python/Generated/AST/NoDestroyAttr.cpp index fbbe69c4c..7c29b3f6f 100644 --- a/bindings/Python/Generated/AST/NoDestroyAttr.cpp +++ b/bindings/Python/Generated/AST/NoDestroyAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[351]) || tp >= &(gTypes[352])) { + if (tp < &(gTypes[355]) || tp >= &(gTypes[356])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoDestroyAttr::static_kind(): - tp = &(gTypes[351]); + tp = &(gTypes[355]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[351]); + PyTypeObject * const tp = &(gTypes[355]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoDuplicateAttr.cpp b/bindings/Python/Generated/AST/NoDuplicateAttr.cpp index c0f932137..bb3c4ad31 100644 --- a/bindings/Python/Generated/AST/NoDuplicateAttr.cpp +++ b/bindings/Python/Generated/AST/NoDuplicateAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[350]) || tp >= &(gTypes[351])) { + if (tp < &(gTypes[354]) || tp >= &(gTypes[355])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoDuplicateAttr::static_kind(): - tp = &(gTypes[350]); + tp = &(gTypes[354]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[350]); + PyTypeObject * const tp = &(gTypes[354]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoEscapeAttr.cpp b/bindings/Python/Generated/AST/NoEscapeAttr.cpp index 55abb63fa..41d9d0c8a 100644 --- a/bindings/Python/Generated/AST/NoEscapeAttr.cpp +++ b/bindings/Python/Generated/AST/NoEscapeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[70]) || tp >= &(gTypes[71])) { + if (tp < &(gTypes[74]) || tp >= &(gTypes[75])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoEscapeAttr::static_kind(): - tp = &(gTypes[70]); + tp = &(gTypes[74]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[70]); + PyTypeObject * const tp = &(gTypes[74]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoInitExpr.cpp b/bindings/Python/Generated/AST/NoInitExpr.cpp index 79c0950dd..7f3a85e86 100644 --- a/bindings/Python/Generated/AST/NoInitExpr.cpp +++ b/bindings/Python/Generated/AST/NoInitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[697]) || tp >= &(gTypes[698])) { + if (tp < &(gTypes[701]) || tp >= &(gTypes[702])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoInitExpr::static_kind(): - tp = &(gTypes[697]); + tp = &(gTypes[701]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[697]); + PyTypeObject * const tp = &(gTypes[701]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoInlineAttr.cpp b/bindings/Python/Generated/AST/NoInlineAttr.cpp index 06aed41c0..530a8fad5 100644 --- a/bindings/Python/Generated/AST/NoInlineAttr.cpp +++ b/bindings/Python/Generated/AST/NoInlineAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[118]) || tp >= &(gTypes[119])) { + if (tp < &(gTypes[122]) || tp >= &(gTypes[123])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoInlineAttr::static_kind(): - tp = &(gTypes[118]); + tp = &(gTypes[122]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[118]); + PyTypeObject * const tp = &(gTypes[122]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[114].tp_hash; - tp->tp_richcompare = gTypes[114].tp_richcompare; + tp->tp_hash = gTypes[118].tp_hash; + tp->tp_richcompare = gTypes[118].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[114]); + tp->tp_base = &(gTypes[118]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp b/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp index 89b947491..29dfd520f 100644 --- a/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp +++ b/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[349]) || tp >= &(gTypes[350])) { + if (tp < &(gTypes[353]) || tp >= &(gTypes[354])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoInstrumentFunctionAttr::static_kind(): - tp = &(gTypes[349]); + tp = &(gTypes[353]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[349]); + PyTypeObject * const tp = &(gTypes[353]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoMergeAttr.cpp b/bindings/Python/Generated/AST/NoMergeAttr.cpp index 16e47301d..e8f7fbba9 100644 --- a/bindings/Python/Generated/AST/NoMergeAttr.cpp +++ b/bindings/Python/Generated/AST/NoMergeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[117]) || tp >= &(gTypes[118])) { + if (tp < &(gTypes[121]) || tp >= &(gTypes[122])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoMergeAttr::static_kind(): - tp = &(gTypes[117]); + tp = &(gTypes[121]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[117]); + PyTypeObject * const tp = &(gTypes[121]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[114].tp_hash; - tp->tp_richcompare = gTypes[114].tp_richcompare; + tp->tp_hash = gTypes[118].tp_hash; + tp->tp_richcompare = gTypes[118].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[114]); + tp->tp_base = &(gTypes[118]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp b/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp index a8b7601e8..54a943a82 100644 --- a/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp +++ b/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[348]) || tp >= &(gTypes[349])) { + if (tp < &(gTypes[352]) || tp >= &(gTypes[353])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoMicroMipsAttr::static_kind(): - tp = &(gTypes[348]); + tp = &(gTypes[352]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[348]); + PyTypeObject * const tp = &(gTypes[352]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoMips16Attr.cpp b/bindings/Python/Generated/AST/NoMips16Attr.cpp index 1172c2c6b..0a12b0879 100644 --- a/bindings/Python/Generated/AST/NoMips16Attr.cpp +++ b/bindings/Python/Generated/AST/NoMips16Attr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[347]) || tp >= &(gTypes[348])) { + if (tp < &(gTypes[351]) || tp >= &(gTypes[352])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoMips16Attr::static_kind(): - tp = &(gTypes[347]); + tp = &(gTypes[351]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[347]); + PyTypeObject * const tp = &(gTypes[351]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp b/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp index 242d35610..7d855819c 100644 --- a/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp +++ b/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[346]) || tp >= &(gTypes[347])) { + if (tp < &(gTypes[350]) || tp >= &(gTypes[351])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoProfileFunctionAttr::static_kind(): - tp = &(gTypes[346]); + tp = &(gTypes[350]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[346]); + PyTypeObject * const tp = &(gTypes[350]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp b/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp index d723ea401..de8a120ce 100644 --- a/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp +++ b/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[345]) || tp >= &(gTypes[346])) { + if (tp < &(gTypes[349]) || tp >= &(gTypes[350])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoRandomizeLayoutAttr::static_kind(): - tp = &(gTypes[345]); + tp = &(gTypes[349]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[345]); + PyTypeObject * const tp = &(gTypes[349]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoReturnAttr.cpp b/bindings/Python/Generated/AST/NoReturnAttr.cpp index db4053f61..6271263eb 100644 --- a/bindings/Python/Generated/AST/NoReturnAttr.cpp +++ b/bindings/Python/Generated/AST/NoReturnAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[344]) || tp >= &(gTypes[345])) { + if (tp < &(gTypes[348]) || tp >= &(gTypes[349])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoReturnAttr::static_kind(): - tp = &(gTypes[344]); + tp = &(gTypes[348]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[344]); + PyTypeObject * const tp = &(gTypes[348]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoSanitizeAttr.cpp b/bindings/Python/Generated/AST/NoSanitizeAttr.cpp index c444e8199..04c14a5da 100644 --- a/bindings/Python/Generated/AST/NoSanitizeAttr.cpp +++ b/bindings/Python/Generated/AST/NoSanitizeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[343]) || tp >= &(gTypes[344])) { + if (tp < &(gTypes[347]) || tp >= &(gTypes[348])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoSanitizeAttr::static_kind(): - tp = &(gTypes[343]); + tp = &(gTypes[347]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[343]); + PyTypeObject * const tp = &(gTypes[347]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp b/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp index 7f61b278b..2521293ef 100644 --- a/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp +++ b/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[342]) || tp >= &(gTypes[343])) { + if (tp < &(gTypes[346]) || tp >= &(gTypes[347])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoSpeculativeLoadHardeningAttr::static_kind(): - tp = &(gTypes[342]); + tp = &(gTypes[346]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[342]); + PyTypeObject * const tp = &(gTypes[346]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoSplitStackAttr.cpp b/bindings/Python/Generated/AST/NoSplitStackAttr.cpp index b518adfcb..136756a0e 100644 --- a/bindings/Python/Generated/AST/NoSplitStackAttr.cpp +++ b/bindings/Python/Generated/AST/NoSplitStackAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[341]) || tp >= &(gTypes[342])) { + if (tp < &(gTypes[345]) || tp >= &(gTypes[346])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoSplitStackAttr::static_kind(): - tp = &(gTypes[341]); + tp = &(gTypes[345]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[341]); + PyTypeObject * const tp = &(gTypes[345]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp b/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp index 93e6bc2e4..33b00e88e 100644 --- a/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp +++ b/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[340]) || tp >= &(gTypes[341])) { + if (tp < &(gTypes[344]) || tp >= &(gTypes[345])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoStackProtectorAttr::static_kind(): - tp = &(gTypes[340]); + tp = &(gTypes[344]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[340]); + PyTypeObject * const tp = &(gTypes[344]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp b/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp index 5c1dd0c0e..02594205d 100644 --- a/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp +++ b/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[339]) || tp >= &(gTypes[340])) { + if (tp < &(gTypes[343]) || tp >= &(gTypes[344])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoThreadSafetyAnalysisAttr::static_kind(): - tp = &(gTypes[339]); + tp = &(gTypes[343]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[339]); + PyTypeObject * const tp = &(gTypes[343]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoThrowAttr.cpp b/bindings/Python/Generated/AST/NoThrowAttr.cpp index e36db6e40..cef7936ee 100644 --- a/bindings/Python/Generated/AST/NoThrowAttr.cpp +++ b/bindings/Python/Generated/AST/NoThrowAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[338]) || tp >= &(gTypes[339])) { + if (tp < &(gTypes[342]) || tp >= &(gTypes[343])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoThrowAttr::static_kind(): - tp = &(gTypes[338]); + tp = &(gTypes[342]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[338]); + PyTypeObject * const tp = &(gTypes[342]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp b/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp index 0817c3e49..0d850f6e5 100644 --- a/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp +++ b/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[337]) || tp >= &(gTypes[338])) { + if (tp < &(gTypes[341]) || tp >= &(gTypes[342])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoUniqueAddressAttr::static_kind(): - tp = &(gTypes[337]); + tp = &(gTypes[341]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[337]); + PyTypeObject * const tp = &(gTypes[341]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NoUwtableAttr.cpp b/bindings/Python/Generated/AST/NoUwtableAttr.cpp index 626e68f29..4b709fa0e 100644 --- a/bindings/Python/Generated/AST/NoUwtableAttr.cpp +++ b/bindings/Python/Generated/AST/NoUwtableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[336]) || tp >= &(gTypes[337])) { + if (tp < &(gTypes[340]) || tp >= &(gTypes[341])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NoUwtableAttr::static_kind(): - tp = &(gTypes[336]); + tp = &(gTypes[340]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[336]); + PyTypeObject * const tp = &(gTypes[340]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NonNullAttr.cpp b/bindings/Python/Generated/AST/NonNullAttr.cpp index 157623ce4..0fcfe6f96 100644 --- a/bindings/Python/Generated/AST/NonNullAttr.cpp +++ b/bindings/Python/Generated/AST/NonNullAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[405]) || tp >= &(gTypes[406])) { + if (tp < &(gTypes[409]) || tp >= &(gTypes[410])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NonNullAttr::static_kind(): - tp = &(gTypes[405]); + tp = &(gTypes[409]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[405]); + PyTypeObject * const tp = &(gTypes[409]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp b/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp index 77f998fce..a031ebc76 100644 --- a/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp +++ b/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[760]) || tp >= &(gTypes[761])) { + if (tp < &(gTypes[764]) || tp >= &(gTypes[765])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NonTypeTemplateParmDecl::static_kind(): - tp = &(gTypes[760]); + tp = &(gTypes[764]); break; } @@ -449,7 +449,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -501,7 +501,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[760]); + PyTypeObject * const tp = &(gTypes[764]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -516,12 +516,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[752].tp_hash; - tp->tp_richcompare = gTypes[752].tp_richcompare; + tp->tp_hash = gTypes[756].tp_hash; + tp->tp_richcompare = gTypes[756].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[752]); + tp->tp_base = &(gTypes[756]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NotTailCalledAttr.cpp b/bindings/Python/Generated/AST/NotTailCalledAttr.cpp index 38ca29dfd..728957295 100644 --- a/bindings/Python/Generated/AST/NotTailCalledAttr.cpp +++ b/bindings/Python/Generated/AST/NotTailCalledAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[335]) || tp >= &(gTypes[336])) { + if (tp < &(gTypes[339]) || tp >= &(gTypes[340])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NotTailCalledAttr::static_kind(): - tp = &(gTypes[335]); + tp = &(gTypes[339]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[335]); + PyTypeObject * const tp = &(gTypes[339]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/NullStmt.cpp b/bindings/Python/Generated/AST/NullStmt.cpp index 5b8de73c9..42382a029 100644 --- a/bindings/Python/Generated/AST/NullStmt.cpp +++ b/bindings/Python/Generated/AST/NullStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[563]) || tp >= &(gTypes[564])) { + if (tp < &(gTypes[567]) || tp >= &(gTypes[568])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::NullStmt::static_kind(): - tp = &(gTypes[563]); + tp = &(gTypes[567]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[563]); + PyTypeObject * const tp = &(gTypes[567]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPAllocateDecl.cpp b/bindings/Python/Generated/AST/OMPAllocateDecl.cpp index 405426b45..28eb6d502 100644 --- a/bindings/Python/Generated/AST/OMPAllocateDecl.cpp +++ b/bindings/Python/Generated/AST/OMPAllocateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[730]) || tp >= &(gTypes[731])) { + if (tp < &(gTypes[734]) || tp >= &(gTypes[735])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPAllocateDecl::static_kind(): - tp = &(gTypes[730]); + tp = &(gTypes[734]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[730]); + PyTypeObject * const tp = &(gTypes[734]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[727].tp_hash; - tp->tp_richcompare = gTypes[727].tp_richcompare; + tp->tp_hash = gTypes[731].tp_hash; + tp->tp_richcompare = gTypes[731].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[727]); + tp->tp_base = &(gTypes[731]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp b/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp index e7ef39580..c0898948a 100644 --- a/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp +++ b/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[334]) || tp >= &(gTypes[335])) { + if (tp < &(gTypes[338]) || tp >= &(gTypes[339])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPAllocateDeclAttr::static_kind(): - tp = &(gTypes[334]); + tp = &(gTypes[338]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[334]); + PyTypeObject * const tp = &(gTypes[338]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp b/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp index ad21bec10..ef87fb90b 100644 --- a/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp +++ b/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[696]) || tp >= &(gTypes[697])) { + if (tp < &(gTypes[700]) || tp >= &(gTypes[701])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPArraySectionExpr::static_kind(): - tp = &(gTypes[696]); + tp = &(gTypes[700]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[696]); + PyTypeObject * const tp = &(gTypes[700]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp b/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp index d2423d79c..3610fc270 100644 --- a/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp +++ b/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[695]) || tp >= &(gTypes[696])) { + if (tp < &(gTypes[699]) || tp >= &(gTypes[700])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPArrayShapingExpr::static_kind(): - tp = &(gTypes[695]); + tp = &(gTypes[699]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[695]); + PyTypeObject * const tp = &(gTypes[699]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPAtomicDirective.cpp b/bindings/Python/Generated/AST/OMPAtomicDirective.cpp index f1231d6ec..04501af3d 100644 --- a/bindings/Python/Generated/AST/OMPAtomicDirective.cpp +++ b/bindings/Python/Generated/AST/OMPAtomicDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[494]) || tp >= &(gTypes[495])) { + if (tp < &(gTypes[498]) || tp >= &(gTypes[499])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPAtomicDirective::static_kind(): - tp = &(gTypes[494]); + tp = &(gTypes[498]); break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -449,7 +449,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[494]); + PyTypeObject * const tp = &(gTypes[498]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -464,12 +464,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPBarrierDirective.cpp b/bindings/Python/Generated/AST/OMPBarrierDirective.cpp index 5df2c252a..6f8dc9593 100644 --- a/bindings/Python/Generated/AST/OMPBarrierDirective.cpp +++ b/bindings/Python/Generated/AST/OMPBarrierDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[493]) || tp >= &(gTypes[494])) { + if (tp < &(gTypes[497]) || tp >= &(gTypes[498])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPBarrierDirective::static_kind(): - tp = &(gTypes[493]); + tp = &(gTypes[497]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[493]); + PyTypeObject * const tp = &(gTypes[497]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPCancelDirective.cpp b/bindings/Python/Generated/AST/OMPCancelDirective.cpp index 8b5353458..ca8220255 100644 --- a/bindings/Python/Generated/AST/OMPCancelDirective.cpp +++ b/bindings/Python/Generated/AST/OMPCancelDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[492]) || tp >= &(gTypes[493])) { + if (tp < &(gTypes[496]) || tp >= &(gTypes[497])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPCancelDirective::static_kind(): - tp = &(gTypes[492]); + tp = &(gTypes[496]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[492]); + PyTypeObject * const tp = &(gTypes[496]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp b/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp index e3545c780..c86a78803 100644 --- a/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp +++ b/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[491]) || tp >= &(gTypes[492])) { + if (tp < &(gTypes[495]) || tp >= &(gTypes[496])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPCancellationPointDirective::static_kind(): - tp = &(gTypes[491]); + tp = &(gTypes[495]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[491]); + PyTypeObject * const tp = &(gTypes[495]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp b/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp index bfbffbd7d..0d98dd519 100644 --- a/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp +++ b/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[562]) || tp >= &(gTypes[563])) { + if (tp < &(gTypes[566]) || tp >= &(gTypes[567])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPCanonicalLoop::static_kind(): - tp = &(gTypes[562]); + tp = &(gTypes[566]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[562]); + PyTypeObject * const tp = &(gTypes[566]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp b/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp index 2c801a25a..4cc8f0f62 100644 --- a/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp +++ b/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[69]) || tp >= &(gTypes[70])) { + if (tp < &(gTypes[73]) || tp >= &(gTypes[74])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPCaptureKindAttr::static_kind(): - tp = &(gTypes[69]); + tp = &(gTypes[73]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[69]); + PyTypeObject * const tp = &(gTypes[73]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp b/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp index 313086b6e..051311d4c 100644 --- a/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp +++ b/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[333]) || tp >= &(gTypes[334])) { + if (tp < &(gTypes[337]) || tp >= &(gTypes[338])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPCaptureNoInitAttr::static_kind(): - tp = &(gTypes[333]); + tp = &(gTypes[337]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[333]); + PyTypeObject * const tp = &(gTypes[337]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp b/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp index 953cb118c..edd6577cf 100644 --- a/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp +++ b/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[755]) || tp >= &(gTypes[756])) { + if (tp < &(gTypes[759]) || tp >= &(gTypes[760])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPCapturedExprDecl::static_kind(): - tp = &(gTypes[755]); + tp = &(gTypes[759]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[755]); + PyTypeObject * const tp = &(gTypes[759]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[753].tp_hash; - tp->tp_richcompare = gTypes[753].tp_richcompare; + tp->tp_hash = gTypes[757].tp_hash; + tp->tp_richcompare = gTypes[757].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[753]); + tp->tp_base = &(gTypes[757]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPCriticalDirective.cpp b/bindings/Python/Generated/AST/OMPCriticalDirective.cpp index 1d35be249..38a440faf 100644 --- a/bindings/Python/Generated/AST/OMPCriticalDirective.cpp +++ b/bindings/Python/Generated/AST/OMPCriticalDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[490]) || tp >= &(gTypes[491])) { + if (tp < &(gTypes[494]) || tp >= &(gTypes[495])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPCriticalDirective::static_kind(): - tp = &(gTypes[490]); + tp = &(gTypes[494]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[490]); + PyTypeObject * const tp = &(gTypes[494]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp index 8182d8546..4f07d1173 100644 --- a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp +++ b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[727]) || tp >= &(gTypes[731])) { + if (tp < &(gTypes[731]) || tp >= &(gTypes[735])) { return std::nullopt; } @@ -88,15 +88,15 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPThreadPrivateDecl::static_kind(): - tp = &(gTypes[728]); + tp = &(gTypes[732]); break; case mx::OMPRequiresDecl::static_kind(): - tp = &(gTypes[729]); + tp = &(gTypes[733]); break; case mx::OMPAllocateDecl::static_kind(): - tp = &(gTypes[730]); + tp = &(gTypes[734]); break; } @@ -340,7 +340,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -370,7 +370,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[727]); + PyTypeObject * const tp = &(gTypes[731]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -385,12 +385,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp index a0045d92d..062a4cc6f 100644 --- a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp +++ b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[772]) || tp >= &(gTypes[774])) { + if (tp < &(gTypes[776]) || tp >= &(gTypes[778])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDeclareMapperDecl::static_kind(): - tp = &(gTypes[773]); + tp = &(gTypes[777]); break; } @@ -332,7 +332,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -362,7 +362,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[772]); + PyTypeObject * const tp = &(gTypes[776]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -377,12 +377,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp b/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp index 6d33e0384..918f25b2c 100644 --- a/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp +++ b/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[773]) || tp >= &(gTypes[774])) { + if (tp < &(gTypes[777]) || tp >= &(gTypes[778])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDeclareMapperDecl::static_kind(): - tp = &(gTypes[773]); + tp = &(gTypes[777]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[773]); + PyTypeObject * const tp = &(gTypes[777]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[772].tp_hash; - tp->tp_richcompare = gTypes[772].tp_richcompare; + tp->tp_hash = gTypes[776].tp_hash; + tp->tp_richcompare = gTypes[776].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[772]); + tp->tp_base = &(gTypes[776]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp b/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp index 123caf9a5..07ea2b225 100644 --- a/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp +++ b/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[748]) || tp >= &(gTypes[749])) { + if (tp < &(gTypes[752]) || tp >= &(gTypes[753])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDeclareReductionDecl::static_kind(): - tp = &(gTypes[748]); + tp = &(gTypes[752]); break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[748]); + PyTypeObject * const tp = &(gTypes[752]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -474,12 +474,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp b/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp index e7e82c2a6..2fca3437c 100644 --- a/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp +++ b/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[68]) || tp >= &(gTypes[69])) { + if (tp < &(gTypes[72]) || tp >= &(gTypes[73])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDeclareSimdDeclAttr::static_kind(): - tp = &(gTypes[68]); + tp = &(gTypes[72]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[68]); + PyTypeObject * const tp = &(gTypes[72]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp b/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp index 32b0d3d1c..915f4b49d 100644 --- a/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp +++ b/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[332]) || tp >= &(gTypes[333])) { + if (tp < &(gTypes[336]) || tp >= &(gTypes[337])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDeclareTargetDeclAttr::static_kind(): - tp = &(gTypes[332]); + tp = &(gTypes[336]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -381,7 +381,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[332]); + PyTypeObject * const tp = &(gTypes[336]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -396,12 +396,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp b/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp index 8181c241f..572a449ad 100644 --- a/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp +++ b/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[331]) || tp >= &(gTypes[332])) { + if (tp < &(gTypes[335]) || tp >= &(gTypes[336])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDeclareVariantAttr::static_kind(): - tp = &(gTypes[331]); + tp = &(gTypes[335]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[331]); + PyTypeObject * const tp = &(gTypes[335]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDepobjDirective.cpp b/bindings/Python/Generated/AST/OMPDepobjDirective.cpp index 26ef75d0e..afa226cab 100644 --- a/bindings/Python/Generated/AST/OMPDepobjDirective.cpp +++ b/bindings/Python/Generated/AST/OMPDepobjDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[489]) || tp >= &(gTypes[490])) { + if (tp < &(gTypes[493]) || tp >= &(gTypes[494])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDepobjDirective::static_kind(): - tp = &(gTypes[489]); + tp = &(gTypes[493]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[489]); + PyTypeObject * const tp = &(gTypes[493]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDispatchDirective.cpp b/bindings/Python/Generated/AST/OMPDispatchDirective.cpp index 1d730b8ea..f9cb4cafb 100644 --- a/bindings/Python/Generated/AST/OMPDispatchDirective.cpp +++ b/bindings/Python/Generated/AST/OMPDispatchDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[488]) || tp >= &(gTypes[489])) { + if (tp < &(gTypes[492]) || tp >= &(gTypes[493])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDispatchDirective::static_kind(): - tp = &(gTypes[488]); + tp = &(gTypes[492]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[488]); + PyTypeObject * const tp = &(gTypes[492]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDistributeDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeDirective.cpp index 281fa7f3e..2af991fe7 100644 --- a/bindings/Python/Generated/AST/OMPDistributeDirective.cpp +++ b/bindings/Python/Generated/AST/OMPDistributeDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[531]) || tp >= &(gTypes[532])) { + if (tp < &(gTypes[535]) || tp >= &(gTypes[536])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDistributeDirective::static_kind(): - tp = &(gTypes[531]); + tp = &(gTypes[535]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[531]); + PyTypeObject * const tp = &(gTypes[535]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp index 7e05dc9a5..c4c648ef5 100644 --- a/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp +++ b/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[530]) || tp >= &(gTypes[531])) { + if (tp < &(gTypes[534]) || tp >= &(gTypes[535])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDistributeParallelForDirective::static_kind(): - tp = &(gTypes[530]); + tp = &(gTypes[534]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[530]); + PyTypeObject * const tp = &(gTypes[534]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp index d0360e1fb..dae29fc21 100644 --- a/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[529]) || tp >= &(gTypes[530])) { + if (tp < &(gTypes[533]) || tp >= &(gTypes[534])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[529]); + tp = &(gTypes[533]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[529]); + PyTypeObject * const tp = &(gTypes[533]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp index ade273c6f..dcf65b660 100644 --- a/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[528]) || tp >= &(gTypes[529])) { + if (tp < &(gTypes[532]) || tp >= &(gTypes[533])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPDistributeSimdDirective::static_kind(): - tp = &(gTypes[528]); + tp = &(gTypes[532]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[528]); + PyTypeObject * const tp = &(gTypes[532]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPErrorDirective.cpp b/bindings/Python/Generated/AST/OMPErrorDirective.cpp index 2a0608b36..094fbc1a0 100644 --- a/bindings/Python/Generated/AST/OMPErrorDirective.cpp +++ b/bindings/Python/Generated/AST/OMPErrorDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[487]) || tp >= &(gTypes[488])) { + if (tp < &(gTypes[491]) || tp >= &(gTypes[492])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPErrorDirective::static_kind(): - tp = &(gTypes[487]); + tp = &(gTypes[491]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[487]); + PyTypeObject * const tp = &(gTypes[491]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPExecutableDirective.cpp b/bindings/Python/Generated/AST/OMPExecutableDirective.cpp index 2fcab1cec..b79f1164b 100644 --- a/bindings/Python/Generated/AST/OMPExecutableDirective.cpp +++ b/bindings/Python/Generated/AST/OMPExecutableDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[486]) || tp >= &(gTypes[562])) { + if (tp < &(gTypes[490]) || tp >= &(gTypes[566])) { return std::nullopt; } @@ -88,291 +88,291 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPErrorDirective::static_kind(): - tp = &(gTypes[487]); + tp = &(gTypes[491]); break; case mx::OMPDispatchDirective::static_kind(): - tp = &(gTypes[488]); + tp = &(gTypes[492]); break; case mx::OMPDepobjDirective::static_kind(): - tp = &(gTypes[489]); + tp = &(gTypes[493]); break; case mx::OMPCriticalDirective::static_kind(): - tp = &(gTypes[490]); + tp = &(gTypes[494]); break; case mx::OMPCancellationPointDirective::static_kind(): - tp = &(gTypes[491]); + tp = &(gTypes[495]); break; case mx::OMPCancelDirective::static_kind(): - tp = &(gTypes[492]); + tp = &(gTypes[496]); break; case mx::OMPBarrierDirective::static_kind(): - tp = &(gTypes[493]); + tp = &(gTypes[497]); break; case mx::OMPAtomicDirective::static_kind(): - tp = &(gTypes[494]); + tp = &(gTypes[498]); break; case mx::OMPTeamsDirective::static_kind(): - tp = &(gTypes[495]); + tp = &(gTypes[499]); break; case mx::OMPTaskyieldDirective::static_kind(): - tp = &(gTypes[496]); + tp = &(gTypes[500]); break; case mx::OMPTaskwaitDirective::static_kind(): - tp = &(gTypes[497]); + tp = &(gTypes[501]); break; case mx::OMPTaskgroupDirective::static_kind(): - tp = &(gTypes[498]); + tp = &(gTypes[502]); break; case mx::OMPTaskDirective::static_kind(): - tp = &(gTypes[499]); + tp = &(gTypes[503]); break; case mx::OMPTargetUpdateDirective::static_kind(): - tp = &(gTypes[500]); + tp = &(gTypes[504]); break; case mx::OMPTargetTeamsDirective::static_kind(): - tp = &(gTypes[501]); + tp = &(gTypes[505]); break; case mx::OMPTargetParallelDirective::static_kind(): - tp = &(gTypes[502]); + tp = &(gTypes[506]); break; case mx::OMPTargetExitDataDirective::static_kind(): - tp = &(gTypes[503]); + tp = &(gTypes[507]); break; case mx::OMPTargetEnterDataDirective::static_kind(): - tp = &(gTypes[504]); + tp = &(gTypes[508]); break; case mx::OMPTargetDirective::static_kind(): - tp = &(gTypes[505]); + tp = &(gTypes[509]); break; case mx::OMPTargetDataDirective::static_kind(): - tp = &(gTypes[506]); + tp = &(gTypes[510]); break; case mx::OMPSingleDirective::static_kind(): - tp = &(gTypes[507]); + tp = &(gTypes[511]); break; case mx::OMPSectionsDirective::static_kind(): - tp = &(gTypes[508]); + tp = &(gTypes[512]); break; case mx::OMPSectionDirective::static_kind(): - tp = &(gTypes[509]); + tp = &(gTypes[513]); break; case mx::OMPScopeDirective::static_kind(): - tp = &(gTypes[510]); + tp = &(gTypes[514]); break; case mx::OMPScanDirective::static_kind(): - tp = &(gTypes[511]); + tp = &(gTypes[515]); break; case mx::OMPParallelSectionsDirective::static_kind(): - tp = &(gTypes[512]); + tp = &(gTypes[516]); break; case mx::OMPParallelMasterDirective::static_kind(): - tp = &(gTypes[513]); + tp = &(gTypes[517]); break; case mx::OMPParallelMaskedDirective::static_kind(): - tp = &(gTypes[514]); + tp = &(gTypes[518]); break; case mx::OMPParallelDirective::static_kind(): - tp = &(gTypes[515]); + tp = &(gTypes[519]); break; case mx::OMPOrderedDirective::static_kind(): - tp = &(gTypes[516]); + tp = &(gTypes[520]); break; case mx::OMPMetaDirective::static_kind(): - tp = &(gTypes[517]); + tp = &(gTypes[521]); break; case mx::OMPMasterDirective::static_kind(): - tp = &(gTypes[518]); + tp = &(gTypes[522]); break; case mx::OMPMaskedDirective::static_kind(): - tp = &(gTypes[519]); + tp = &(gTypes[523]); break; case mx::OMPUnrollDirective::static_kind(): - tp = &(gTypes[522]); + tp = &(gTypes[526]); break; case mx::OMPTileDirective::static_kind(): - tp = &(gTypes[523]); + tp = &(gTypes[527]); break; case mx::OMPGenericLoopDirective::static_kind(): - tp = &(gTypes[525]); + tp = &(gTypes[529]); break; case mx::OMPForSimdDirective::static_kind(): - tp = &(gTypes[526]); + tp = &(gTypes[530]); break; case mx::OMPForDirective::static_kind(): - tp = &(gTypes[527]); + tp = &(gTypes[531]); break; case mx::OMPDistributeSimdDirective::static_kind(): - tp = &(gTypes[528]); + tp = &(gTypes[532]); break; case mx::OMPDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[529]); + tp = &(gTypes[533]); break; case mx::OMPDistributeParallelForDirective::static_kind(): - tp = &(gTypes[530]); + tp = &(gTypes[534]); break; case mx::OMPDistributeDirective::static_kind(): - tp = &(gTypes[531]); + tp = &(gTypes[535]); break; case mx::OMPTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[532]); + tp = &(gTypes[536]); break; case mx::OMPTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[533]); + tp = &(gTypes[537]); break; case mx::OMPTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[534]); + tp = &(gTypes[538]); break; case mx::OMPTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[535]); + tp = &(gTypes[539]); break; case mx::OMPTeamsDistributeDirective::static_kind(): - tp = &(gTypes[536]); + tp = &(gTypes[540]); break; case mx::OMPTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[537]); + tp = &(gTypes[541]); break; case mx::OMPTaskLoopDirective::static_kind(): - tp = &(gTypes[538]); + tp = &(gTypes[542]); break; case mx::OMPTargetTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[539]); + tp = &(gTypes[543]); break; case mx::OMPTargetTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[540]); + tp = &(gTypes[544]); break; case mx::OMPTargetTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[541]); + tp = &(gTypes[545]); break; case mx::OMPTargetTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[542]); + tp = &(gTypes[546]); break; case mx::OMPTargetTeamsDistributeDirective::static_kind(): - tp = &(gTypes[543]); + tp = &(gTypes[547]); break; case mx::OMPTargetSimdDirective::static_kind(): - tp = &(gTypes[544]); + tp = &(gTypes[548]); break; case mx::OMPTargetParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[545]); + tp = &(gTypes[549]); break; case mx::OMPTargetParallelForSimdDirective::static_kind(): - tp = &(gTypes[546]); + tp = &(gTypes[550]); break; case mx::OMPTargetParallelForDirective::static_kind(): - tp = &(gTypes[547]); + tp = &(gTypes[551]); break; case mx::OMPSimdDirective::static_kind(): - tp = &(gTypes[548]); + tp = &(gTypes[552]); break; case mx::OMPParallelMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[549]); + tp = &(gTypes[553]); break; case mx::OMPParallelMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[550]); + tp = &(gTypes[554]); break; case mx::OMPParallelMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[551]); + tp = &(gTypes[555]); break; case mx::OMPParallelMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[552]); + tp = &(gTypes[556]); break; case mx::OMPParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[553]); + tp = &(gTypes[557]); break; case mx::OMPParallelForSimdDirective::static_kind(): - tp = &(gTypes[554]); + tp = &(gTypes[558]); break; case mx::OMPParallelForDirective::static_kind(): - tp = &(gTypes[555]); + tp = &(gTypes[559]); break; case mx::OMPMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[556]); + tp = &(gTypes[560]); break; case mx::OMPMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[557]); + tp = &(gTypes[561]); break; case mx::OMPMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[558]); + tp = &(gTypes[562]); break; case mx::OMPMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[559]); + tp = &(gTypes[563]); break; case mx::OMPInteropDirective::static_kind(): - tp = &(gTypes[560]); + tp = &(gTypes[564]); break; case mx::OMPFlushDirective::static_kind(): - tp = &(gTypes[561]); + tp = &(gTypes[565]); break; } @@ -646,7 +646,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -676,7 +676,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[486]); + PyTypeObject * const tp = &(gTypes[490]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -691,12 +691,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPFlushDirective.cpp b/bindings/Python/Generated/AST/OMPFlushDirective.cpp index 51d906daf..d7513e4ae 100644 --- a/bindings/Python/Generated/AST/OMPFlushDirective.cpp +++ b/bindings/Python/Generated/AST/OMPFlushDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[561]) || tp >= &(gTypes[562])) { + if (tp < &(gTypes[565]) || tp >= &(gTypes[566])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPFlushDirective::static_kind(): - tp = &(gTypes[561]); + tp = &(gTypes[565]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[561]); + PyTypeObject * const tp = &(gTypes[565]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPForDirective.cpp b/bindings/Python/Generated/AST/OMPForDirective.cpp index 74d574ae9..31b63b88f 100644 --- a/bindings/Python/Generated/AST/OMPForDirective.cpp +++ b/bindings/Python/Generated/AST/OMPForDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[527]) || tp >= &(gTypes[528])) { + if (tp < &(gTypes[531]) || tp >= &(gTypes[532])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPForDirective::static_kind(): - tp = &(gTypes[527]); + tp = &(gTypes[531]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[527]); + PyTypeObject * const tp = &(gTypes[531]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPForSimdDirective.cpp index 7aa2fd864..79ba31919 100644 --- a/bindings/Python/Generated/AST/OMPForSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPForSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[526]) || tp >= &(gTypes[527])) { + if (tp < &(gTypes[530]) || tp >= &(gTypes[531])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPForSimdDirective::static_kind(): - tp = &(gTypes[526]); + tp = &(gTypes[530]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[526]); + PyTypeObject * const tp = &(gTypes[530]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp index 2b62003a2..f3421d641 100644 --- a/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[525]) || tp >= &(gTypes[526])) { + if (tp < &(gTypes[529]) || tp >= &(gTypes[530])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPGenericLoopDirective::static_kind(): - tp = &(gTypes[525]); + tp = &(gTypes[529]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[525]); + PyTypeObject * const tp = &(gTypes[529]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPInteropDirective.cpp b/bindings/Python/Generated/AST/OMPInteropDirective.cpp index 282547288..c916917a9 100644 --- a/bindings/Python/Generated/AST/OMPInteropDirective.cpp +++ b/bindings/Python/Generated/AST/OMPInteropDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[560]) || tp >= &(gTypes[561])) { + if (tp < &(gTypes[564]) || tp >= &(gTypes[565])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPInteropDirective::static_kind(): - tp = &(gTypes[560]); + tp = &(gTypes[564]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[560]); + PyTypeObject * const tp = &(gTypes[564]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPIteratorExpr.cpp b/bindings/Python/Generated/AST/OMPIteratorExpr.cpp index 76a1616f3..e71b3a2c5 100644 --- a/bindings/Python/Generated/AST/OMPIteratorExpr.cpp +++ b/bindings/Python/Generated/AST/OMPIteratorExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[694]) || tp >= &(gTypes[695])) { + if (tp < &(gTypes[698]) || tp >= &(gTypes[699])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPIteratorExpr::static_kind(): - tp = &(gTypes[694]); + tp = &(gTypes[698]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[694]); + PyTypeObject * const tp = &(gTypes[698]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp b/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp index 3443bd107..50abdea97 100644 --- a/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp +++ b/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[520]) || tp >= &(gTypes[560])) { + if (tp < &(gTypes[524]) || tp >= &(gTypes[564])) { return std::nullopt; } @@ -88,151 +88,151 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPUnrollDirective::static_kind(): - tp = &(gTypes[522]); + tp = &(gTypes[526]); break; case mx::OMPTileDirective::static_kind(): - tp = &(gTypes[523]); + tp = &(gTypes[527]); break; case mx::OMPGenericLoopDirective::static_kind(): - tp = &(gTypes[525]); + tp = &(gTypes[529]); break; case mx::OMPForSimdDirective::static_kind(): - tp = &(gTypes[526]); + tp = &(gTypes[530]); break; case mx::OMPForDirective::static_kind(): - tp = &(gTypes[527]); + tp = &(gTypes[531]); break; case mx::OMPDistributeSimdDirective::static_kind(): - tp = &(gTypes[528]); + tp = &(gTypes[532]); break; case mx::OMPDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[529]); + tp = &(gTypes[533]); break; case mx::OMPDistributeParallelForDirective::static_kind(): - tp = &(gTypes[530]); + tp = &(gTypes[534]); break; case mx::OMPDistributeDirective::static_kind(): - tp = &(gTypes[531]); + tp = &(gTypes[535]); break; case mx::OMPTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[532]); + tp = &(gTypes[536]); break; case mx::OMPTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[533]); + tp = &(gTypes[537]); break; case mx::OMPTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[534]); + tp = &(gTypes[538]); break; case mx::OMPTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[535]); + tp = &(gTypes[539]); break; case mx::OMPTeamsDistributeDirective::static_kind(): - tp = &(gTypes[536]); + tp = &(gTypes[540]); break; case mx::OMPTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[537]); + tp = &(gTypes[541]); break; case mx::OMPTaskLoopDirective::static_kind(): - tp = &(gTypes[538]); + tp = &(gTypes[542]); break; case mx::OMPTargetTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[539]); + tp = &(gTypes[543]); break; case mx::OMPTargetTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[540]); + tp = &(gTypes[544]); break; case mx::OMPTargetTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[541]); + tp = &(gTypes[545]); break; case mx::OMPTargetTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[542]); + tp = &(gTypes[546]); break; case mx::OMPTargetTeamsDistributeDirective::static_kind(): - tp = &(gTypes[543]); + tp = &(gTypes[547]); break; case mx::OMPTargetSimdDirective::static_kind(): - tp = &(gTypes[544]); + tp = &(gTypes[548]); break; case mx::OMPTargetParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[545]); + tp = &(gTypes[549]); break; case mx::OMPTargetParallelForSimdDirective::static_kind(): - tp = &(gTypes[546]); + tp = &(gTypes[550]); break; case mx::OMPTargetParallelForDirective::static_kind(): - tp = &(gTypes[547]); + tp = &(gTypes[551]); break; case mx::OMPSimdDirective::static_kind(): - tp = &(gTypes[548]); + tp = &(gTypes[552]); break; case mx::OMPParallelMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[549]); + tp = &(gTypes[553]); break; case mx::OMPParallelMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[550]); + tp = &(gTypes[554]); break; case mx::OMPParallelMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[551]); + tp = &(gTypes[555]); break; case mx::OMPParallelMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[552]); + tp = &(gTypes[556]); break; case mx::OMPParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[553]); + tp = &(gTypes[557]); break; case mx::OMPParallelForSimdDirective::static_kind(): - tp = &(gTypes[554]); + tp = &(gTypes[558]); break; case mx::OMPParallelForDirective::static_kind(): - tp = &(gTypes[555]); + tp = &(gTypes[559]); break; case mx::OMPMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[556]); + tp = &(gTypes[560]); break; case mx::OMPMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[557]); + tp = &(gTypes[561]); break; case mx::OMPMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[558]); + tp = &(gTypes[562]); break; case mx::OMPMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[559]); + tp = &(gTypes[563]); break; } @@ -456,7 +456,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -486,7 +486,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[520]); + PyTypeObject * const tp = &(gTypes[524]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -501,12 +501,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPLoopDirective.cpp b/bindings/Python/Generated/AST/OMPLoopDirective.cpp index 5097617d7..7e2e7ebe0 100644 --- a/bindings/Python/Generated/AST/OMPLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[524]) || tp >= &(gTypes[560])) { + if (tp < &(gTypes[528]) || tp >= &(gTypes[564])) { return std::nullopt; } @@ -88,143 +88,143 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPGenericLoopDirective::static_kind(): - tp = &(gTypes[525]); + tp = &(gTypes[529]); break; case mx::OMPForSimdDirective::static_kind(): - tp = &(gTypes[526]); + tp = &(gTypes[530]); break; case mx::OMPForDirective::static_kind(): - tp = &(gTypes[527]); + tp = &(gTypes[531]); break; case mx::OMPDistributeSimdDirective::static_kind(): - tp = &(gTypes[528]); + tp = &(gTypes[532]); break; case mx::OMPDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[529]); + tp = &(gTypes[533]); break; case mx::OMPDistributeParallelForDirective::static_kind(): - tp = &(gTypes[530]); + tp = &(gTypes[534]); break; case mx::OMPDistributeDirective::static_kind(): - tp = &(gTypes[531]); + tp = &(gTypes[535]); break; case mx::OMPTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[532]); + tp = &(gTypes[536]); break; case mx::OMPTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[533]); + tp = &(gTypes[537]); break; case mx::OMPTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[534]); + tp = &(gTypes[538]); break; case mx::OMPTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[535]); + tp = &(gTypes[539]); break; case mx::OMPTeamsDistributeDirective::static_kind(): - tp = &(gTypes[536]); + tp = &(gTypes[540]); break; case mx::OMPTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[537]); + tp = &(gTypes[541]); break; case mx::OMPTaskLoopDirective::static_kind(): - tp = &(gTypes[538]); + tp = &(gTypes[542]); break; case mx::OMPTargetTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[539]); + tp = &(gTypes[543]); break; case mx::OMPTargetTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[540]); + tp = &(gTypes[544]); break; case mx::OMPTargetTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[541]); + tp = &(gTypes[545]); break; case mx::OMPTargetTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[542]); + tp = &(gTypes[546]); break; case mx::OMPTargetTeamsDistributeDirective::static_kind(): - tp = &(gTypes[543]); + tp = &(gTypes[547]); break; case mx::OMPTargetSimdDirective::static_kind(): - tp = &(gTypes[544]); + tp = &(gTypes[548]); break; case mx::OMPTargetParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[545]); + tp = &(gTypes[549]); break; case mx::OMPTargetParallelForSimdDirective::static_kind(): - tp = &(gTypes[546]); + tp = &(gTypes[550]); break; case mx::OMPTargetParallelForDirective::static_kind(): - tp = &(gTypes[547]); + tp = &(gTypes[551]); break; case mx::OMPSimdDirective::static_kind(): - tp = &(gTypes[548]); + tp = &(gTypes[552]); break; case mx::OMPParallelMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[549]); + tp = &(gTypes[553]); break; case mx::OMPParallelMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[550]); + tp = &(gTypes[554]); break; case mx::OMPParallelMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[551]); + tp = &(gTypes[555]); break; case mx::OMPParallelMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[552]); + tp = &(gTypes[556]); break; case mx::OMPParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[553]); + tp = &(gTypes[557]); break; case mx::OMPParallelForSimdDirective::static_kind(): - tp = &(gTypes[554]); + tp = &(gTypes[558]); break; case mx::OMPParallelForDirective::static_kind(): - tp = &(gTypes[555]); + tp = &(gTypes[559]); break; case mx::OMPMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[556]); + tp = &(gTypes[560]); break; case mx::OMPMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[557]); + tp = &(gTypes[561]); break; case mx::OMPMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[558]); + tp = &(gTypes[562]); break; case mx::OMPMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[559]); + tp = &(gTypes[563]); break; } @@ -888,7 +888,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -1094,7 +1094,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[524]); + PyTypeObject * const tp = &(gTypes[528]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -1109,12 +1109,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[520].tp_hash; - tp->tp_richcompare = gTypes[520].tp_richcompare; + tp->tp_hash = gTypes[524].tp_hash; + tp->tp_richcompare = gTypes[524].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[520]); + tp->tp_base = &(gTypes[524]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp b/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp index f7704148f..555f35021 100644 --- a/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp +++ b/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[521]) || tp >= &(gTypes[524])) { + if (tp < &(gTypes[525]) || tp >= &(gTypes[528])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPUnrollDirective::static_kind(): - tp = &(gTypes[522]); + tp = &(gTypes[526]); break; case mx::OMPTileDirective::static_kind(): - tp = &(gTypes[523]); + tp = &(gTypes[527]); break; } @@ -326,7 +326,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -356,7 +356,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[521]); + PyTypeObject * const tp = &(gTypes[525]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -371,12 +371,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[520].tp_hash; - tp->tp_richcompare = gTypes[520].tp_richcompare; + tp->tp_hash = gTypes[524].tp_hash; + tp->tp_richcompare = gTypes[524].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[520]); + tp->tp_base = &(gTypes[524]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPMaskedDirective.cpp b/bindings/Python/Generated/AST/OMPMaskedDirective.cpp index 97dd5af19..4b98b1117 100644 --- a/bindings/Python/Generated/AST/OMPMaskedDirective.cpp +++ b/bindings/Python/Generated/AST/OMPMaskedDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[519]) || tp >= &(gTypes[520])) { + if (tp < &(gTypes[523]) || tp >= &(gTypes[524])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPMaskedDirective::static_kind(): - tp = &(gTypes[519]); + tp = &(gTypes[523]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[519]); + PyTypeObject * const tp = &(gTypes[523]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp index 8714559ea..704898efe 100644 --- a/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[559]) || tp >= &(gTypes[560])) { + if (tp < &(gTypes[563]) || tp >= &(gTypes[564])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[559]); + tp = &(gTypes[563]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[559]); + PyTypeObject * const tp = &(gTypes[563]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp index f75304d3b..e942617cb 100644 --- a/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[558]) || tp >= &(gTypes[559])) { + if (tp < &(gTypes[562]) || tp >= &(gTypes[563])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[558]); + tp = &(gTypes[562]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[558]); + PyTypeObject * const tp = &(gTypes[562]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPMasterDirective.cpp b/bindings/Python/Generated/AST/OMPMasterDirective.cpp index 34aeda128..0e4078259 100644 --- a/bindings/Python/Generated/AST/OMPMasterDirective.cpp +++ b/bindings/Python/Generated/AST/OMPMasterDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[518]) || tp >= &(gTypes[519])) { + if (tp < &(gTypes[522]) || tp >= &(gTypes[523])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPMasterDirective::static_kind(): - tp = &(gTypes[518]); + tp = &(gTypes[522]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[518]); + PyTypeObject * const tp = &(gTypes[522]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp index 711c4b0d3..9af32b670 100644 --- a/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[557]) || tp >= &(gTypes[558])) { + if (tp < &(gTypes[561]) || tp >= &(gTypes[562])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[557]); + tp = &(gTypes[561]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[557]); + PyTypeObject * const tp = &(gTypes[561]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp index 43639947d..3985137c9 100644 --- a/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[556]) || tp >= &(gTypes[557])) { + if (tp < &(gTypes[560]) || tp >= &(gTypes[561])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[556]); + tp = &(gTypes[560]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[556]); + PyTypeObject * const tp = &(gTypes[560]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPMetaDirective.cpp b/bindings/Python/Generated/AST/OMPMetaDirective.cpp index 06bb864df..02e4316f2 100644 --- a/bindings/Python/Generated/AST/OMPMetaDirective.cpp +++ b/bindings/Python/Generated/AST/OMPMetaDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[517]) || tp >= &(gTypes[518])) { + if (tp < &(gTypes[521]) || tp >= &(gTypes[522])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPMetaDirective::static_kind(): - tp = &(gTypes[517]); + tp = &(gTypes[521]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[517]); + PyTypeObject * const tp = &(gTypes[521]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPOrderedDirective.cpp b/bindings/Python/Generated/AST/OMPOrderedDirective.cpp index 112ff1566..979842567 100644 --- a/bindings/Python/Generated/AST/OMPOrderedDirective.cpp +++ b/bindings/Python/Generated/AST/OMPOrderedDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[516]) || tp >= &(gTypes[517])) { + if (tp < &(gTypes[520]) || tp >= &(gTypes[521])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPOrderedDirective::static_kind(): - tp = &(gTypes[516]); + tp = &(gTypes[520]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[516]); + PyTypeObject * const tp = &(gTypes[520]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelDirective.cpp b/bindings/Python/Generated/AST/OMPParallelDirective.cpp index b4556ca5d..d10e5a367 100644 --- a/bindings/Python/Generated/AST/OMPParallelDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[515]) || tp >= &(gTypes[516])) { + if (tp < &(gTypes[519]) || tp >= &(gTypes[520])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelDirective::static_kind(): - tp = &(gTypes[515]); + tp = &(gTypes[519]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[515]); + PyTypeObject * const tp = &(gTypes[519]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPParallelForDirective.cpp index 889121059..101a112b6 100644 --- a/bindings/Python/Generated/AST/OMPParallelForDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelForDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[555]) || tp >= &(gTypes[556])) { + if (tp < &(gTypes[559]) || tp >= &(gTypes[560])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelForDirective::static_kind(): - tp = &(gTypes[555]); + tp = &(gTypes[559]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[555]); + PyTypeObject * const tp = &(gTypes[559]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp index 05c854c53..fd448fbaf 100644 --- a/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[554]) || tp >= &(gTypes[555])) { + if (tp < &(gTypes[558]) || tp >= &(gTypes[559])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelForSimdDirective::static_kind(): - tp = &(gTypes[554]); + tp = &(gTypes[558]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[554]); + PyTypeObject * const tp = &(gTypes[558]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp index daa9f0a77..9a01b7095 100644 --- a/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[553]) || tp >= &(gTypes[554])) { + if (tp < &(gTypes[557]) || tp >= &(gTypes[558])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[553]); + tp = &(gTypes[557]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[553]); + PyTypeObject * const tp = &(gTypes[557]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp index fe1bb7b2f..c47829b72 100644 --- a/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[514]) || tp >= &(gTypes[515])) { + if (tp < &(gTypes[518]) || tp >= &(gTypes[519])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelMaskedDirective::static_kind(): - tp = &(gTypes[514]); + tp = &(gTypes[518]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[514]); + PyTypeObject * const tp = &(gTypes[518]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp index a7445d607..91022a337 100644 --- a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[552]) || tp >= &(gTypes[553])) { + if (tp < &(gTypes[556]) || tp >= &(gTypes[557])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[552]); + tp = &(gTypes[556]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[552]); + PyTypeObject * const tp = &(gTypes[556]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp index fd3948286..1544027fc 100644 --- a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[551]) || tp >= &(gTypes[552])) { + if (tp < &(gTypes[555]) || tp >= &(gTypes[556])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[551]); + tp = &(gTypes[555]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[551]); + PyTypeObject * const tp = &(gTypes[555]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp index 9e92a4512..22cbe81c7 100644 --- a/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[513]) || tp >= &(gTypes[514])) { + if (tp < &(gTypes[517]) || tp >= &(gTypes[518])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelMasterDirective::static_kind(): - tp = &(gTypes[513]); + tp = &(gTypes[517]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[513]); + PyTypeObject * const tp = &(gTypes[517]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp index d872c5893..4e6ccddf6 100644 --- a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[550]) || tp >= &(gTypes[551])) { + if (tp < &(gTypes[554]) || tp >= &(gTypes[555])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[550]); + tp = &(gTypes[554]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[550]); + PyTypeObject * const tp = &(gTypes[554]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp index 2c8e26386..75ec88039 100644 --- a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[549]) || tp >= &(gTypes[550])) { + if (tp < &(gTypes[553]) || tp >= &(gTypes[554])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[549]); + tp = &(gTypes[553]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[549]); + PyTypeObject * const tp = &(gTypes[553]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp b/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp index 9a88e5982..f528b7700 100644 --- a/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp +++ b/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[512]) || tp >= &(gTypes[513])) { + if (tp < &(gTypes[516]) || tp >= &(gTypes[517])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPParallelSectionsDirective::static_kind(): - tp = &(gTypes[512]); + tp = &(gTypes[516]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[512]); + PyTypeObject * const tp = &(gTypes[516]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp b/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp index 9f120d8f4..903637f9a 100644 --- a/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp +++ b/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[67]) || tp >= &(gTypes[68])) { + if (tp < &(gTypes[71]) || tp >= &(gTypes[72])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPReferencedVarAttr::static_kind(): - tp = &(gTypes[67]); + tp = &(gTypes[71]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[67]); + PyTypeObject * const tp = &(gTypes[71]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPRequiresDecl.cpp b/bindings/Python/Generated/AST/OMPRequiresDecl.cpp index fa22abf0f..d7971ff99 100644 --- a/bindings/Python/Generated/AST/OMPRequiresDecl.cpp +++ b/bindings/Python/Generated/AST/OMPRequiresDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[729]) || tp >= &(gTypes[730])) { + if (tp < &(gTypes[733]) || tp >= &(gTypes[734])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPRequiresDecl::static_kind(): - tp = &(gTypes[729]); + tp = &(gTypes[733]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[729]); + PyTypeObject * const tp = &(gTypes[733]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[727].tp_hash; - tp->tp_richcompare = gTypes[727].tp_richcompare; + tp->tp_hash = gTypes[731].tp_hash; + tp->tp_richcompare = gTypes[731].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[727]); + tp->tp_base = &(gTypes[731]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPScanDirective.cpp b/bindings/Python/Generated/AST/OMPScanDirective.cpp index bfef5f579..cf65980da 100644 --- a/bindings/Python/Generated/AST/OMPScanDirective.cpp +++ b/bindings/Python/Generated/AST/OMPScanDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[511]) || tp >= &(gTypes[512])) { + if (tp < &(gTypes[515]) || tp >= &(gTypes[516])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPScanDirective::static_kind(): - tp = &(gTypes[511]); + tp = &(gTypes[515]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[511]); + PyTypeObject * const tp = &(gTypes[515]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPScopeDirective.cpp b/bindings/Python/Generated/AST/OMPScopeDirective.cpp index d331a9339..b9402e9b3 100644 --- a/bindings/Python/Generated/AST/OMPScopeDirective.cpp +++ b/bindings/Python/Generated/AST/OMPScopeDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[510]) || tp >= &(gTypes[511])) { + if (tp < &(gTypes[514]) || tp >= &(gTypes[515])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPScopeDirective::static_kind(): - tp = &(gTypes[510]); + tp = &(gTypes[514]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[510]); + PyTypeObject * const tp = &(gTypes[514]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPSectionDirective.cpp b/bindings/Python/Generated/AST/OMPSectionDirective.cpp index 15b0f0e6c..d986fb64d 100644 --- a/bindings/Python/Generated/AST/OMPSectionDirective.cpp +++ b/bindings/Python/Generated/AST/OMPSectionDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[509]) || tp >= &(gTypes[510])) { + if (tp < &(gTypes[513]) || tp >= &(gTypes[514])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPSectionDirective::static_kind(): - tp = &(gTypes[509]); + tp = &(gTypes[513]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[509]); + PyTypeObject * const tp = &(gTypes[513]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPSectionsDirective.cpp b/bindings/Python/Generated/AST/OMPSectionsDirective.cpp index d85004f11..751d99d09 100644 --- a/bindings/Python/Generated/AST/OMPSectionsDirective.cpp +++ b/bindings/Python/Generated/AST/OMPSectionsDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[508]) || tp >= &(gTypes[509])) { + if (tp < &(gTypes[512]) || tp >= &(gTypes[513])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPSectionsDirective::static_kind(): - tp = &(gTypes[508]); + tp = &(gTypes[512]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[508]); + PyTypeObject * const tp = &(gTypes[512]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPSimdDirective.cpp b/bindings/Python/Generated/AST/OMPSimdDirective.cpp index 52a2a21cc..d74ffb6be 100644 --- a/bindings/Python/Generated/AST/OMPSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[548]) || tp >= &(gTypes[549])) { + if (tp < &(gTypes[552]) || tp >= &(gTypes[553])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPSimdDirective::static_kind(): - tp = &(gTypes[548]); + tp = &(gTypes[552]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[548]); + PyTypeObject * const tp = &(gTypes[552]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPSingleDirective.cpp b/bindings/Python/Generated/AST/OMPSingleDirective.cpp index c1daccfa7..17e5a84e3 100644 --- a/bindings/Python/Generated/AST/OMPSingleDirective.cpp +++ b/bindings/Python/Generated/AST/OMPSingleDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[507]) || tp >= &(gTypes[508])) { + if (tp < &(gTypes[511]) || tp >= &(gTypes[512])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPSingleDirective::static_kind(): - tp = &(gTypes[507]); + tp = &(gTypes[511]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[507]); + PyTypeObject * const tp = &(gTypes[511]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp b/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp index 70ed5b2fb..af783ec89 100644 --- a/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[506]) || tp >= &(gTypes[507])) { + if (tp < &(gTypes[510]) || tp >= &(gTypes[511])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetDataDirective::static_kind(): - tp = &(gTypes[506]); + tp = &(gTypes[510]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[506]); + PyTypeObject * const tp = &(gTypes[510]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetDirective.cpp b/bindings/Python/Generated/AST/OMPTargetDirective.cpp index 0972659f9..7500e7e2f 100644 --- a/bindings/Python/Generated/AST/OMPTargetDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[505]) || tp >= &(gTypes[506])) { + if (tp < &(gTypes[509]) || tp >= &(gTypes[510])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetDirective::static_kind(): - tp = &(gTypes[505]); + tp = &(gTypes[509]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[505]); + PyTypeObject * const tp = &(gTypes[509]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp b/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp index 43757596e..0c969b7b1 100644 --- a/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[504]) || tp >= &(gTypes[505])) { + if (tp < &(gTypes[508]) || tp >= &(gTypes[509])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetEnterDataDirective::static_kind(): - tp = &(gTypes[504]); + tp = &(gTypes[508]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[504]); + PyTypeObject * const tp = &(gTypes[508]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp b/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp index 9eea16662..5415ddcf8 100644 --- a/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[503]) || tp >= &(gTypes[504])) { + if (tp < &(gTypes[507]) || tp >= &(gTypes[508])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetExitDataDirective::static_kind(): - tp = &(gTypes[503]); + tp = &(gTypes[507]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[503]); + PyTypeObject * const tp = &(gTypes[507]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp index 6744da2f1..dfa0f8600 100644 --- a/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[502]) || tp >= &(gTypes[503])) { + if (tp < &(gTypes[506]) || tp >= &(gTypes[507])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetParallelDirective::static_kind(): - tp = &(gTypes[502]); + tp = &(gTypes[506]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[502]); + PyTypeObject * const tp = &(gTypes[506]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp index 110a7cca9..0b5e326d5 100644 --- a/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[547]) || tp >= &(gTypes[548])) { + if (tp < &(gTypes[551]) || tp >= &(gTypes[552])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetParallelForDirective::static_kind(): - tp = &(gTypes[547]); + tp = &(gTypes[551]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[547]); + PyTypeObject * const tp = &(gTypes[551]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp index c4c8b923a..0f1957e0d 100644 --- a/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[546]) || tp >= &(gTypes[547])) { + if (tp < &(gTypes[550]) || tp >= &(gTypes[551])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetParallelForSimdDirective::static_kind(): - tp = &(gTypes[546]); + tp = &(gTypes[550]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[546]); + PyTypeObject * const tp = &(gTypes[550]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp index fbf9e1575..422b2abe1 100644 --- a/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[545]) || tp >= &(gTypes[546])) { + if (tp < &(gTypes[549]) || tp >= &(gTypes[550])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[545]); + tp = &(gTypes[549]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[545]); + PyTypeObject * const tp = &(gTypes[549]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp index bcb7eb7a3..f40fe38f2 100644 --- a/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[544]) || tp >= &(gTypes[545])) { + if (tp < &(gTypes[548]) || tp >= &(gTypes[549])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetSimdDirective::static_kind(): - tp = &(gTypes[544]); + tp = &(gTypes[548]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[544]); + PyTypeObject * const tp = &(gTypes[548]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp index 7d8685d49..55ec6a02b 100644 --- a/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[501]) || tp >= &(gTypes[502])) { + if (tp < &(gTypes[505]) || tp >= &(gTypes[506])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetTeamsDirective::static_kind(): - tp = &(gTypes[501]); + tp = &(gTypes[505]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[501]); + PyTypeObject * const tp = &(gTypes[505]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp index 4ce1e7f3c..5202c7e07 100644 --- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[543]) || tp >= &(gTypes[544])) { + if (tp < &(gTypes[547]) || tp >= &(gTypes[548])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetTeamsDistributeDirective::static_kind(): - tp = &(gTypes[543]); + tp = &(gTypes[547]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[543]); + PyTypeObject * const tp = &(gTypes[547]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp index 72ccdfa40..452935db8 100644 --- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[542]) || tp >= &(gTypes[543])) { + if (tp < &(gTypes[546]) || tp >= &(gTypes[547])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[542]); + tp = &(gTypes[546]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[542]); + PyTypeObject * const tp = &(gTypes[546]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp index 69cbc9f46..caac63edd 100644 --- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[541]) || tp >= &(gTypes[542])) { + if (tp < &(gTypes[545]) || tp >= &(gTypes[546])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[541]); + tp = &(gTypes[545]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[541]); + PyTypeObject * const tp = &(gTypes[545]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp index 05ff2084f..c522afe27 100644 --- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[540]) || tp >= &(gTypes[541])) { + if (tp < &(gTypes[544]) || tp >= &(gTypes[545])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[540]); + tp = &(gTypes[544]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[540]); + PyTypeObject * const tp = &(gTypes[544]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp index e5417f3da..8e0d885e3 100644 --- a/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[539]) || tp >= &(gTypes[540])) { + if (tp < &(gTypes[543]) || tp >= &(gTypes[544])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[539]); + tp = &(gTypes[543]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[539]); + PyTypeObject * const tp = &(gTypes[543]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp b/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp index 54edf66d4..b8d73779a 100644 --- a/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[500]) || tp >= &(gTypes[501])) { + if (tp < &(gTypes[504]) || tp >= &(gTypes[505])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTargetUpdateDirective::static_kind(): - tp = &(gTypes[500]); + tp = &(gTypes[504]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[500]); + PyTypeObject * const tp = &(gTypes[504]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTaskDirective.cpp b/bindings/Python/Generated/AST/OMPTaskDirective.cpp index 4056da67b..9e13c11a6 100644 --- a/bindings/Python/Generated/AST/OMPTaskDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTaskDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[499]) || tp >= &(gTypes[500])) { + if (tp < &(gTypes[503]) || tp >= &(gTypes[504])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTaskDirective::static_kind(): - tp = &(gTypes[499]); + tp = &(gTypes[503]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[499]); + PyTypeObject * const tp = &(gTypes[503]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp index 92e0372f1..b2be6ab1f 100644 --- a/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[538]) || tp >= &(gTypes[539])) { + if (tp < &(gTypes[542]) || tp >= &(gTypes[543])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTaskLoopDirective::static_kind(): - tp = &(gTypes[538]); + tp = &(gTypes[542]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[538]); + PyTypeObject * const tp = &(gTypes[542]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp index ef47f2d93..807ab62ff 100644 --- a/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[537]) || tp >= &(gTypes[538])) { + if (tp < &(gTypes[541]) || tp >= &(gTypes[542])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[537]); + tp = &(gTypes[541]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[537]); + PyTypeObject * const tp = &(gTypes[541]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp b/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp index e92bf4913..6fb0239ef 100644 --- a/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[498]) || tp >= &(gTypes[499])) { + if (tp < &(gTypes[502]) || tp >= &(gTypes[503])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTaskgroupDirective::static_kind(): - tp = &(gTypes[498]); + tp = &(gTypes[502]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[498]); + PyTypeObject * const tp = &(gTypes[502]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp b/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp index ad4e85203..f86adcf2f 100644 --- a/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[497]) || tp >= &(gTypes[498])) { + if (tp < &(gTypes[501]) || tp >= &(gTypes[502])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTaskwaitDirective::static_kind(): - tp = &(gTypes[497]); + tp = &(gTypes[501]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[497]); + PyTypeObject * const tp = &(gTypes[501]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp b/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp index fed0cab2d..98fb5a76a 100644 --- a/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[496]) || tp >= &(gTypes[497])) { + if (tp < &(gTypes[500]) || tp >= &(gTypes[501])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTaskyieldDirective::static_kind(): - tp = &(gTypes[496]); + tp = &(gTypes[500]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[496]); + PyTypeObject * const tp = &(gTypes[500]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTeamsDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDirective.cpp index 9bcca88f6..dea2f551a 100644 --- a/bindings/Python/Generated/AST/OMPTeamsDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTeamsDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[495]) || tp >= &(gTypes[496])) { + if (tp < &(gTypes[499]) || tp >= &(gTypes[500])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTeamsDirective::static_kind(): - tp = &(gTypes[495]); + tp = &(gTypes[499]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[495]); + PyTypeObject * const tp = &(gTypes[499]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[486].tp_hash; - tp->tp_richcompare = gTypes[486].tp_richcompare; + tp->tp_hash = gTypes[490].tp_hash; + tp->tp_richcompare = gTypes[490].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[486]); + tp->tp_base = &(gTypes[490]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp index 7f9df622f..6f2d9bcb0 100644 --- a/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[536]) || tp >= &(gTypes[537])) { + if (tp < &(gTypes[540]) || tp >= &(gTypes[541])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTeamsDistributeDirective::static_kind(): - tp = &(gTypes[536]); + tp = &(gTypes[540]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[536]); + PyTypeObject * const tp = &(gTypes[540]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp index 47065e1c6..1c92fb502 100644 --- a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[535]) || tp >= &(gTypes[536])) { + if (tp < &(gTypes[539]) || tp >= &(gTypes[540])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[535]); + tp = &(gTypes[539]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[535]); + PyTypeObject * const tp = &(gTypes[539]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp index 1d1d8a0d7..1f2dd7377 100644 --- a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[534]) || tp >= &(gTypes[535])) { + if (tp < &(gTypes[538]) || tp >= &(gTypes[539])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[534]); + tp = &(gTypes[538]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[534]); + PyTypeObject * const tp = &(gTypes[538]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp index dd75d8fba..e1dfb912c 100644 --- a/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[533]) || tp >= &(gTypes[534])) { + if (tp < &(gTypes[537]) || tp >= &(gTypes[538])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[533]); + tp = &(gTypes[537]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[533]); + PyTypeObject * const tp = &(gTypes[537]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp index 80716534e..df5946da3 100644 --- a/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[532]) || tp >= &(gTypes[533])) { + if (tp < &(gTypes[536]) || tp >= &(gTypes[537])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[532]); + tp = &(gTypes[536]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[532]); + PyTypeObject * const tp = &(gTypes[536]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[524].tp_hash; - tp->tp_richcompare = gTypes[524].tp_richcompare; + tp->tp_hash = gTypes[528].tp_hash; + tp->tp_richcompare = gTypes[528].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[524]); + tp->tp_base = &(gTypes[528]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp b/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp index d8062c522..c9dd13ebe 100644 --- a/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp +++ b/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[728]) || tp >= &(gTypes[729])) { + if (tp < &(gTypes[732]) || tp >= &(gTypes[733])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPThreadPrivateDecl::static_kind(): - tp = &(gTypes[728]); + tp = &(gTypes[732]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[728]); + PyTypeObject * const tp = &(gTypes[732]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[727].tp_hash; - tp->tp_richcompare = gTypes[727].tp_richcompare; + tp->tp_hash = gTypes[731].tp_hash; + tp->tp_richcompare = gTypes[731].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[727]); + tp->tp_base = &(gTypes[731]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp b/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp index e56a80f7c..f82d3ffba 100644 --- a/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp +++ b/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[330]) || tp >= &(gTypes[331])) { + if (tp < &(gTypes[334]) || tp >= &(gTypes[335])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPThreadPrivateDeclAttr::static_kind(): - tp = &(gTypes[330]); + tp = &(gTypes[334]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[330]); + PyTypeObject * const tp = &(gTypes[334]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPTileDirective.cpp b/bindings/Python/Generated/AST/OMPTileDirective.cpp index 7c0f3e920..7b42c0138 100644 --- a/bindings/Python/Generated/AST/OMPTileDirective.cpp +++ b/bindings/Python/Generated/AST/OMPTileDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[523]) || tp >= &(gTypes[524])) { + if (tp < &(gTypes[527]) || tp >= &(gTypes[528])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPTileDirective::static_kind(): - tp = &(gTypes[523]); + tp = &(gTypes[527]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[523]); + PyTypeObject * const tp = &(gTypes[527]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[521].tp_hash; - tp->tp_richcompare = gTypes[521].tp_richcompare; + tp->tp_hash = gTypes[525].tp_hash; + tp->tp_richcompare = gTypes[525].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[521]); + tp->tp_base = &(gTypes[525]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OMPUnrollDirective.cpp b/bindings/Python/Generated/AST/OMPUnrollDirective.cpp index dbb6c0652..2c064d29c 100644 --- a/bindings/Python/Generated/AST/OMPUnrollDirective.cpp +++ b/bindings/Python/Generated/AST/OMPUnrollDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[522]) || tp >= &(gTypes[523])) { + if (tp < &(gTypes[526]) || tp >= &(gTypes[527])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OMPUnrollDirective::static_kind(): - tp = &(gTypes[522]); + tp = &(gTypes[526]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[522]); + PyTypeObject * const tp = &(gTypes[526]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[521].tp_hash; - tp->tp_richcompare = gTypes[521].tp_richcompare; + tp->tp_hash = gTypes[525].tp_hash; + tp->tp_richcompare = gTypes[525].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[521]); + tp->tp_base = &(gTypes[525]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OSConsumedAttr.cpp b/bindings/Python/Generated/AST/OSConsumedAttr.cpp index b720b503d..37759e0a5 100644 --- a/bindings/Python/Generated/AST/OSConsumedAttr.cpp +++ b/bindings/Python/Generated/AST/OSConsumedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[404]) || tp >= &(gTypes[405])) { + if (tp < &(gTypes[408]) || tp >= &(gTypes[409])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OSConsumedAttr::static_kind(): - tp = &(gTypes[404]); + tp = &(gTypes[408]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[404]); + PyTypeObject * const tp = &(gTypes[408]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp b/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp index 53dd76f6a..f30520522 100644 --- a/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp +++ b/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[329]) || tp >= &(gTypes[330])) { + if (tp < &(gTypes[333]) || tp >= &(gTypes[334])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OSConsumesThisAttr::static_kind(): - tp = &(gTypes[329]); + tp = &(gTypes[333]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[329]); + PyTypeObject * const tp = &(gTypes[333]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp b/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp index 22715cc93..ce2501929 100644 --- a/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp +++ b/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[328]) || tp >= &(gTypes[329])) { + if (tp < &(gTypes[332]) || tp >= &(gTypes[333])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OSReturnsNotRetainedAttr::static_kind(): - tp = &(gTypes[328]); + tp = &(gTypes[332]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[328]); + PyTypeObject * const tp = &(gTypes[332]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp b/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp index 1cfb9e6fa..57c067f4e 100644 --- a/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp +++ b/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[327]) || tp >= &(gTypes[328])) { + if (tp < &(gTypes[331]) || tp >= &(gTypes[332])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OSReturnsRetainedAttr::static_kind(): - tp = &(gTypes[327]); + tp = &(gTypes[331]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[327]); + PyTypeObject * const tp = &(gTypes[331]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp b/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp index 627818cb8..f9aceb3d5 100644 --- a/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp +++ b/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[326]) || tp >= &(gTypes[327])) { + if (tp < &(gTypes[330]) || tp >= &(gTypes[331])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OSReturnsRetainedOnNonZeroAttr::static_kind(): - tp = &(gTypes[326]); + tp = &(gTypes[330]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[326]); + PyTypeObject * const tp = &(gTypes[330]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp b/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp index 3cfa9eef3..313cfe948 100644 --- a/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp +++ b/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[325]) || tp >= &(gTypes[326])) { + if (tp < &(gTypes[329]) || tp >= &(gTypes[330])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OSReturnsRetainedOnZeroAttr::static_kind(): - tp = &(gTypes[325]); + tp = &(gTypes[329]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[325]); + PyTypeObject * const tp = &(gTypes[329]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp b/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp index 6d7d20ecd..9084a8bc0 100644 --- a/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp +++ b/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[693]) || tp >= &(gTypes[694])) { + if (tp < &(gTypes[697]) || tp >= &(gTypes[698])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCArrayLiteral::static_kind(): - tp = &(gTypes[693]); + tp = &(gTypes[697]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -401,7 +401,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[693]); + PyTypeObject * const tp = &(gTypes[697]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -416,12 +416,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp b/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp index b77e6ce04..c7835f623 100644 --- a/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp +++ b/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[485]) || tp >= &(gTypes[486])) { + if (tp < &(gTypes[489]) || tp >= &(gTypes[490])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAtCatchStmt::static_kind(): - tp = &(gTypes[485]); + tp = &(gTypes[489]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[485]); + PyTypeObject * const tp = &(gTypes[489]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp b/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp index a90d63a64..4e905ce87 100644 --- a/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[770]) || tp >= &(gTypes[771])) { + if (tp < &(gTypes[774]) || tp >= &(gTypes[775])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAtDefsFieldDecl::static_kind(): - tp = &(gTypes[770]); + tp = &(gTypes[774]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[770]); + PyTypeObject * const tp = &(gTypes[774]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[768].tp_hash; - tp->tp_richcompare = gTypes[768].tp_richcompare; + tp->tp_hash = gTypes[772].tp_hash; + tp->tp_richcompare = gTypes[772].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[768]); + tp->tp_base = &(gTypes[772]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp b/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp index ae33a149d..d90dc714a 100644 --- a/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp +++ b/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[484]) || tp >= &(gTypes[485])) { + if (tp < &(gTypes[488]) || tp >= &(gTypes[489])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAtFinallyStmt::static_kind(): - tp = &(gTypes[484]); + tp = &(gTypes[488]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[484]); + PyTypeObject * const tp = &(gTypes[488]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp b/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp index ace1ac21f..0d4003536 100644 --- a/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp +++ b/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[483]) || tp >= &(gTypes[484])) { + if (tp < &(gTypes[487]) || tp >= &(gTypes[488])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAtSynchronizedStmt::static_kind(): - tp = &(gTypes[483]); + tp = &(gTypes[487]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[483]); + PyTypeObject * const tp = &(gTypes[487]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp b/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp index 50ed661c6..4540145f7 100644 --- a/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp +++ b/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[482]) || tp >= &(gTypes[483])) { + if (tp < &(gTypes[486]) || tp >= &(gTypes[487])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAtThrowStmt::static_kind(): - tp = &(gTypes[482]); + tp = &(gTypes[486]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[482]); + PyTypeObject * const tp = &(gTypes[486]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp b/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp index ac2be34a6..f86726695 100644 --- a/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp +++ b/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[481]) || tp >= &(gTypes[482])) { + if (tp < &(gTypes[485]) || tp >= &(gTypes[486])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAtTryStmt::static_kind(): - tp = &(gTypes[481]); + tp = &(gTypes[485]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[481]); + PyTypeObject * const tp = &(gTypes[485]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp b/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp index 2fae5f958..8e7f10faf 100644 --- a/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp +++ b/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[480]) || tp >= &(gTypes[481])) { + if (tp < &(gTypes[484]) || tp >= &(gTypes[485])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAutoreleasePoolStmt::static_kind(): - tp = &(gTypes[480]); + tp = &(gTypes[484]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[480]); + PyTypeObject * const tp = &(gTypes[484]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp b/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp index 774cd8ae4..87bc8c5c7 100644 --- a/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[692]) || tp >= &(gTypes[693])) { + if (tp < &(gTypes[696]) || tp >= &(gTypes[697])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCAvailabilityCheckExpr::static_kind(): - tp = &(gTypes[692]); + tp = &(gTypes[696]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[692]); + PyTypeObject * const tp = &(gTypes[696]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp b/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp index b7e028d8b..cede4c957 100644 --- a/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[691]) || tp >= &(gTypes[692])) { + if (tp < &(gTypes[695]) || tp >= &(gTypes[696])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCBoolLiteralExpr::static_kind(): - tp = &(gTypes[691]); + tp = &(gTypes[695]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[691]); + PyTypeObject * const tp = &(gTypes[695]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp b/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp index 597b0f379..cf1d93ebf 100644 --- a/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[66]) || tp >= &(gTypes[67])) { + if (tp < &(gTypes[70]) || tp >= &(gTypes[71])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCBoxableAttr::static_kind(): - tp = &(gTypes[66]); + tp = &(gTypes[70]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[66]); + PyTypeObject * const tp = &(gTypes[70]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp b/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp index 9f443aca1..f2617c843 100644 --- a/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[690]) || tp >= &(gTypes[691])) { + if (tp < &(gTypes[694]) || tp >= &(gTypes[695])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCBoxedExpr::static_kind(): - tp = &(gTypes[690]); + tp = &(gTypes[694]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[690]); + PyTypeObject * const tp = &(gTypes[694]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp b/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp index 3f35a1b0e..f14efbf2f 100644 --- a/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[324]) || tp >= &(gTypes[325])) { + if (tp < &(gTypes[328]) || tp >= &(gTypes[329])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCBridgeAttr::static_kind(): - tp = &(gTypes[324]); + tp = &(gTypes[328]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[324]); + PyTypeObject * const tp = &(gTypes[328]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp b/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp index 9b72fa6cf..44f47dad8 100644 --- a/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[323]) || tp >= &(gTypes[324])) { + if (tp < &(gTypes[327]) || tp >= &(gTypes[328])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCBridgeMutableAttr::static_kind(): - tp = &(gTypes[323]); + tp = &(gTypes[327]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[323]); + PyTypeObject * const tp = &(gTypes[327]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp b/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp index 75e99cec7..94e33bd8e 100644 --- a/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[322]) || tp >= &(gTypes[323])) { + if (tp < &(gTypes[326]) || tp >= &(gTypes[327])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCBridgeRelatedAttr::static_kind(): - tp = &(gTypes[322]); + tp = &(gTypes[326]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[322]); + PyTypeObject * const tp = &(gTypes[326]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp b/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp index 0e124190f..91847c0d5 100644 --- a/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[612]) || tp >= &(gTypes[613])) { + if (tp < &(gTypes[616]) || tp >= &(gTypes[617])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCBridgedCastExpr::static_kind(): - tp = &(gTypes[612]); + tp = &(gTypes[616]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[612]); + PyTypeObject * const tp = &(gTypes[616]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[602].tp_hash; - tp->tp_richcompare = gTypes[602].tp_richcompare; + tp->tp_hash = gTypes[606].tp_hash; + tp->tp_richcompare = gTypes[606].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[602]); + tp->tp_base = &(gTypes[606]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp b/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp index 1efa33401..9b2e23889 100644 --- a/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[804]) || tp >= &(gTypes[805])) { + if (tp < &(gTypes[808]) || tp >= &(gTypes[809])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCCategoryDecl::static_kind(): - tp = &(gTypes[804]); + tp = &(gTypes[808]); break; } @@ -479,7 +479,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -575,7 +575,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[804]); + PyTypeObject * const tp = &(gTypes[808]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -590,12 +590,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[803].tp_hash; - tp->tp_richcompare = gTypes[803].tp_richcompare; + tp->tp_hash = gTypes[807].tp_hash; + tp->tp_richcompare = gTypes[807].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[803]); + tp->tp_base = &(gTypes[807]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp b/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp index 8349d47c5..89d46589a 100644 --- a/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[808]) || tp >= &(gTypes[809])) { + if (tp < &(gTypes[812]) || tp >= &(gTypes[813])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCCategoryImplDecl::static_kind(): - tp = &(gTypes[808]); + tp = &(gTypes[812]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[808]); + PyTypeObject * const tp = &(gTypes[812]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[807].tp_hash; - tp->tp_richcompare = gTypes[807].tp_richcompare; + tp->tp_hash = gTypes[811].tp_hash; + tp->tp_richcompare = gTypes[811].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[807]); + tp->tp_base = &(gTypes[811]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp b/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp index 9f9ecca88..7605cba6e 100644 --- a/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[65]) || tp >= &(gTypes[66])) { + if (tp < &(gTypes[69]) || tp >= &(gTypes[70])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCClassStubAttr::static_kind(): - tp = &(gTypes[65]); + tp = &(gTypes[69]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[65]); + PyTypeObject * const tp = &(gTypes[69]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp b/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp index d0c9ca939..f251688af 100644 --- a/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[810]) || tp >= &(gTypes[811])) { + if (tp < &(gTypes[814]) || tp >= &(gTypes[815])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCCompatibleAliasDecl::static_kind(): - tp = &(gTypes[810]); + tp = &(gTypes[814]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[810]); + PyTypeObject * const tp = &(gTypes[814]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCContainerDecl.cpp b/bindings/Python/Generated/AST/ObjCContainerDecl.cpp index 52f0a9ec8..bac3f9e25 100644 --- a/bindings/Python/Generated/AST/ObjCContainerDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCContainerDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[803]) || tp >= &(gTypes[810])) { + if (tp < &(gTypes[807]) || tp >= &(gTypes[814])) { return std::nullopt; } @@ -88,23 +88,23 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCCategoryDecl::static_kind(): - tp = &(gTypes[804]); + tp = &(gTypes[808]); break; case mx::ObjCProtocolDecl::static_kind(): - tp = &(gTypes[805]); + tp = &(gTypes[809]); break; case mx::ObjCInterfaceDecl::static_kind(): - tp = &(gTypes[806]); + tp = &(gTypes[810]); break; case mx::ObjCCategoryImplDecl::static_kind(): - tp = &(gTypes[808]); + tp = &(gTypes[812]); break; case mx::ObjCImplementationDecl::static_kind(): - tp = &(gTypes[809]); + tp = &(gTypes[813]); break; } @@ -498,7 +498,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -660,7 +660,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[803]); + PyTypeObject * const tp = &(gTypes[807]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -675,12 +675,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp b/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp index a59cd5120..568d5c9ba 100644 --- a/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[64]) || tp >= &(gTypes[65])) { + if (tp < &(gTypes[68]) || tp >= &(gTypes[69])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCDesignatedInitializerAttr::static_kind(): - tp = &(gTypes[64]); + tp = &(gTypes[68]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[64]); + PyTypeObject * const tp = &(gTypes[68]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp b/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp index 9ec122d2c..53d090fc3 100644 --- a/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp +++ b/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[689]) || tp >= &(gTypes[690])) { + if (tp < &(gTypes[693]) || tp >= &(gTypes[694])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCDictionaryLiteral::static_kind(): - tp = &(gTypes[689]); + tp = &(gTypes[693]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[689]); + PyTypeObject * const tp = &(gTypes[693]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCDirectAttr.cpp b/bindings/Python/Generated/AST/ObjCDirectAttr.cpp index 23b1c0ea1..8ee0d1f53 100644 --- a/bindings/Python/Generated/AST/ObjCDirectAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCDirectAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[63]) || tp >= &(gTypes[64])) { + if (tp < &(gTypes[67]) || tp >= &(gTypes[68])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCDirectAttr::static_kind(): - tp = &(gTypes[63]); + tp = &(gTypes[67]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[63]); + PyTypeObject * const tp = &(gTypes[67]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp b/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp index d3b396f99..f72efa70a 100644 --- a/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[62]) || tp >= &(gTypes[63])) { + if (tp < &(gTypes[66]) || tp >= &(gTypes[67])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCDirectMembersAttr::static_kind(): - tp = &(gTypes[62]); + tp = &(gTypes[66]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[62]); + PyTypeObject * const tp = &(gTypes[66]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp b/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp index a45becb8c..62d3f88ce 100644 --- a/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[688]) || tp >= &(gTypes[689])) { + if (tp < &(gTypes[692]) || tp >= &(gTypes[693])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCEncodeExpr::static_kind(): - tp = &(gTypes[688]); + tp = &(gTypes[692]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[688]); + PyTypeObject * const tp = &(gTypes[692]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp b/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp index ed2f36ea6..e1765f7f1 100644 --- a/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[321]) || tp >= &(gTypes[322])) { + if (tp < &(gTypes[325]) || tp >= &(gTypes[326])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCExceptionAttr::static_kind(): - tp = &(gTypes[321]); + tp = &(gTypes[325]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[321]); + PyTypeObject * const tp = &(gTypes[325]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp b/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp index 4345d50dc..716183a49 100644 --- a/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[320]) || tp >= &(gTypes[321])) { + if (tp < &(gTypes[324]) || tp >= &(gTypes[325])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCExplicitProtocolImplAttr::static_kind(): - tp = &(gTypes[320]); + tp = &(gTypes[324]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[320]); + PyTypeObject * const tp = &(gTypes[324]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp b/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp index 0ee50296a..70fc35d13 100644 --- a/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[319]) || tp >= &(gTypes[320])) { + if (tp < &(gTypes[323]) || tp >= &(gTypes[324])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCExternallyRetainedAttr::static_kind(): - tp = &(gTypes[319]); + tp = &(gTypes[323]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[319]); + PyTypeObject * const tp = &(gTypes[323]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp b/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp index 07c5ab240..d8f302828 100644 --- a/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp +++ b/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[479]) || tp >= &(gTypes[480])) { + if (tp < &(gTypes[483]) || tp >= &(gTypes[484])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCForCollectionStmt::static_kind(): - tp = &(gTypes[479]); + tp = &(gTypes[483]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[479]); + PyTypeObject * const tp = &(gTypes[483]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCGCAttr.cpp b/bindings/Python/Generated/AST/ObjCGCAttr.cpp index 7b8bf9773..9e4dc33c1 100644 --- a/bindings/Python/Generated/AST/ObjCGCAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCGCAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[23]) || tp >= &(gTypes[24])) { + if (tp < &(gTypes[27]) || tp >= &(gTypes[28])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCGCAttr::static_kind(): - tp = &(gTypes[23]); + tp = &(gTypes[27]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[23]); + PyTypeObject * const tp = &(gTypes[27]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCImplDecl.cpp b/bindings/Python/Generated/AST/ObjCImplDecl.cpp index a45605ad4..2878e9678 100644 --- a/bindings/Python/Generated/AST/ObjCImplDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCImplDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[807]) || tp >= &(gTypes[810])) { + if (tp < &(gTypes[811]) || tp >= &(gTypes[814])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCCategoryImplDecl::static_kind(): - tp = &(gTypes[808]); + tp = &(gTypes[812]); break; case mx::ObjCImplementationDecl::static_kind(): - tp = &(gTypes[809]); + tp = &(gTypes[813]); break; } @@ -366,7 +366,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -418,7 +418,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[807]); + PyTypeObject * const tp = &(gTypes[811]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -433,12 +433,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[803].tp_hash; - tp->tp_richcompare = gTypes[803].tp_richcompare; + tp->tp_hash = gTypes[807].tp_hash; + tp->tp_richcompare = gTypes[807].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[803]); + tp->tp_base = &(gTypes[807]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp b/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp index 3cd5cc46e..b64d89b40 100644 --- a/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[809]) || tp >= &(gTypes[810])) { + if (tp < &(gTypes[813]) || tp >= &(gTypes[814])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCImplementationDecl::static_kind(): - tp = &(gTypes[809]); + tp = &(gTypes[813]); break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -533,7 +533,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[809]); + PyTypeObject * const tp = &(gTypes[813]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -548,12 +548,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[807].tp_hash; - tp->tp_richcompare = gTypes[807].tp_richcompare; + tp->tp_hash = gTypes[811].tp_hash; + tp->tp_richcompare = gTypes[811].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[807]); + tp->tp_base = &(gTypes[811]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp b/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp index ad27f364f..07700b1a1 100644 --- a/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[318]) || tp >= &(gTypes[319])) { + if (tp < &(gTypes[322]) || tp >= &(gTypes[323])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCIndependentClassAttr::static_kind(): - tp = &(gTypes[318]); + tp = &(gTypes[322]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[318]); + PyTypeObject * const tp = &(gTypes[322]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp b/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp index 829c11fec..36fb68e6a 100644 --- a/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[687]) || tp >= &(gTypes[688])) { + if (tp < &(gTypes[691]) || tp >= &(gTypes[692])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCIndirectCopyRestoreExpr::static_kind(): - tp = &(gTypes[687]); + tp = &(gTypes[691]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[687]); + PyTypeObject * const tp = &(gTypes[691]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp b/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp index 95aaf2a09..918cfb600 100644 --- a/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[22]) || tp >= &(gTypes[23])) { + if (tp < &(gTypes[26]) || tp >= &(gTypes[27])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCInertUnsafeUnretainedAttr::static_kind(): - tp = &(gTypes[22]); + tp = &(gTypes[26]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[22]); + PyTypeObject * const tp = &(gTypes[26]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp b/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp index 53fae5787..6b7f70caf 100644 --- a/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[806]) || tp >= &(gTypes[807])) { + if (tp < &(gTypes[810]) || tp >= &(gTypes[811])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCInterfaceDecl::static_kind(): - tp = &(gTypes[806]); + tp = &(gTypes[810]); break; } @@ -649,7 +649,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -855,7 +855,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[806]); + PyTypeObject * const tp = &(gTypes[810]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -870,12 +870,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[803].tp_hash; - tp->tp_richcompare = gTypes[803].tp_richcompare; + tp->tp_hash = gTypes[807].tp_hash; + tp->tp_richcompare = gTypes[807].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[803]); + tp->tp_base = &(gTypes[807]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCInterfaceType.cpp b/bindings/Python/Generated/AST/ObjCInterfaceType.cpp index 4f41bfce8..f01db1d65 100644 --- a/bindings/Python/Generated/AST/ObjCInterfaceType.cpp +++ b/bindings/Python/Generated/AST/ObjCInterfaceType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[428]) || tp >= &(gTypes[429])) { + if (tp < &(gTypes[432]) || tp >= &(gTypes[433])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCInterfaceType::static_kind(): - tp = &(gTypes[428]); + tp = &(gTypes[432]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[428]); + PyTypeObject * const tp = &(gTypes[432]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[427].tp_hash; - tp->tp_richcompare = gTypes[427].tp_richcompare; + tp->tp_hash = gTypes[431].tp_hash; + tp->tp_richcompare = gTypes[431].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[427]); + tp->tp_base = &(gTypes[431]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCIsaExpr.cpp b/bindings/Python/Generated/AST/ObjCIsaExpr.cpp index e28e7688d..3183ec312 100644 --- a/bindings/Python/Generated/AST/ObjCIsaExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCIsaExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[686]) || tp >= &(gTypes[687])) { + if (tp < &(gTypes[690]) || tp >= &(gTypes[691])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCIsaExpr::static_kind(): - tp = &(gTypes[686]); + tp = &(gTypes[690]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[686]); + PyTypeObject * const tp = &(gTypes[690]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCIvarDecl.cpp b/bindings/Python/Generated/AST/ObjCIvarDecl.cpp index 734891aa4..96e676506 100644 --- a/bindings/Python/Generated/AST/ObjCIvarDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCIvarDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[769]) || tp >= &(gTypes[770])) { + if (tp < &(gTypes[773]) || tp >= &(gTypes[774])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCIvarDecl::static_kind(): - tp = &(gTypes[769]); + tp = &(gTypes[773]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[769]); + PyTypeObject * const tp = &(gTypes[773]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[768].tp_hash; - tp->tp_richcompare = gTypes[768].tp_richcompare; + tp->tp_hash = gTypes[772].tp_hash; + tp->tp_richcompare = gTypes[772].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[768]); + tp->tp_base = &(gTypes[772]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp b/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp index 61a1b34e1..8f1e007f3 100644 --- a/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[685]) || tp >= &(gTypes[686])) { + if (tp < &(gTypes[689]) || tp >= &(gTypes[690])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCIvarRefExpr::static_kind(): - tp = &(gTypes[685]); + tp = &(gTypes[689]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[685]); + PyTypeObject * const tp = &(gTypes[689]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp b/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp index 8f8827c19..0ac3aa513 100644 --- a/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[21]) || tp >= &(gTypes[22])) { + if (tp < &(gTypes[25]) || tp >= &(gTypes[26])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCKindOfAttr::static_kind(): - tp = &(gTypes[21]); + tp = &(gTypes[25]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[21]); + PyTypeObject * const tp = &(gTypes[25]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCMessageExpr.cpp b/bindings/Python/Generated/AST/ObjCMessageExpr.cpp index 492222851..ef43f18fb 100644 --- a/bindings/Python/Generated/AST/ObjCMessageExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCMessageExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[684]) || tp >= &(gTypes[685])) { + if (tp < &(gTypes[688]) || tp >= &(gTypes[689])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCMessageExpr::static_kind(): - tp = &(gTypes[684]); + tp = &(gTypes[688]); break; } @@ -539,7 +539,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -613,7 +613,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[684]); + PyTypeObject * const tp = &(gTypes[688]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -628,12 +628,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCMethodDecl.cpp b/bindings/Python/Generated/AST/ObjCMethodDecl.cpp index 62c145b60..f9ec8b4e2 100644 --- a/bindings/Python/Generated/AST/ObjCMethodDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCMethodDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[802]) || tp >= &(gTypes[803])) { + if (tp < &(gTypes[806]) || tp >= &(gTypes[807])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCMethodDecl::static_kind(): - tp = &(gTypes[802]); + tp = &(gTypes[806]); break; } @@ -689,7 +689,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -763,7 +763,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[802]); + PyTypeObject * const tp = &(gTypes[806]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -778,12 +778,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp b/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp index 4f1b5c883..260da6e22 100644 --- a/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[317]) || tp >= &(gTypes[318])) { + if (tp < &(gTypes[321]) || tp >= &(gTypes[322])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCMethodFamilyAttr::static_kind(): - tp = &(gTypes[317]); + tp = &(gTypes[321]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[317]); + PyTypeObject * const tp = &(gTypes[321]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp b/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp index 9a5ec87e0..26dbcb386 100644 --- a/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[316]) || tp >= &(gTypes[317])) { + if (tp < &(gTypes[320]) || tp >= &(gTypes[321])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCNSObjectAttr::static_kind(): - tp = &(gTypes[316]); + tp = &(gTypes[320]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[316]); + PyTypeObject * const tp = &(gTypes[320]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp b/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp index e8917a279..140ab1500 100644 --- a/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[61]) || tp >= &(gTypes[62])) { + if (tp < &(gTypes[65]) || tp >= &(gTypes[66])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCNonLazyClassAttr::static_kind(): - tp = &(gTypes[61]); + tp = &(gTypes[65]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[61]); + PyTypeObject * const tp = &(gTypes[65]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp b/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp index eade4a768..1ab300b3b 100644 --- a/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[60]) || tp >= &(gTypes[61])) { + if (tp < &(gTypes[64]) || tp >= &(gTypes[65])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCNonRuntimeProtocolAttr::static_kind(): - tp = &(gTypes[60]); + tp = &(gTypes[64]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[60]); + PyTypeObject * const tp = &(gTypes[64]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp b/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp index 6e39a7d31..11da5f7f2 100644 --- a/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp +++ b/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[429]) || tp >= &(gTypes[430])) { + if (tp < &(gTypes[433]) || tp >= &(gTypes[434])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCObjectPointerType::static_kind(): - tp = &(gTypes[429]); + tp = &(gTypes[433]); break; } @@ -463,7 +463,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -581,7 +581,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[429]); + PyTypeObject * const tp = &(gTypes[433]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -596,12 +596,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCObjectType.cpp b/bindings/Python/Generated/AST/ObjCObjectType.cpp index ff71b31b8..05ed187a7 100644 --- a/bindings/Python/Generated/AST/ObjCObjectType.cpp +++ b/bindings/Python/Generated/AST/ObjCObjectType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[427]) || tp >= &(gTypes[429])) { + if (tp < &(gTypes[431]) || tp >= &(gTypes[433])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCObjectType::static_kind(): - tp = &(gTypes[427]); + tp = &(gTypes[431]); break; case mx::ObjCInterfaceType::static_kind(): - tp = &(gTypes[428]); + tp = &(gTypes[432]); break; } @@ -477,7 +477,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -551,7 +551,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[427]); + PyTypeObject * const tp = &(gTypes[431]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -566,12 +566,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp b/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp index 0cbffe301..8f8f94fec 100644 --- a/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[315]) || tp >= &(gTypes[316])) { + if (tp < &(gTypes[319]) || tp >= &(gTypes[320])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCOwnershipAttr::static_kind(): - tp = &(gTypes[315]); + tp = &(gTypes[319]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[315]); + PyTypeObject * const tp = &(gTypes[319]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp b/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp index 51d714924..c983a8bf3 100644 --- a/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[314]) || tp >= &(gTypes[315])) { + if (tp < &(gTypes[318]) || tp >= &(gTypes[319])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCPreciseLifetimeAttr::static_kind(): - tp = &(gTypes[314]); + tp = &(gTypes[318]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[314]); + PyTypeObject * const tp = &(gTypes[318]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp b/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp index 5bc2cab89..60c3287fa 100644 --- a/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[801]) || tp >= &(gTypes[802])) { + if (tp < &(gTypes[805]) || tp >= &(gTypes[806])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCPropertyDecl::static_kind(): - tp = &(gTypes[801]); + tp = &(gTypes[805]); break; } @@ -529,7 +529,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -559,7 +559,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[801]); + PyTypeObject * const tp = &(gTypes[805]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -574,12 +574,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp b/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp index ee9c72689..b447d9e82 100644 --- a/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[737]) || tp >= &(gTypes[738])) { + if (tp < &(gTypes[741]) || tp >= &(gTypes[742])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCPropertyImplDecl::static_kind(): - tp = &(gTypes[737]); + tp = &(gTypes[741]); break; } @@ -439,7 +439,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -469,7 +469,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[737]); + PyTypeObject * const tp = &(gTypes[741]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -484,12 +484,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp b/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp index 46bf0da44..83839cebe 100644 --- a/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[683]) || tp >= &(gTypes[684])) { + if (tp < &(gTypes[687]) || tp >= &(gTypes[688])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCPropertyRefExpr::static_kind(): - tp = &(gTypes[683]); + tp = &(gTypes[687]); break; } @@ -479,7 +479,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -509,7 +509,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[683]); + PyTypeObject * const tp = &(gTypes[687]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -524,12 +524,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp b/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp index 75a4a77b3..571a60349 100644 --- a/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[805]) || tp >= &(gTypes[806])) { + if (tp < &(gTypes[809]) || tp >= &(gTypes[810])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCProtocolDecl::static_kind(): - tp = &(gTypes[805]); + tp = &(gTypes[809]); break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -503,7 +503,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[805]); + PyTypeObject * const tp = &(gTypes[809]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -518,12 +518,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[803].tp_hash; - tp->tp_richcompare = gTypes[803].tp_richcompare; + tp->tp_hash = gTypes[807].tp_hash; + tp->tp_richcompare = gTypes[807].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[803]); + tp->tp_base = &(gTypes[807]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp b/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp index a7e5d6aed..7b78231f8 100644 --- a/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[682]) || tp >= &(gTypes[683])) { + if (tp < &(gTypes[686]) || tp >= &(gTypes[687])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCProtocolExpr::static_kind(): - tp = &(gTypes[682]); + tp = &(gTypes[686]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[682]); + PyTypeObject * const tp = &(gTypes[686]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp b/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp index b42d87e3d..71b03f6ac 100644 --- a/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[313]) || tp >= &(gTypes[314])) { + if (tp < &(gTypes[317]) || tp >= &(gTypes[318])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCRequiresPropertyDefsAttr::static_kind(): - tp = &(gTypes[313]); + tp = &(gTypes[317]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[313]); + PyTypeObject * const tp = &(gTypes[317]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp b/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp index 3cbd0ba7f..5b2c4c189 100644 --- a/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[312]) || tp >= &(gTypes[313])) { + if (tp < &(gTypes[316]) || tp >= &(gTypes[317])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCRequiresSuperAttr::static_kind(): - tp = &(gTypes[312]); + tp = &(gTypes[316]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[312]); + PyTypeObject * const tp = &(gTypes[316]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp b/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp index 8b54a1e1f..6ab51fba6 100644 --- a/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[311]) || tp >= &(gTypes[312])) { + if (tp < &(gTypes[315]) || tp >= &(gTypes[316])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCReturnsInnerPointerAttr::static_kind(): - tp = &(gTypes[311]); + tp = &(gTypes[315]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[311]); + PyTypeObject * const tp = &(gTypes[315]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp b/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp index 9dd775dc0..e576015bb 100644 --- a/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[310]) || tp >= &(gTypes[311])) { + if (tp < &(gTypes[314]) || tp >= &(gTypes[315])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCRootClassAttr::static_kind(): - tp = &(gTypes[310]); + tp = &(gTypes[314]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[310]); + PyTypeObject * const tp = &(gTypes[314]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp b/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp index 11b54943b..b2e38e331 100644 --- a/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[59]) || tp >= &(gTypes[60])) { + if (tp < &(gTypes[63]) || tp >= &(gTypes[64])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCRuntimeNameAttr::static_kind(): - tp = &(gTypes[59]); + tp = &(gTypes[63]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[59]); + PyTypeObject * const tp = &(gTypes[63]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp b/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp index 85c34130f..855ff9fe0 100644 --- a/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[58]) || tp >= &(gTypes[59])) { + if (tp < &(gTypes[62]) || tp >= &(gTypes[63])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCRuntimeVisibleAttr::static_kind(): - tp = &(gTypes[58]); + tp = &(gTypes[62]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[58]); + PyTypeObject * const tp = &(gTypes[62]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp b/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp index 8ec97ea60..7af0b94fe 100644 --- a/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[681]) || tp >= &(gTypes[682])) { + if (tp < &(gTypes[685]) || tp >= &(gTypes[686])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCSelectorExpr::static_kind(): - tp = &(gTypes[681]); + tp = &(gTypes[685]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[681]); + PyTypeObject * const tp = &(gTypes[685]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCStringLiteral.cpp b/bindings/Python/Generated/AST/ObjCStringLiteral.cpp index f9b3babd1..c2bc1a2b2 100644 --- a/bindings/Python/Generated/AST/ObjCStringLiteral.cpp +++ b/bindings/Python/Generated/AST/ObjCStringLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[680]) || tp >= &(gTypes[681])) { + if (tp < &(gTypes[684]) || tp >= &(gTypes[685])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCStringLiteral::static_kind(): - tp = &(gTypes[680]); + tp = &(gTypes[684]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[680]); + PyTypeObject * const tp = &(gTypes[684]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp b/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp index 131acd295..4fb7ceeff 100644 --- a/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp +++ b/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[309]) || tp >= &(gTypes[310])) { + if (tp < &(gTypes[313]) || tp >= &(gTypes[314])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCSubclassingRestrictedAttr::static_kind(): - tp = &(gTypes[309]); + tp = &(gTypes[313]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[309]); + PyTypeObject * const tp = &(gTypes[313]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp b/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp index 056038275..e70ebd4d5 100644 --- a/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp +++ b/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[679]) || tp >= &(gTypes[680])) { + if (tp < &(gTypes[683]) || tp >= &(gTypes[684])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCSubscriptRefExpr::static_kind(): - tp = &(gTypes[679]); + tp = &(gTypes[683]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[679]); + PyTypeObject * const tp = &(gTypes[683]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp b/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp index bc6fd2dcd..365ba405e 100644 --- a/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp +++ b/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[791]) || tp >= &(gTypes[792])) { + if (tp < &(gTypes[795]) || tp >= &(gTypes[796])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCTypeParamDecl::static_kind(): - tp = &(gTypes[791]); + tp = &(gTypes[795]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[791]); + PyTypeObject * const tp = &(gTypes[795]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[788].tp_hash; - tp->tp_richcompare = gTypes[788].tp_richcompare; + tp->tp_hash = gTypes[792].tp_hash; + tp->tp_richcompare = gTypes[792].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[788]); + tp->tp_base = &(gTypes[792]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ObjCTypeParamType.cpp b/bindings/Python/Generated/AST/ObjCTypeParamType.cpp index 63c090d49..f2abf5a73 100644 --- a/bindings/Python/Generated/AST/ObjCTypeParamType.cpp +++ b/bindings/Python/Generated/AST/ObjCTypeParamType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[426]) || tp >= &(gTypes[427])) { + if (tp < &(gTypes[430]) || tp >= &(gTypes[431])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ObjCTypeParamType::static_kind(): - tp = &(gTypes[426]); + tp = &(gTypes[430]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[426]); + PyTypeObject * const tp = &(gTypes[430]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OffsetOfExpr.cpp b/bindings/Python/Generated/AST/OffsetOfExpr.cpp index 5aa673813..783b1d1f4 100644 --- a/bindings/Python/Generated/AST/OffsetOfExpr.cpp +++ b/bindings/Python/Generated/AST/OffsetOfExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[678]) || tp >= &(gTypes[679])) { + if (tp < &(gTypes[682]) || tp >= &(gTypes[683])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OffsetOfExpr::static_kind(): - tp = &(gTypes[678]); + tp = &(gTypes[682]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[678]); + PyTypeObject * const tp = &(gTypes[682]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpaqueValueExpr.cpp b/bindings/Python/Generated/AST/OpaqueValueExpr.cpp index cf4b87bf9..78fe14e46 100644 --- a/bindings/Python/Generated/AST/OpaqueValueExpr.cpp +++ b/bindings/Python/Generated/AST/OpaqueValueExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[677]) || tp >= &(gTypes[678])) { + if (tp < &(gTypes[681]) || tp >= &(gTypes[682])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpaqueValueExpr::static_kind(): - tp = &(gTypes[677]); + tp = &(gTypes[681]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[677]); + PyTypeObject * const tp = &(gTypes[681]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp b/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp index db6bd91a2..0a6020ca1 100644 --- a/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[57]) || tp >= &(gTypes[58])) { + if (tp < &(gTypes[61]) || tp >= &(gTypes[62])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLAccessAttr::static_kind(): - tp = &(gTypes[57]); + tp = &(gTypes[61]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[57]); + PyTypeObject * const tp = &(gTypes[61]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp index 62d920ff0..df3afad95 100644 --- a/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[20]) || tp >= &(gTypes[21])) { + if (tp < &(gTypes[24]) || tp >= &(gTypes[25])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLConstantAddressSpaceAttr::static_kind(): - tp = &(gTypes[20]); + tp = &(gTypes[24]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[20]); + PyTypeObject * const tp = &(gTypes[24]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp index f2dd23079..ebf1d66de 100644 --- a/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[19]) || tp >= &(gTypes[20])) { + if (tp < &(gTypes[23]) || tp >= &(gTypes[24])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLGenericAddressSpaceAttr::static_kind(): - tp = &(gTypes[19]); + tp = &(gTypes[23]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[19]); + PyTypeObject * const tp = &(gTypes[23]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp index c3b031fd5..59dba9590 100644 --- a/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[18]) || tp >= &(gTypes[19])) { + if (tp < &(gTypes[22]) || tp >= &(gTypes[23])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLGlobalAddressSpaceAttr::static_kind(): - tp = &(gTypes[18]); + tp = &(gTypes[22]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[18]); + PyTypeObject * const tp = &(gTypes[22]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp index 1bdae147e..8cde0659c 100644 --- a/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[17]) || tp >= &(gTypes[18])) { + if (tp < &(gTypes[21]) || tp >= &(gTypes[22])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLGlobalDeviceAddressSpaceAttr::static_kind(): - tp = &(gTypes[17]); + tp = &(gTypes[21]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[17]); + PyTypeObject * const tp = &(gTypes[21]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp index 44f959994..a3c5ce0df 100644 --- a/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[16]) || tp >= &(gTypes[17])) { + if (tp < &(gTypes[20]) || tp >= &(gTypes[21])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLGlobalHostAddressSpaceAttr::static_kind(): - tp = &(gTypes[16]); + tp = &(gTypes[20]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[16]); + PyTypeObject * const tp = &(gTypes[20]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp b/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp index 0907db949..daef3d6d6 100644 --- a/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[308]) || tp >= &(gTypes[309])) { + if (tp < &(gTypes[312]) || tp >= &(gTypes[313])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLIntelReqdSubGroupSizeAttr::static_kind(): - tp = &(gTypes[308]); + tp = &(gTypes[312]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[308]); + PyTypeObject * const tp = &(gTypes[312]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp b/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp index ed2c6b919..e30fe581b 100644 --- a/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[307]) || tp >= &(gTypes[308])) { + if (tp < &(gTypes[311]) || tp >= &(gTypes[312])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLKernelAttr::static_kind(): - tp = &(gTypes[307]); + tp = &(gTypes[311]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[307]); + PyTypeObject * const tp = &(gTypes[311]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp index 5e70476a0..e5ce36f25 100644 --- a/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[15]) || tp >= &(gTypes[16])) { + if (tp < &(gTypes[19]) || tp >= &(gTypes[20])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLLocalAddressSpaceAttr::static_kind(): - tp = &(gTypes[15]); + tp = &(gTypes[19]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[15]); + PyTypeObject * const tp = &(gTypes[19]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp index 792f2ba53..eb22490b0 100644 --- a/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[14]) || tp >= &(gTypes[15])) { + if (tp < &(gTypes[18]) || tp >= &(gTypes[19])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLPrivateAddressSpaceAttr::static_kind(): - tp = &(gTypes[14]); + tp = &(gTypes[18]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[14]); + PyTypeObject * const tp = &(gTypes[18]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp b/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp index 4bb44ec42..df08fae6b 100644 --- a/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp +++ b/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[49]) || tp >= &(gTypes[50])) { + if (tp < &(gTypes[53]) || tp >= &(gTypes[54])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLUnrollHintAttr::static_kind(): - tp = &(gTypes[49]); + tp = &(gTypes[53]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[49]); + PyTypeObject * const tp = &(gTypes[53]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[48].tp_hash; - tp->tp_richcompare = gTypes[48].tp_richcompare; + tp->tp_hash = gTypes[52].tp_hash; + tp->tp_richcompare = gTypes[52].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[48]); + tp->tp_base = &(gTypes[52]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp b/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp index dcfa5d130..984ccf382 100644 --- a/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp +++ b/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[306]) || tp >= &(gTypes[307])) { + if (tp < &(gTypes[310]) || tp >= &(gTypes[311])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OptimizeNoneAttr::static_kind(): - tp = &(gTypes[306]); + tp = &(gTypes[310]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[306]); + PyTypeObject * const tp = &(gTypes[310]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OverloadExpr.cpp b/bindings/Python/Generated/AST/OverloadExpr.cpp index 35137d2cf..dbee15b10 100644 --- a/bindings/Python/Generated/AST/OverloadExpr.cpp +++ b/bindings/Python/Generated/AST/OverloadExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[674]) || tp >= &(gTypes[677])) { + if (tp < &(gTypes[678]) || tp >= &(gTypes[681])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedMemberExpr::static_kind(): - tp = &(gTypes[675]); + tp = &(gTypes[679]); break; case mx::UnresolvedLookupExpr::static_kind(): - tp = &(gTypes[676]); + tp = &(gTypes[680]); break; } @@ -396,7 +396,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -448,7 +448,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[674]); + PyTypeObject * const tp = &(gTypes[678]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -463,12 +463,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OverloadableAttr.cpp b/bindings/Python/Generated/AST/OverloadableAttr.cpp index c9260d011..d09c96bc1 100644 --- a/bindings/Python/Generated/AST/OverloadableAttr.cpp +++ b/bindings/Python/Generated/AST/OverloadableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[56]) || tp >= &(gTypes[57])) { + if (tp < &(gTypes[60]) || tp >= &(gTypes[61])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OverloadableAttr::static_kind(): - tp = &(gTypes[56]); + tp = &(gTypes[60]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[56]); + PyTypeObject * const tp = &(gTypes[60]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OverrideAttr.cpp b/bindings/Python/Generated/AST/OverrideAttr.cpp index 2e7cd1cf3..bc70ca9d2 100644 --- a/bindings/Python/Generated/AST/OverrideAttr.cpp +++ b/bindings/Python/Generated/AST/OverrideAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[305]) || tp >= &(gTypes[306])) { + if (tp < &(gTypes[309]) || tp >= &(gTypes[310])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OverrideAttr::static_kind(): - tp = &(gTypes[305]); + tp = &(gTypes[309]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[305]); + PyTypeObject * const tp = &(gTypes[309]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OwnerAttr.cpp b/bindings/Python/Generated/AST/OwnerAttr.cpp index 8f57ed024..7596008f0 100644 --- a/bindings/Python/Generated/AST/OwnerAttr.cpp +++ b/bindings/Python/Generated/AST/OwnerAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[304]) || tp >= &(gTypes[305])) { + if (tp < &(gTypes[308]) || tp >= &(gTypes[309])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OwnerAttr::static_kind(): - tp = &(gTypes[304]); + tp = &(gTypes[308]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[304]); + PyTypeObject * const tp = &(gTypes[308]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/OwnershipAttr.cpp b/bindings/Python/Generated/AST/OwnershipAttr.cpp index 76b05c083..939e6f45f 100644 --- a/bindings/Python/Generated/AST/OwnershipAttr.cpp +++ b/bindings/Python/Generated/AST/OwnershipAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[303]) || tp >= &(gTypes[304])) { + if (tp < &(gTypes[307]) || tp >= &(gTypes[308])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OwnershipAttr::static_kind(): - tp = &(gTypes[303]); + tp = &(gTypes[307]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -381,7 +381,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[303]); + PyTypeObject * const tp = &(gTypes[307]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -396,12 +396,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PackExpansionExpr.cpp b/bindings/Python/Generated/AST/PackExpansionExpr.cpp index 57d4c1388..5a069f386 100644 --- a/bindings/Python/Generated/AST/PackExpansionExpr.cpp +++ b/bindings/Python/Generated/AST/PackExpansionExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[673]) || tp >= &(gTypes[674])) { + if (tp < &(gTypes[677]) || tp >= &(gTypes[678])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PackExpansionExpr::static_kind(): - tp = &(gTypes[673]); + tp = &(gTypes[677]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[673]); + PyTypeObject * const tp = &(gTypes[677]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PackExpansionType.cpp b/bindings/Python/Generated/AST/PackExpansionType.cpp index fa4f3404e..a64655621 100644 --- a/bindings/Python/Generated/AST/PackExpansionType.cpp +++ b/bindings/Python/Generated/AST/PackExpansionType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[425]) || tp >= &(gTypes[426])) { + if (tp < &(gTypes[429]) || tp >= &(gTypes[430])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PackExpansionType::static_kind(): - tp = &(gTypes[425]); + tp = &(gTypes[429]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[425]); + PyTypeObject * const tp = &(gTypes[429]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PackedAttr.cpp b/bindings/Python/Generated/AST/PackedAttr.cpp index fb64efdf5..351a8fa4b 100644 --- a/bindings/Python/Generated/AST/PackedAttr.cpp +++ b/bindings/Python/Generated/AST/PackedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[302]) || tp >= &(gTypes[303])) { + if (tp < &(gTypes[306]) || tp >= &(gTypes[307])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PackedAttr::static_kind(): - tp = &(gTypes[302]); + tp = &(gTypes[306]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[302]); + PyTypeObject * const tp = &(gTypes[306]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ParamTypestateAttr.cpp b/bindings/Python/Generated/AST/ParamTypestateAttr.cpp index fc9ee9577..074fd3226 100644 --- a/bindings/Python/Generated/AST/ParamTypestateAttr.cpp +++ b/bindings/Python/Generated/AST/ParamTypestateAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[301]) || tp >= &(gTypes[302])) { + if (tp < &(gTypes[305]) || tp >= &(gTypes[306])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ParamTypestateAttr::static_kind(): - tp = &(gTypes[301]); + tp = &(gTypes[305]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[301]); + PyTypeObject * const tp = &(gTypes[305]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ParameterABIAttr.cpp b/bindings/Python/Generated/AST/ParameterABIAttr.cpp index 59e9201f1..9a11d3a74 100644 --- a/bindings/Python/Generated/AST/ParameterABIAttr.cpp +++ b/bindings/Python/Generated/AST/ParameterABIAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[399]) || tp >= &(gTypes[404])) { + if (tp < &(gTypes[403]) || tp >= &(gTypes[408])) { return std::nullopt; } @@ -88,19 +88,19 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftIndirectResultAttr::static_kind(): - tp = &(gTypes[400]); + tp = &(gTypes[404]); break; case mx::SwiftErrorResultAttr::static_kind(): - tp = &(gTypes[401]); + tp = &(gTypes[405]); break; case mx::SwiftContextAttr::static_kind(): - tp = &(gTypes[402]); + tp = &(gTypes[406]); break; case mx::SwiftAsyncContextAttr::static_kind(): - tp = &(gTypes[403]); + tp = &(gTypes[407]); break; } @@ -284,7 +284,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -336,7 +336,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[399]); + PyTypeObject * const tp = &(gTypes[403]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -351,12 +351,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ParenExpr.cpp b/bindings/Python/Generated/AST/ParenExpr.cpp index 8cb35c73a..c1fdf764a 100644 --- a/bindings/Python/Generated/AST/ParenExpr.cpp +++ b/bindings/Python/Generated/AST/ParenExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[672]) || tp >= &(gTypes[673])) { + if (tp < &(gTypes[676]) || tp >= &(gTypes[677])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ParenExpr::static_kind(): - tp = &(gTypes[672]); + tp = &(gTypes[676]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[672]); + PyTypeObject * const tp = &(gTypes[676]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ParenListExpr.cpp b/bindings/Python/Generated/AST/ParenListExpr.cpp index 1a61c7a16..3f1a0ed32 100644 --- a/bindings/Python/Generated/AST/ParenListExpr.cpp +++ b/bindings/Python/Generated/AST/ParenListExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[671]) || tp >= &(gTypes[672])) { + if (tp < &(gTypes[675]) || tp >= &(gTypes[676])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ParenListExpr::static_kind(): - tp = &(gTypes[671]); + tp = &(gTypes[675]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -411,7 +411,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[671]); + PyTypeObject * const tp = &(gTypes[675]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -426,12 +426,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ParenType.cpp b/bindings/Python/Generated/AST/ParenType.cpp index 659b6f55b..f05f4dcbe 100644 --- a/bindings/Python/Generated/AST/ParenType.cpp +++ b/bindings/Python/Generated/AST/ParenType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[424]) || tp >= &(gTypes[425])) { + if (tp < &(gTypes[428]) || tp >= &(gTypes[429])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ParenType::static_kind(): - tp = &(gTypes[424]); + tp = &(gTypes[428]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[424]); + PyTypeObject * const tp = &(gTypes[428]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ParmVarDecl.cpp b/bindings/Python/Generated/AST/ParmVarDecl.cpp index 93a29fda8..a6ec98c1b 100644 --- a/bindings/Python/Generated/AST/ParmVarDecl.cpp +++ b/bindings/Python/Generated/AST/ParmVarDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[754]) || tp >= &(gTypes[755])) { + if (tp < &(gTypes[758]) || tp >= &(gTypes[759])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ParmVarDecl::static_kind(): - tp = &(gTypes[754]); + tp = &(gTypes[758]); break; } @@ -509,7 +509,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -539,7 +539,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[754]); + PyTypeObject * const tp = &(gTypes[758]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -554,12 +554,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[753].tp_hash; - tp->tp_richcompare = gTypes[753].tp_richcompare; + tp->tp_hash = gTypes[757].tp_hash; + tp->tp_richcompare = gTypes[757].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[753]); + tp->tp_base = &(gTypes[757]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PascalAttr.cpp b/bindings/Python/Generated/AST/PascalAttr.cpp index d5a50cf39..c5c0a3f1b 100644 --- a/bindings/Python/Generated/AST/PascalAttr.cpp +++ b/bindings/Python/Generated/AST/PascalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[300]) || tp >= &(gTypes[301])) { + if (tp < &(gTypes[304]) || tp >= &(gTypes[305])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PascalAttr::static_kind(): - tp = &(gTypes[300]); + tp = &(gTypes[304]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[300]); + PyTypeObject * const tp = &(gTypes[304]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp b/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp index 71cbc6567..647737517 100644 --- a/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp +++ b/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[398]) || tp >= &(gTypes[399])) { + if (tp < &(gTypes[402]) || tp >= &(gTypes[403])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PassObjectSizeAttr::static_kind(): - tp = &(gTypes[398]); + tp = &(gTypes[402]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[398]); + PyTypeObject * const tp = &(gTypes[402]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp b/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp index 843ab0578..9dc517475 100644 --- a/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp +++ b/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[299]) || tp >= &(gTypes[300])) { + if (tp < &(gTypes[303]) || tp >= &(gTypes[304])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PatchableFunctionEntryAttr::static_kind(): - tp = &(gTypes[299]); + tp = &(gTypes[303]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[299]); + PyTypeObject * const tp = &(gTypes[303]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PcsAttr.cpp b/bindings/Python/Generated/AST/PcsAttr.cpp index f196d6201..b1e9f4855 100644 --- a/bindings/Python/Generated/AST/PcsAttr.cpp +++ b/bindings/Python/Generated/AST/PcsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[298]) || tp >= &(gTypes[299])) { + if (tp < &(gTypes[302]) || tp >= &(gTypes[303])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PcsAttr::static_kind(): - tp = &(gTypes[298]); + tp = &(gTypes[302]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[298]); + PyTypeObject * const tp = &(gTypes[302]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PipeType.cpp b/bindings/Python/Generated/AST/PipeType.cpp index 14455151a..757b6fb52 100644 --- a/bindings/Python/Generated/AST/PipeType.cpp +++ b/bindings/Python/Generated/AST/PipeType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[423]) || tp >= &(gTypes[424])) { + if (tp < &(gTypes[427]) || tp >= &(gTypes[428])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PipeType::static_kind(): - tp = &(gTypes[423]); + tp = &(gTypes[427]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[423]); + PyTypeObject * const tp = &(gTypes[427]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PointerAttr.cpp b/bindings/Python/Generated/AST/PointerAttr.cpp index c220e66bf..bedc24685 100644 --- a/bindings/Python/Generated/AST/PointerAttr.cpp +++ b/bindings/Python/Generated/AST/PointerAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[297]) || tp >= &(gTypes[298])) { + if (tp < &(gTypes[301]) || tp >= &(gTypes[302])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PointerAttr::static_kind(): - tp = &(gTypes[297]); + tp = &(gTypes[301]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[297]); + PyTypeObject * const tp = &(gTypes[301]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PointerType.cpp b/bindings/Python/Generated/AST/PointerType.cpp index 5bd5c7fda..61dd90f2b 100644 --- a/bindings/Python/Generated/AST/PointerType.cpp +++ b/bindings/Python/Generated/AST/PointerType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[422]) || tp >= &(gTypes[423])) { + if (tp < &(gTypes[426]) || tp >= &(gTypes[427])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PointerType::static_kind(): - tp = &(gTypes[422]); + tp = &(gTypes[426]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[422]); + PyTypeObject * const tp = &(gTypes[426]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp index f6b0150a0..7f90d6285 100644 --- a/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp +++ b/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[296]) || tp >= &(gTypes[297])) { + if (tp < &(gTypes[300]) || tp >= &(gTypes[301])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaClangBSSSectionAttr::static_kind(): - tp = &(gTypes[296]); + tp = &(gTypes[300]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[296]); + PyTypeObject * const tp = &(gTypes[300]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp index eaf62433c..c6e35962a 100644 --- a/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp +++ b/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[295]) || tp >= &(gTypes[296])) { + if (tp < &(gTypes[299]) || tp >= &(gTypes[300])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaClangDataSectionAttr::static_kind(): - tp = &(gTypes[295]); + tp = &(gTypes[299]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[295]); + PyTypeObject * const tp = &(gTypes[299]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp index 900a792d7..bf7ef1aeb 100644 --- a/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp +++ b/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[294]) || tp >= &(gTypes[295])) { + if (tp < &(gTypes[298]) || tp >= &(gTypes[299])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaClangRelroSectionAttr::static_kind(): - tp = &(gTypes[294]); + tp = &(gTypes[298]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[294]); + PyTypeObject * const tp = &(gTypes[298]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp index 98f5cb951..7cd6ffdbe 100644 --- a/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp +++ b/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[293]) || tp >= &(gTypes[294])) { + if (tp < &(gTypes[297]) || tp >= &(gTypes[298])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaClangRodataSectionAttr::static_kind(): - tp = &(gTypes[293]); + tp = &(gTypes[297]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[293]); + PyTypeObject * const tp = &(gTypes[297]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp index 1ac2bb194..5f99ee5f4 100644 --- a/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp +++ b/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[292]) || tp >= &(gTypes[293])) { + if (tp < &(gTypes[296]) || tp >= &(gTypes[297])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaClangTextSectionAttr::static_kind(): - tp = &(gTypes[292]); + tp = &(gTypes[296]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[292]); + PyTypeObject * const tp = &(gTypes[296]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PragmaCommentDecl.cpp b/bindings/Python/Generated/AST/PragmaCommentDecl.cpp index 09225534d..a441b3077 100644 --- a/bindings/Python/Generated/AST/PragmaCommentDecl.cpp +++ b/bindings/Python/Generated/AST/PragmaCommentDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[736]) || tp >= &(gTypes[737])) { + if (tp < &(gTypes[740]) || tp >= &(gTypes[741])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaCommentDecl::static_kind(): - tp = &(gTypes[736]); + tp = &(gTypes[740]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[736]); + PyTypeObject * const tp = &(gTypes[740]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp b/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp index 6a59e1f99..868e53c66 100644 --- a/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp +++ b/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[735]) || tp >= &(gTypes[736])) { + if (tp < &(gTypes[739]) || tp >= &(gTypes[740])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaDetectMismatchDecl::static_kind(): - tp = &(gTypes[735]); + tp = &(gTypes[739]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[735]); + PyTypeObject * const tp = &(gTypes[739]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PredefinedExpr.cpp b/bindings/Python/Generated/AST/PredefinedExpr.cpp index 656ad2724..d5a4641d3 100644 --- a/bindings/Python/Generated/AST/PredefinedExpr.cpp +++ b/bindings/Python/Generated/AST/PredefinedExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[670]) || tp >= &(gTypes[671])) { + if (tp < &(gTypes[674]) || tp >= &(gTypes[675])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PredefinedExpr::static_kind(): - tp = &(gTypes[670]); + tp = &(gTypes[674]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[670]); + PyTypeObject * const tp = &(gTypes[674]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PreferredNameAttr.cpp b/bindings/Python/Generated/AST/PreferredNameAttr.cpp index 6332a123f..9a68048c9 100644 --- a/bindings/Python/Generated/AST/PreferredNameAttr.cpp +++ b/bindings/Python/Generated/AST/PreferredNameAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[291]) || tp >= &(gTypes[292])) { + if (tp < &(gTypes[295]) || tp >= &(gTypes[296])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PreferredNameAttr::static_kind(): - tp = &(gTypes[291]); + tp = &(gTypes[295]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[291]); + PyTypeObject * const tp = &(gTypes[295]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PreferredTypeAttr.cpp b/bindings/Python/Generated/AST/PreferredTypeAttr.cpp index f4950a44a..ca273725c 100644 --- a/bindings/Python/Generated/AST/PreferredTypeAttr.cpp +++ b/bindings/Python/Generated/AST/PreferredTypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[290]) || tp >= &(gTypes[291])) { + if (tp < &(gTypes[294]) || tp >= &(gTypes[295])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PreferredTypeAttr::static_kind(): - tp = &(gTypes[290]); + tp = &(gTypes[294]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[290]); + PyTypeObject * const tp = &(gTypes[294]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PreserveAllAttr.cpp b/bindings/Python/Generated/AST/PreserveAllAttr.cpp index 787a473ab..7194294a2 100644 --- a/bindings/Python/Generated/AST/PreserveAllAttr.cpp +++ b/bindings/Python/Generated/AST/PreserveAllAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[289]) || tp >= &(gTypes[290])) { + if (tp < &(gTypes[293]) || tp >= &(gTypes[294])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PreserveAllAttr::static_kind(): - tp = &(gTypes[289]); + tp = &(gTypes[293]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[289]); + PyTypeObject * const tp = &(gTypes[293]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PreserveMostAttr.cpp b/bindings/Python/Generated/AST/PreserveMostAttr.cpp index 205295eab..2a6287438 100644 --- a/bindings/Python/Generated/AST/PreserveMostAttr.cpp +++ b/bindings/Python/Generated/AST/PreserveMostAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[288]) || tp >= &(gTypes[289])) { + if (tp < &(gTypes[292]) || tp >= &(gTypes[293])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PreserveMostAttr::static_kind(): - tp = &(gTypes[288]); + tp = &(gTypes[292]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[288]); + PyTypeObject * const tp = &(gTypes[292]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PseudoObjectExpr.cpp b/bindings/Python/Generated/AST/PseudoObjectExpr.cpp index a809884a6..150039ac6 100644 --- a/bindings/Python/Generated/AST/PseudoObjectExpr.cpp +++ b/bindings/Python/Generated/AST/PseudoObjectExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[669]) || tp >= &(gTypes[670])) { + if (tp < &(gTypes[673]) || tp >= &(gTypes[674])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PseudoObjectExpr::static_kind(): - tp = &(gTypes[669]); + tp = &(gTypes[673]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -463,7 +463,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[669]); + PyTypeObject * const tp = &(gTypes[673]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -478,12 +478,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PtGuardedByAttr.cpp b/bindings/Python/Generated/AST/PtGuardedByAttr.cpp index e57088d39..99d430e09 100644 --- a/bindings/Python/Generated/AST/PtGuardedByAttr.cpp +++ b/bindings/Python/Generated/AST/PtGuardedByAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[287]) || tp >= &(gTypes[288])) { + if (tp < &(gTypes[291]) || tp >= &(gTypes[292])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PtGuardedByAttr::static_kind(): - tp = &(gTypes[287]); + tp = &(gTypes[291]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[287]); + PyTypeObject * const tp = &(gTypes[291]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp b/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp index 1ae4f15d3..cc3978d12 100644 --- a/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp +++ b/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[286]) || tp >= &(gTypes[287])) { + if (tp < &(gTypes[290]) || tp >= &(gTypes[291])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PtGuardedVarAttr::static_kind(): - tp = &(gTypes[286]); + tp = &(gTypes[290]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[286]); + PyTypeObject * const tp = &(gTypes[290]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Ptr32Attr.cpp b/bindings/Python/Generated/AST/Ptr32Attr.cpp index 13a4b8808..6370318e9 100644 --- a/bindings/Python/Generated/AST/Ptr32Attr.cpp +++ b/bindings/Python/Generated/AST/Ptr32Attr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[13]) || tp >= &(gTypes[14])) { + if (tp < &(gTypes[17]) || tp >= &(gTypes[18])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::Ptr32Attr::static_kind(): - tp = &(gTypes[13]); + tp = &(gTypes[17]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[13]); + PyTypeObject * const tp = &(gTypes[17]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Ptr64Attr.cpp b/bindings/Python/Generated/AST/Ptr64Attr.cpp index 3db5d2219..a398ad336 100644 --- a/bindings/Python/Generated/AST/Ptr64Attr.cpp +++ b/bindings/Python/Generated/AST/Ptr64Attr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[12]) || tp >= &(gTypes[13])) { + if (tp < &(gTypes[16]) || tp >= &(gTypes[17])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::Ptr64Attr::static_kind(): - tp = &(gTypes[12]); + tp = &(gTypes[16]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[12]); + PyTypeObject * const tp = &(gTypes[16]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/PureAttr.cpp b/bindings/Python/Generated/AST/PureAttr.cpp index 8ee822f13..167253fdf 100644 --- a/bindings/Python/Generated/AST/PureAttr.cpp +++ b/bindings/Python/Generated/AST/PureAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[285]) || tp >= &(gTypes[286])) { + if (tp < &(gTypes[289]) || tp >= &(gTypes[290])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PureAttr::static_kind(): - tp = &(gTypes[285]); + tp = &(gTypes[289]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[285]); + PyTypeObject * const tp = &(gTypes[289]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/QualifiedType.cpp b/bindings/Python/Generated/AST/QualifiedType.cpp index 5b725d2ab..cc690973e 100644 --- a/bindings/Python/Generated/AST/QualifiedType.cpp +++ b/bindings/Python/Generated/AST/QualifiedType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[421]) || tp >= &(gTypes[422])) { + if (tp < &(gTypes[425]) || tp >= &(gTypes[426])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::QualifiedType::static_kind(): - tp = &(gTypes[421]); + tp = &(gTypes[425]); break; } @@ -623,7 +623,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -675,7 +675,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[421]); + PyTypeObject * const tp = &(gTypes[425]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -690,12 +690,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp b/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp index c8c5faac4..98af23fc6 100644 --- a/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp +++ b/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[284]) || tp >= &(gTypes[285])) { + if (tp < &(gTypes[288]) || tp >= &(gTypes[289])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RISCVInterruptAttr::static_kind(): - tp = &(gTypes[284]); + tp = &(gTypes[288]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[284]); + PyTypeObject * const tp = &(gTypes[288]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RValueReferenceType.cpp b/bindings/Python/Generated/AST/RValueReferenceType.cpp index 5f8a9465c..4fdfde70d 100644 --- a/bindings/Python/Generated/AST/RValueReferenceType.cpp +++ b/bindings/Python/Generated/AST/RValueReferenceType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[419]) || tp >= &(gTypes[420])) { + if (tp < &(gTypes[423]) || tp >= &(gTypes[424])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RValueReferenceType::static_kind(): - tp = &(gTypes[419]); + tp = &(gTypes[423]); break; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -325,7 +325,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[419]); + PyTypeObject * const tp = &(gTypes[423]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -340,12 +340,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[418].tp_hash; - tp->tp_richcompare = gTypes[418].tp_richcompare; + tp->tp_hash = gTypes[422].tp_hash; + tp->tp_richcompare = gTypes[422].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[418]); + tp->tp_base = &(gTypes[422]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp b/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp index f8ff4abe3..ba9bf97ee 100644 --- a/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp +++ b/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[283]) || tp >= &(gTypes[284])) { + if (tp < &(gTypes[287]) || tp >= &(gTypes[288])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RandomizeLayoutAttr::static_kind(): - tp = &(gTypes[283]); + tp = &(gTypes[287]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[283]); + PyTypeObject * const tp = &(gTypes[287]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp b/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp index 20a2a356c..d5b3f59ba 100644 --- a/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp +++ b/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[282]) || tp >= &(gTypes[283])) { + if (tp < &(gTypes[286]) || tp >= &(gTypes[287])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReadOnlyPlacementAttr::static_kind(): - tp = &(gTypes[282]); + tp = &(gTypes[286]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[282]); + PyTypeObject * const tp = &(gTypes[286]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RecordDecl.cpp b/bindings/Python/Generated/AST/RecordDecl.cpp index e0389f576..c69fc4a23 100644 --- a/bindings/Python/Generated/AST/RecordDecl.cpp +++ b/bindings/Python/Generated/AST/RecordDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[782]) || tp >= &(gTypes[786])) { + if (tp < &(gTypes[786]) || tp >= &(gTypes[790])) { return std::nullopt; } @@ -88,19 +88,19 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RecordDecl::static_kind(): - tp = &(gTypes[782]); + tp = &(gTypes[786]); break; case mx::CXXRecordDecl::static_kind(): - tp = &(gTypes[783]); + tp = &(gTypes[787]); break; case mx::ClassTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[784]); + tp = &(gTypes[788]); break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; } @@ -621,7 +621,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -673,7 +673,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[782]); + PyTypeObject * const tp = &(gTypes[786]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -688,12 +688,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[781].tp_hash; - tp->tp_richcompare = gTypes[781].tp_richcompare; + tp->tp_hash = gTypes[785].tp_hash; + tp->tp_richcompare = gTypes[785].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[781]); + tp->tp_base = &(gTypes[785]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RecordType.cpp b/bindings/Python/Generated/AST/RecordType.cpp index 61004ecdb..385a709a7 100644 --- a/bindings/Python/Generated/AST/RecordType.cpp +++ b/bindings/Python/Generated/AST/RecordType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[414]) || tp >= &(gTypes[415])) { + if (tp < &(gTypes[418]) || tp >= &(gTypes[419])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RecordType::static_kind(): - tp = &(gTypes[414]); + tp = &(gTypes[418]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[414]); + PyTypeObject * const tp = &(gTypes[418]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[413].tp_hash; - tp->tp_richcompare = gTypes[413].tp_richcompare; + tp->tp_hash = gTypes[417].tp_hash; + tp->tp_richcompare = gTypes[417].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[413]); + tp->tp_base = &(gTypes[417]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RecoveryExpr.cpp b/bindings/Python/Generated/AST/RecoveryExpr.cpp index a581ab28f..06b5e565d 100644 --- a/bindings/Python/Generated/AST/RecoveryExpr.cpp +++ b/bindings/Python/Generated/AST/RecoveryExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[668]) || tp >= &(gTypes[669])) { + if (tp < &(gTypes[672]) || tp >= &(gTypes[673])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RecoveryExpr::static_kind(): - tp = &(gTypes[668]); + tp = &(gTypes[672]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -391,7 +391,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[668]); + PyTypeObject * const tp = &(gTypes[672]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -406,12 +406,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp b/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp index 9917e1529..af2d6aaa9 100644 --- a/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp +++ b/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[793]) || tp >= &(gTypes[798])) { + if (tp < &(gTypes[797]) || tp >= &(gTypes[802])) { return std::nullopt; } @@ -88,19 +88,19 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionTemplateDecl::static_kind(): - tp = &(gTypes[794]); + tp = &(gTypes[798]); break; case mx::ClassTemplateDecl::static_kind(): - tp = &(gTypes[795]); + tp = &(gTypes[799]); break; case mx::VarTemplateDecl::static_kind(): - tp = &(gTypes[796]); + tp = &(gTypes[800]); break; case mx::TypeAliasTemplateDecl::static_kind(): - tp = &(gTypes[797]); + tp = &(gTypes[801]); break; } @@ -354,7 +354,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -384,7 +384,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[793]); + PyTypeObject * const tp = &(gTypes[797]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -399,12 +399,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[792].tp_hash; - tp->tp_richcompare = gTypes[792].tp_richcompare; + tp->tp_hash = gTypes[796].tp_hash; + tp->tp_richcompare = gTypes[796].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[792]); + tp->tp_base = &(gTypes[796]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReferenceType.cpp b/bindings/Python/Generated/AST/ReferenceType.cpp index cc07f2608..c78b7e1db 100644 --- a/bindings/Python/Generated/AST/ReferenceType.cpp +++ b/bindings/Python/Generated/AST/ReferenceType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[418]) || tp >= &(gTypes[421])) { + if (tp < &(gTypes[422]) || tp >= &(gTypes[425])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RValueReferenceType::static_kind(): - tp = &(gTypes[419]); + tp = &(gTypes[423]); break; case mx::LValueReferenceType::static_kind(): - tp = &(gTypes[420]); + tp = &(gTypes[424]); break; } @@ -290,7 +290,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -342,7 +342,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[418]); + PyTypeObject * const tp = &(gTypes[422]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -357,12 +357,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RegCallAttr.cpp b/bindings/Python/Generated/AST/RegCallAttr.cpp index 3f4db4436..12b4ee441 100644 --- a/bindings/Python/Generated/AST/RegCallAttr.cpp +++ b/bindings/Python/Generated/AST/RegCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[281]) || tp >= &(gTypes[282])) { + if (tp < &(gTypes[285]) || tp >= &(gTypes[286])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RegCallAttr::static_kind(): - tp = &(gTypes[281]); + tp = &(gTypes[285]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[281]); + PyTypeObject * const tp = &(gTypes[285]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReinitializesAttr.cpp b/bindings/Python/Generated/AST/ReinitializesAttr.cpp index 68cc4b089..52b7446d6 100644 --- a/bindings/Python/Generated/AST/ReinitializesAttr.cpp +++ b/bindings/Python/Generated/AST/ReinitializesAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[280]) || tp >= &(gTypes[281])) { + if (tp < &(gTypes[284]) || tp >= &(gTypes[285])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReinitializesAttr::static_kind(): - tp = &(gTypes[280]); + tp = &(gTypes[284]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[280]); + PyTypeObject * const tp = &(gTypes[284]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp b/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp index d71f4cf57..c36983f53 100644 --- a/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp +++ b/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[279]) || tp >= &(gTypes[280])) { + if (tp < &(gTypes[283]) || tp >= &(gTypes[284])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReleaseCapabilityAttr::static_kind(): - tp = &(gTypes[279]); + tp = &(gTypes[283]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[279]); + PyTypeObject * const tp = &(gTypes[283]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp b/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp index ea733840b..30bc5e887 100644 --- a/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp +++ b/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[397]) || tp >= &(gTypes[398])) { + if (tp < &(gTypes[401]) || tp >= &(gTypes[402])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReleaseHandleAttr::static_kind(): - tp = &(gTypes[397]); + tp = &(gTypes[401]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[397]); + PyTypeObject * const tp = &(gTypes[401]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp b/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp index 0adef67af..9bcc27c30 100644 --- a/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp +++ b/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[55]) || tp >= &(gTypes[56])) { + if (tp < &(gTypes[59]) || tp >= &(gTypes[60])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RenderScriptKernelAttr::static_kind(): - tp = &(gTypes[55]); + tp = &(gTypes[59]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[55]); + PyTypeObject * const tp = &(gTypes[59]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp b/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp index 364697248..d5951f11f 100644 --- a/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp +++ b/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[278]) || tp >= &(gTypes[279])) { + if (tp < &(gTypes[282]) || tp >= &(gTypes[283])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReqdWorkGroupSizeAttr::static_kind(): - tp = &(gTypes[278]); + tp = &(gTypes[282]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[278]); + PyTypeObject * const tp = &(gTypes[282]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp b/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp index 18a5bde5c..6354c9293 100644 --- a/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp +++ b/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[277]) || tp >= &(gTypes[278])) { + if (tp < &(gTypes[281]) || tp >= &(gTypes[282])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RequiresCapabilityAttr::static_kind(): - tp = &(gTypes[277]); + tp = &(gTypes[281]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[277]); + PyTypeObject * const tp = &(gTypes[281]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RequiresExpr.cpp b/bindings/Python/Generated/AST/RequiresExpr.cpp index 775dffeac..18461761d 100644 --- a/bindings/Python/Generated/AST/RequiresExpr.cpp +++ b/bindings/Python/Generated/AST/RequiresExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[667]) || tp >= &(gTypes[668])) { + if (tp < &(gTypes[671]) || tp >= &(gTypes[672])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RequiresExpr::static_kind(): - tp = &(gTypes[667]); + tp = &(gTypes[671]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -441,7 +441,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[667]); + PyTypeObject * const tp = &(gTypes[671]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -456,12 +456,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp b/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp index 96a8a36cb..c49b46707 100644 --- a/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp +++ b/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[734]) || tp >= &(gTypes[735])) { + if (tp < &(gTypes[738]) || tp >= &(gTypes[739])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RequiresExprBodyDecl::static_kind(): - tp = &(gTypes[734]); + tp = &(gTypes[738]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[734]); + PyTypeObject * const tp = &(gTypes[738]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RestrictAttr.cpp b/bindings/Python/Generated/AST/RestrictAttr.cpp index 91db6a04e..895baa4fe 100644 --- a/bindings/Python/Generated/AST/RestrictAttr.cpp +++ b/bindings/Python/Generated/AST/RestrictAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[276]) || tp >= &(gTypes[277])) { + if (tp < &(gTypes[280]) || tp >= &(gTypes[281])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RestrictAttr::static_kind(): - tp = &(gTypes[276]); + tp = &(gTypes[280]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[276]); + PyTypeObject * const tp = &(gTypes[280]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/RetainAttr.cpp b/bindings/Python/Generated/AST/RetainAttr.cpp index 7b1a6429f..ac3a151f1 100644 --- a/bindings/Python/Generated/AST/RetainAttr.cpp +++ b/bindings/Python/Generated/AST/RetainAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[275]) || tp >= &(gTypes[276])) { + if (tp < &(gTypes[279]) || tp >= &(gTypes[280])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RetainAttr::static_kind(): - tp = &(gTypes[275]); + tp = &(gTypes[279]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[275]); + PyTypeObject * const tp = &(gTypes[279]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReturnStmt.cpp b/bindings/Python/Generated/AST/ReturnStmt.cpp index 1ca1c408c..83948276a 100644 --- a/bindings/Python/Generated/AST/ReturnStmt.cpp +++ b/bindings/Python/Generated/AST/ReturnStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[478]) || tp >= &(gTypes[479])) { + if (tp < &(gTypes[482]) || tp >= &(gTypes[483])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReturnStmt::static_kind(): - tp = &(gTypes[478]); + tp = &(gTypes[482]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[478]); + PyTypeObject * const tp = &(gTypes[482]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp b/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp index 668f4ac0b..d415815a0 100644 --- a/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp +++ b/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[274]) || tp >= &(gTypes[275])) { + if (tp < &(gTypes[278]) || tp >= &(gTypes[279])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReturnTypestateAttr::static_kind(): - tp = &(gTypes[274]); + tp = &(gTypes[278]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[274]); + PyTypeObject * const tp = &(gTypes[278]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp b/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp index fbc702c90..d4056b497 100644 --- a/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp +++ b/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[273]) || tp >= &(gTypes[274])) { + if (tp < &(gTypes[277]) || tp >= &(gTypes[278])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReturnsNonNullAttr::static_kind(): - tp = &(gTypes[273]); + tp = &(gTypes[277]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[273]); + PyTypeObject * const tp = &(gTypes[277]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp b/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp index c84b6fcaf..9fe76f85f 100644 --- a/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp +++ b/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[272]) || tp >= &(gTypes[273])) { + if (tp < &(gTypes[276]) || tp >= &(gTypes[277])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ReturnsTwiceAttr::static_kind(): - tp = &(gTypes[272]); + tp = &(gTypes[276]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[272]); + PyTypeObject * const tp = &(gTypes[276]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SEHExceptStmt.cpp b/bindings/Python/Generated/AST/SEHExceptStmt.cpp index 01aa6ff91..47d8c6c2a 100644 --- a/bindings/Python/Generated/AST/SEHExceptStmt.cpp +++ b/bindings/Python/Generated/AST/SEHExceptStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[477]) || tp >= &(gTypes[478])) { + if (tp < &(gTypes[481]) || tp >= &(gTypes[482])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SEHExceptStmt::static_kind(): - tp = &(gTypes[477]); + tp = &(gTypes[481]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[477]); + PyTypeObject * const tp = &(gTypes[481]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SEHFinallyStmt.cpp b/bindings/Python/Generated/AST/SEHFinallyStmt.cpp index 4e929bed8..802f4b30c 100644 --- a/bindings/Python/Generated/AST/SEHFinallyStmt.cpp +++ b/bindings/Python/Generated/AST/SEHFinallyStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[476]) || tp >= &(gTypes[477])) { + if (tp < &(gTypes[480]) || tp >= &(gTypes[481])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SEHFinallyStmt::static_kind(): - tp = &(gTypes[476]); + tp = &(gTypes[480]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[476]); + PyTypeObject * const tp = &(gTypes[480]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SEHLeaveStmt.cpp b/bindings/Python/Generated/AST/SEHLeaveStmt.cpp index 25a54bc5f..317c6bc15 100644 --- a/bindings/Python/Generated/AST/SEHLeaveStmt.cpp +++ b/bindings/Python/Generated/AST/SEHLeaveStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[475]) || tp >= &(gTypes[476])) { + if (tp < &(gTypes[479]) || tp >= &(gTypes[480])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SEHLeaveStmt::static_kind(): - tp = &(gTypes[475]); + tp = &(gTypes[479]); break; } @@ -329,7 +329,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[475]); + PyTypeObject * const tp = &(gTypes[479]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -374,12 +374,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SEHTryStmt.cpp b/bindings/Python/Generated/AST/SEHTryStmt.cpp index 15e301583..d6fe30b7a 100644 --- a/bindings/Python/Generated/AST/SEHTryStmt.cpp +++ b/bindings/Python/Generated/AST/SEHTryStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[474]) || tp >= &(gTypes[475])) { + if (tp < &(gTypes[478]) || tp >= &(gTypes[479])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SEHTryStmt::static_kind(): - tp = &(gTypes[474]); + tp = &(gTypes[478]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[474]); + PyTypeObject * const tp = &(gTypes[478]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SPtrAttr.cpp b/bindings/Python/Generated/AST/SPtrAttr.cpp index a26efab23..5406de25d 100644 --- a/bindings/Python/Generated/AST/SPtrAttr.cpp +++ b/bindings/Python/Generated/AST/SPtrAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[11]) || tp >= &(gTypes[12])) { + if (tp < &(gTypes[15]) || tp >= &(gTypes[16])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SPtrAttr::static_kind(): - tp = &(gTypes[11]); + tp = &(gTypes[15]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[11]); + PyTypeObject * const tp = &(gTypes[15]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SYCLKernelAttr.cpp b/bindings/Python/Generated/AST/SYCLKernelAttr.cpp index b144c3d3c..33f1c22ce 100644 --- a/bindings/Python/Generated/AST/SYCLKernelAttr.cpp +++ b/bindings/Python/Generated/AST/SYCLKernelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[271]) || tp >= &(gTypes[272])) { + if (tp < &(gTypes[275]) || tp >= &(gTypes[276])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SYCLKernelAttr::static_kind(): - tp = &(gTypes[271]); + tp = &(gTypes[275]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[271]); + PyTypeObject * const tp = &(gTypes[275]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp b/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp index 673262b04..c7a15a473 100644 --- a/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp +++ b/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[270]) || tp >= &(gTypes[271])) { + if (tp < &(gTypes[274]) || tp >= &(gTypes[275])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SYCLSpecialClassAttr::static_kind(): - tp = &(gTypes[270]); + tp = &(gTypes[274]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[270]); + PyTypeObject * const tp = &(gTypes[274]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp b/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp index 6e1ffe264..fad3032dd 100644 --- a/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp +++ b/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[666]) || tp >= &(gTypes[667])) { + if (tp < &(gTypes[670]) || tp >= &(gTypes[671])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SYCLUniqueStableNameExpr::static_kind(): - tp = &(gTypes[666]); + tp = &(gTypes[670]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[666]); + PyTypeObject * const tp = &(gTypes[670]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ScopedLockableAttr.cpp b/bindings/Python/Generated/AST/ScopedLockableAttr.cpp index 32e2b2205..109a95072 100644 --- a/bindings/Python/Generated/AST/ScopedLockableAttr.cpp +++ b/bindings/Python/Generated/AST/ScopedLockableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[269]) || tp >= &(gTypes[270])) { + if (tp < &(gTypes[273]) || tp >= &(gTypes[274])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ScopedLockableAttr::static_kind(): - tp = &(gTypes[269]); + tp = &(gTypes[273]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[269]); + PyTypeObject * const tp = &(gTypes[273]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SectionAttr.cpp b/bindings/Python/Generated/AST/SectionAttr.cpp index 5b14cce8e..f22656f87 100644 --- a/bindings/Python/Generated/AST/SectionAttr.cpp +++ b/bindings/Python/Generated/AST/SectionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[268]) || tp >= &(gTypes[269])) { + if (tp < &(gTypes[272]) || tp >= &(gTypes[273])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SectionAttr::static_kind(): - tp = &(gTypes[268]); + tp = &(gTypes[272]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[268]); + PyTypeObject * const tp = &(gTypes[272]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SelectAnyAttr.cpp b/bindings/Python/Generated/AST/SelectAnyAttr.cpp index 4598b40d4..465e6a262 100644 --- a/bindings/Python/Generated/AST/SelectAnyAttr.cpp +++ b/bindings/Python/Generated/AST/SelectAnyAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[267]) || tp >= &(gTypes[268])) { + if (tp < &(gTypes[271]) || tp >= &(gTypes[272])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SelectAnyAttr::static_kind(): - tp = &(gTypes[267]); + tp = &(gTypes[271]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[267]); + PyTypeObject * const tp = &(gTypes[271]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SentinelAttr.cpp b/bindings/Python/Generated/AST/SentinelAttr.cpp index db19e81bc..5c3cb68da 100644 --- a/bindings/Python/Generated/AST/SentinelAttr.cpp +++ b/bindings/Python/Generated/AST/SentinelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[266]) || tp >= &(gTypes[267])) { + if (tp < &(gTypes[270]) || tp >= &(gTypes[271])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SentinelAttr::static_kind(): - tp = &(gTypes[266]); + tp = &(gTypes[270]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[266]); + PyTypeObject * const tp = &(gTypes[270]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SetTypestateAttr.cpp b/bindings/Python/Generated/AST/SetTypestateAttr.cpp index f9764d419..5fa77b27c 100644 --- a/bindings/Python/Generated/AST/SetTypestateAttr.cpp +++ b/bindings/Python/Generated/AST/SetTypestateAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[265]) || tp >= &(gTypes[266])) { + if (tp < &(gTypes[269]) || tp >= &(gTypes[270])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SetTypestateAttr::static_kind(): - tp = &(gTypes[265]); + tp = &(gTypes[269]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[265]); + PyTypeObject * const tp = &(gTypes[269]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp b/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp index 450e209e3..688e98761 100644 --- a/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp +++ b/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[264]) || tp >= &(gTypes[265])) { + if (tp < &(gTypes[268]) || tp >= &(gTypes[269])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SharedTrylockFunctionAttr::static_kind(): - tp = &(gTypes[264]); + tp = &(gTypes[268]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[264]); + PyTypeObject * const tp = &(gTypes[268]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp b/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp index ce71a816c..2a41fa8ea 100644 --- a/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp +++ b/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[665]) || tp >= &(gTypes[666])) { + if (tp < &(gTypes[669]) || tp >= &(gTypes[670])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ShuffleVectorExpr::static_kind(): - tp = &(gTypes[665]); + tp = &(gTypes[669]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[665]); + PyTypeObject * const tp = &(gTypes[669]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SizeOfPackExpr.cpp b/bindings/Python/Generated/AST/SizeOfPackExpr.cpp index 2953f4c91..a3da8f446 100644 --- a/bindings/Python/Generated/AST/SizeOfPackExpr.cpp +++ b/bindings/Python/Generated/AST/SizeOfPackExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[664]) || tp >= &(gTypes[665])) { + if (tp < &(gTypes[668]) || tp >= &(gTypes[669])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SizeOfPackExpr::static_kind(): - tp = &(gTypes[664]); + tp = &(gTypes[668]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[664]); + PyTypeObject * const tp = &(gTypes[668]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SourceLocExpr.cpp b/bindings/Python/Generated/AST/SourceLocExpr.cpp index fee881060..3dc9381d4 100644 --- a/bindings/Python/Generated/AST/SourceLocExpr.cpp +++ b/bindings/Python/Generated/AST/SourceLocExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[663]) || tp >= &(gTypes[664])) { + if (tp < &(gTypes[667]) || tp >= &(gTypes[668])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SourceLocExpr::static_kind(): - tp = &(gTypes[663]); + tp = &(gTypes[667]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[663]); + PyTypeObject * const tp = &(gTypes[667]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp b/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp index e5cd3cb5f..d49c4b970 100644 --- a/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp +++ b/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[263]) || tp >= &(gTypes[264])) { + if (tp < &(gTypes[267]) || tp >= &(gTypes[268])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SpeculativeLoadHardeningAttr::static_kind(): - tp = &(gTypes[263]); + tp = &(gTypes[267]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[263]); + PyTypeObject * const tp = &(gTypes[267]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp b/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp index c0d3fb3ca..402208e9f 100644 --- a/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp +++ b/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[262]) || tp >= &(gTypes[263])) { + if (tp < &(gTypes[266]) || tp >= &(gTypes[267])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::StandaloneDebugAttr::static_kind(): - tp = &(gTypes[262]); + tp = &(gTypes[266]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[262]); + PyTypeObject * const tp = &(gTypes[266]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/StaticAssertDecl.cpp b/bindings/Python/Generated/AST/StaticAssertDecl.cpp index 496768b90..700949a15 100644 --- a/bindings/Python/Generated/AST/StaticAssertDecl.cpp +++ b/bindings/Python/Generated/AST/StaticAssertDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[733]) || tp >= &(gTypes[734])) { + if (tp < &(gTypes[737]) || tp >= &(gTypes[738])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::StaticAssertDecl::static_kind(): - tp = &(gTypes[733]); + tp = &(gTypes[737]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[733]); + PyTypeObject * const tp = &(gTypes[737]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/StdCallAttr.cpp b/bindings/Python/Generated/AST/StdCallAttr.cpp index 434a48a6c..2a6226271 100644 --- a/bindings/Python/Generated/AST/StdCallAttr.cpp +++ b/bindings/Python/Generated/AST/StdCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[261]) || tp >= &(gTypes[262])) { + if (tp < &(gTypes[265]) || tp >= &(gTypes[266])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::StdCallAttr::static_kind(): - tp = &(gTypes[261]); + tp = &(gTypes[265]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[261]); + PyTypeObject * const tp = &(gTypes[265]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Stmt.cpp b/bindings/Python/Generated/AST/Stmt.cpp index 098d11baa..6e6ee9bbb 100644 --- a/bindings/Python/Generated/AST/Stmt.cpp +++ b/bindings/Python/Generated/AST/Stmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[473]) || tp >= &(gTypes[723])) { + if (tp < &(gTypes[477]) || tp >= &(gTypes[727])) { return std::nullopt; } @@ -88,939 +88,939 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SEHTryStmt::static_kind(): - tp = &(gTypes[474]); + tp = &(gTypes[478]); break; case mx::SEHLeaveStmt::static_kind(): - tp = &(gTypes[475]); + tp = &(gTypes[479]); break; case mx::SEHFinallyStmt::static_kind(): - tp = &(gTypes[476]); + tp = &(gTypes[480]); break; case mx::SEHExceptStmt::static_kind(): - tp = &(gTypes[477]); + tp = &(gTypes[481]); break; case mx::ReturnStmt::static_kind(): - tp = &(gTypes[478]); + tp = &(gTypes[482]); break; case mx::ObjCForCollectionStmt::static_kind(): - tp = &(gTypes[479]); + tp = &(gTypes[483]); break; case mx::ObjCAutoreleasePoolStmt::static_kind(): - tp = &(gTypes[480]); + tp = &(gTypes[484]); break; case mx::ObjCAtTryStmt::static_kind(): - tp = &(gTypes[481]); + tp = &(gTypes[485]); break; case mx::ObjCAtThrowStmt::static_kind(): - tp = &(gTypes[482]); + tp = &(gTypes[486]); break; case mx::ObjCAtSynchronizedStmt::static_kind(): - tp = &(gTypes[483]); + tp = &(gTypes[487]); break; case mx::ObjCAtFinallyStmt::static_kind(): - tp = &(gTypes[484]); + tp = &(gTypes[488]); break; case mx::ObjCAtCatchStmt::static_kind(): - tp = &(gTypes[485]); + tp = &(gTypes[489]); break; case mx::OMPErrorDirective::static_kind(): - tp = &(gTypes[487]); + tp = &(gTypes[491]); break; case mx::OMPDispatchDirective::static_kind(): - tp = &(gTypes[488]); + tp = &(gTypes[492]); break; case mx::OMPDepobjDirective::static_kind(): - tp = &(gTypes[489]); + tp = &(gTypes[493]); break; case mx::OMPCriticalDirective::static_kind(): - tp = &(gTypes[490]); + tp = &(gTypes[494]); break; case mx::OMPCancellationPointDirective::static_kind(): - tp = &(gTypes[491]); + tp = &(gTypes[495]); break; case mx::OMPCancelDirective::static_kind(): - tp = &(gTypes[492]); + tp = &(gTypes[496]); break; case mx::OMPBarrierDirective::static_kind(): - tp = &(gTypes[493]); + tp = &(gTypes[497]); break; case mx::OMPAtomicDirective::static_kind(): - tp = &(gTypes[494]); + tp = &(gTypes[498]); break; case mx::OMPTeamsDirective::static_kind(): - tp = &(gTypes[495]); + tp = &(gTypes[499]); break; case mx::OMPTaskyieldDirective::static_kind(): - tp = &(gTypes[496]); + tp = &(gTypes[500]); break; case mx::OMPTaskwaitDirective::static_kind(): - tp = &(gTypes[497]); + tp = &(gTypes[501]); break; case mx::OMPTaskgroupDirective::static_kind(): - tp = &(gTypes[498]); + tp = &(gTypes[502]); break; case mx::OMPTaskDirective::static_kind(): - tp = &(gTypes[499]); + tp = &(gTypes[503]); break; case mx::OMPTargetUpdateDirective::static_kind(): - tp = &(gTypes[500]); + tp = &(gTypes[504]); break; case mx::OMPTargetTeamsDirective::static_kind(): - tp = &(gTypes[501]); + tp = &(gTypes[505]); break; case mx::OMPTargetParallelDirective::static_kind(): - tp = &(gTypes[502]); + tp = &(gTypes[506]); break; case mx::OMPTargetExitDataDirective::static_kind(): - tp = &(gTypes[503]); + tp = &(gTypes[507]); break; case mx::OMPTargetEnterDataDirective::static_kind(): - tp = &(gTypes[504]); + tp = &(gTypes[508]); break; case mx::OMPTargetDirective::static_kind(): - tp = &(gTypes[505]); + tp = &(gTypes[509]); break; case mx::OMPTargetDataDirective::static_kind(): - tp = &(gTypes[506]); + tp = &(gTypes[510]); break; case mx::OMPSingleDirective::static_kind(): - tp = &(gTypes[507]); + tp = &(gTypes[511]); break; case mx::OMPSectionsDirective::static_kind(): - tp = &(gTypes[508]); + tp = &(gTypes[512]); break; case mx::OMPSectionDirective::static_kind(): - tp = &(gTypes[509]); + tp = &(gTypes[513]); break; case mx::OMPScopeDirective::static_kind(): - tp = &(gTypes[510]); + tp = &(gTypes[514]); break; case mx::OMPScanDirective::static_kind(): - tp = &(gTypes[511]); + tp = &(gTypes[515]); break; case mx::OMPParallelSectionsDirective::static_kind(): - tp = &(gTypes[512]); + tp = &(gTypes[516]); break; case mx::OMPParallelMasterDirective::static_kind(): - tp = &(gTypes[513]); + tp = &(gTypes[517]); break; case mx::OMPParallelMaskedDirective::static_kind(): - tp = &(gTypes[514]); + tp = &(gTypes[518]); break; case mx::OMPParallelDirective::static_kind(): - tp = &(gTypes[515]); + tp = &(gTypes[519]); break; case mx::OMPOrderedDirective::static_kind(): - tp = &(gTypes[516]); + tp = &(gTypes[520]); break; case mx::OMPMetaDirective::static_kind(): - tp = &(gTypes[517]); + tp = &(gTypes[521]); break; case mx::OMPMasterDirective::static_kind(): - tp = &(gTypes[518]); + tp = &(gTypes[522]); break; case mx::OMPMaskedDirective::static_kind(): - tp = &(gTypes[519]); + tp = &(gTypes[523]); break; case mx::OMPUnrollDirective::static_kind(): - tp = &(gTypes[522]); + tp = &(gTypes[526]); break; case mx::OMPTileDirective::static_kind(): - tp = &(gTypes[523]); + tp = &(gTypes[527]); break; case mx::OMPGenericLoopDirective::static_kind(): - tp = &(gTypes[525]); + tp = &(gTypes[529]); break; case mx::OMPForSimdDirective::static_kind(): - tp = &(gTypes[526]); + tp = &(gTypes[530]); break; case mx::OMPForDirective::static_kind(): - tp = &(gTypes[527]); + tp = &(gTypes[531]); break; case mx::OMPDistributeSimdDirective::static_kind(): - tp = &(gTypes[528]); + tp = &(gTypes[532]); break; case mx::OMPDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[529]); + tp = &(gTypes[533]); break; case mx::OMPDistributeParallelForDirective::static_kind(): - tp = &(gTypes[530]); + tp = &(gTypes[534]); break; case mx::OMPDistributeDirective::static_kind(): - tp = &(gTypes[531]); + tp = &(gTypes[535]); break; case mx::OMPTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[532]); + tp = &(gTypes[536]); break; case mx::OMPTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[533]); + tp = &(gTypes[537]); break; case mx::OMPTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[534]); + tp = &(gTypes[538]); break; case mx::OMPTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[535]); + tp = &(gTypes[539]); break; case mx::OMPTeamsDistributeDirective::static_kind(): - tp = &(gTypes[536]); + tp = &(gTypes[540]); break; case mx::OMPTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[537]); + tp = &(gTypes[541]); break; case mx::OMPTaskLoopDirective::static_kind(): - tp = &(gTypes[538]); + tp = &(gTypes[542]); break; case mx::OMPTargetTeamsGenericLoopDirective::static_kind(): - tp = &(gTypes[539]); + tp = &(gTypes[543]); break; case mx::OMPTargetTeamsDistributeSimdDirective::static_kind(): - tp = &(gTypes[540]); + tp = &(gTypes[544]); break; case mx::OMPTargetTeamsDistributeParallelForSimdDirective::static_kind(): - tp = &(gTypes[541]); + tp = &(gTypes[545]); break; case mx::OMPTargetTeamsDistributeParallelForDirective::static_kind(): - tp = &(gTypes[542]); + tp = &(gTypes[546]); break; case mx::OMPTargetTeamsDistributeDirective::static_kind(): - tp = &(gTypes[543]); + tp = &(gTypes[547]); break; case mx::OMPTargetSimdDirective::static_kind(): - tp = &(gTypes[544]); + tp = &(gTypes[548]); break; case mx::OMPTargetParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[545]); + tp = &(gTypes[549]); break; case mx::OMPTargetParallelForSimdDirective::static_kind(): - tp = &(gTypes[546]); + tp = &(gTypes[550]); break; case mx::OMPTargetParallelForDirective::static_kind(): - tp = &(gTypes[547]); + tp = &(gTypes[551]); break; case mx::OMPSimdDirective::static_kind(): - tp = &(gTypes[548]); + tp = &(gTypes[552]); break; case mx::OMPParallelMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[549]); + tp = &(gTypes[553]); break; case mx::OMPParallelMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[550]); + tp = &(gTypes[554]); break; case mx::OMPParallelMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[551]); + tp = &(gTypes[555]); break; case mx::OMPParallelMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[552]); + tp = &(gTypes[556]); break; case mx::OMPParallelGenericLoopDirective::static_kind(): - tp = &(gTypes[553]); + tp = &(gTypes[557]); break; case mx::OMPParallelForSimdDirective::static_kind(): - tp = &(gTypes[554]); + tp = &(gTypes[558]); break; case mx::OMPParallelForDirective::static_kind(): - tp = &(gTypes[555]); + tp = &(gTypes[559]); break; case mx::OMPMasterTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[556]); + tp = &(gTypes[560]); break; case mx::OMPMasterTaskLoopDirective::static_kind(): - tp = &(gTypes[557]); + tp = &(gTypes[561]); break; case mx::OMPMaskedTaskLoopSimdDirective::static_kind(): - tp = &(gTypes[558]); + tp = &(gTypes[562]); break; case mx::OMPMaskedTaskLoopDirective::static_kind(): - tp = &(gTypes[559]); + tp = &(gTypes[563]); break; case mx::OMPInteropDirective::static_kind(): - tp = &(gTypes[560]); + tp = &(gTypes[564]); break; case mx::OMPFlushDirective::static_kind(): - tp = &(gTypes[561]); + tp = &(gTypes[565]); break; case mx::OMPCanonicalLoop::static_kind(): - tp = &(gTypes[562]); + tp = &(gTypes[566]); break; case mx::NullStmt::static_kind(): - tp = &(gTypes[563]); + tp = &(gTypes[567]); break; case mx::MSDependentExistsStmt::static_kind(): - tp = &(gTypes[564]); + tp = &(gTypes[568]); break; case mx::IndirectGotoStmt::static_kind(): - tp = &(gTypes[565]); + tp = &(gTypes[569]); break; case mx::IfStmt::static_kind(): - tp = &(gTypes[566]); + tp = &(gTypes[570]); break; case mx::GotoStmt::static_kind(): - tp = &(gTypes[567]); + tp = &(gTypes[571]); break; case mx::ForStmt::static_kind(): - tp = &(gTypes[568]); + tp = &(gTypes[572]); break; case mx::DoStmt::static_kind(): - tp = &(gTypes[569]); + tp = &(gTypes[573]); break; case mx::DeclStmt::static_kind(): - tp = &(gTypes[570]); + tp = &(gTypes[574]); break; case mx::CoroutineBodyStmt::static_kind(): - tp = &(gTypes[571]); + tp = &(gTypes[575]); break; case mx::CoreturnStmt::static_kind(): - tp = &(gTypes[572]); + tp = &(gTypes[576]); break; case mx::ContinueStmt::static_kind(): - tp = &(gTypes[573]); + tp = &(gTypes[577]); break; case mx::CompoundStmt::static_kind(): - tp = &(gTypes[574]); + tp = &(gTypes[578]); break; case mx::CapturedStmt::static_kind(): - tp = &(gTypes[575]); + tp = &(gTypes[579]); break; case mx::CXXTryStmt::static_kind(): - tp = &(gTypes[576]); + tp = &(gTypes[580]); break; case mx::CXXForRangeStmt::static_kind(): - tp = &(gTypes[577]); + tp = &(gTypes[581]); break; case mx::CXXCatchStmt::static_kind(): - tp = &(gTypes[578]); + tp = &(gTypes[582]); break; case mx::BreakStmt::static_kind(): - tp = &(gTypes[579]); + tp = &(gTypes[583]); break; case mx::MSAsmStmt::static_kind(): - tp = &(gTypes[581]); + tp = &(gTypes[585]); break; case mx::GCCAsmStmt::static_kind(): - tp = &(gTypes[582]); + tp = &(gTypes[586]); break; case mx::WhileStmt::static_kind(): - tp = &(gTypes[583]); + tp = &(gTypes[587]); break; case mx::LabelStmt::static_kind(): - tp = &(gTypes[585]); + tp = &(gTypes[589]); break; case mx::DesignatedInitUpdateExpr::static_kind(): - tp = &(gTypes[587]); + tp = &(gTypes[591]); break; case mx::DesignatedInitExpr::static_kind(): - tp = &(gTypes[588]); + tp = &(gTypes[592]); break; case mx::DependentScopeDeclRefExpr::static_kind(): - tp = &(gTypes[589]); + tp = &(gTypes[593]); break; case mx::DependentCoawaitExpr::static_kind(): - tp = &(gTypes[590]); + tp = &(gTypes[594]); break; case mx::DeclRefExpr::static_kind(): - tp = &(gTypes[591]); + tp = &(gTypes[595]); break; case mx::CoawaitExpr::static_kind(): - tp = &(gTypes[593]); + tp = &(gTypes[597]); break; case mx::CoyieldExpr::static_kind(): - tp = &(gTypes[594]); + tp = &(gTypes[598]); break; case mx::ConvertVectorExpr::static_kind(): - tp = &(gTypes[595]); + tp = &(gTypes[599]); break; case mx::ConceptSpecializationExpr::static_kind(): - tp = &(gTypes[596]); + tp = &(gTypes[600]); break; case mx::CompoundLiteralExpr::static_kind(): - tp = &(gTypes[597]); + tp = &(gTypes[601]); break; case mx::ChooseExpr::static_kind(): - tp = &(gTypes[598]); + tp = &(gTypes[602]); break; case mx::CharacterLiteral::static_kind(): - tp = &(gTypes[599]); + tp = &(gTypes[603]); break; case mx::ImplicitCastExpr::static_kind(): - tp = &(gTypes[601]); + tp = &(gTypes[605]); break; case mx::CXXDynamicCastExpr::static_kind(): - tp = &(gTypes[604]); + tp = &(gTypes[608]); break; case mx::CXXConstCastExpr::static_kind(): - tp = &(gTypes[605]); + tp = &(gTypes[609]); break; case mx::CXXAddrspaceCastExpr::static_kind(): - tp = &(gTypes[606]); + tp = &(gTypes[610]); break; case mx::CXXStaticCastExpr::static_kind(): - tp = &(gTypes[607]); + tp = &(gTypes[611]); break; case mx::CXXReinterpretCastExpr::static_kind(): - tp = &(gTypes[608]); + tp = &(gTypes[612]); break; case mx::CXXFunctionalCastExpr::static_kind(): - tp = &(gTypes[609]); + tp = &(gTypes[613]); break; case mx::CStyleCastExpr::static_kind(): - tp = &(gTypes[610]); + tp = &(gTypes[614]); break; case mx::BuiltinBitCastExpr::static_kind(): - tp = &(gTypes[611]); + tp = &(gTypes[615]); break; case mx::ObjCBridgedCastExpr::static_kind(): - tp = &(gTypes[612]); + tp = &(gTypes[616]); break; case mx::CallExpr::static_kind(): - tp = &(gTypes[613]); + tp = &(gTypes[617]); break; case mx::CXXOperatorCallExpr::static_kind(): - tp = &(gTypes[614]); + tp = &(gTypes[618]); break; case mx::CXXMemberCallExpr::static_kind(): - tp = &(gTypes[615]); + tp = &(gTypes[619]); break; case mx::CUDAKernelCallExpr::static_kind(): - tp = &(gTypes[616]); + tp = &(gTypes[620]); break; case mx::UserDefinedLiteral::static_kind(): - tp = &(gTypes[617]); + tp = &(gTypes[621]); break; case mx::CXXUuidofExpr::static_kind(): - tp = &(gTypes[618]); + tp = &(gTypes[622]); break; case mx::CXXUnresolvedConstructExpr::static_kind(): - tp = &(gTypes[619]); + tp = &(gTypes[623]); break; case mx::CXXTypeidExpr::static_kind(): - tp = &(gTypes[620]); + tp = &(gTypes[624]); break; case mx::CXXThrowExpr::static_kind(): - tp = &(gTypes[621]); + tp = &(gTypes[625]); break; case mx::CXXThisExpr::static_kind(): - tp = &(gTypes[622]); + tp = &(gTypes[626]); break; case mx::CXXStdInitializerListExpr::static_kind(): - tp = &(gTypes[623]); + tp = &(gTypes[627]); break; case mx::CXXScalarValueInitExpr::static_kind(): - tp = &(gTypes[624]); + tp = &(gTypes[628]); break; case mx::CXXRewrittenBinaryOperator::static_kind(): - tp = &(gTypes[625]); + tp = &(gTypes[629]); break; case mx::CXXPseudoDestructorExpr::static_kind(): - tp = &(gTypes[626]); + tp = &(gTypes[630]); break; case mx::CXXParenListInitExpr::static_kind(): - tp = &(gTypes[627]); + tp = &(gTypes[631]); break; case mx::CXXNullPtrLiteralExpr::static_kind(): - tp = &(gTypes[628]); + tp = &(gTypes[632]); break; case mx::CXXNoexceptExpr::static_kind(): - tp = &(gTypes[629]); + tp = &(gTypes[633]); break; case mx::CXXNewExpr::static_kind(): - tp = &(gTypes[630]); + tp = &(gTypes[634]); break; case mx::CXXInheritedCtorInitExpr::static_kind(): - tp = &(gTypes[631]); + tp = &(gTypes[635]); break; case mx::CXXFoldExpr::static_kind(): - tp = &(gTypes[632]); + tp = &(gTypes[636]); break; case mx::CXXDependentScopeMemberExpr::static_kind(): - tp = &(gTypes[633]); + tp = &(gTypes[637]); break; case mx::CXXDeleteExpr::static_kind(): - tp = &(gTypes[634]); + tp = &(gTypes[638]); break; case mx::CXXDefaultInitExpr::static_kind(): - tp = &(gTypes[635]); + tp = &(gTypes[639]); break; case mx::CXXDefaultArgExpr::static_kind(): - tp = &(gTypes[636]); + tp = &(gTypes[640]); break; case mx::CXXConstructExpr::static_kind(): - tp = &(gTypes[637]); + tp = &(gTypes[641]); break; case mx::CXXTemporaryObjectExpr::static_kind(): - tp = &(gTypes[638]); + tp = &(gTypes[642]); break; case mx::CXXBoolLiteralExpr::static_kind(): - tp = &(gTypes[639]); + tp = &(gTypes[643]); break; case mx::CXXBindTemporaryExpr::static_kind(): - tp = &(gTypes[640]); + tp = &(gTypes[644]); break; case mx::BlockExpr::static_kind(): - tp = &(gTypes[641]); + tp = &(gTypes[645]); break; case mx::BinaryOperator::static_kind(): - tp = &(gTypes[642]); + tp = &(gTypes[646]); break; case mx::CompoundAssignOperator::static_kind(): - tp = &(gTypes[643]); + tp = &(gTypes[647]); break; case mx::AtomicExpr::static_kind(): - tp = &(gTypes[644]); + tp = &(gTypes[648]); break; case mx::AsTypeExpr::static_kind(): - tp = &(gTypes[645]); + tp = &(gTypes[649]); break; case mx::ArrayTypeTraitExpr::static_kind(): - tp = &(gTypes[646]); + tp = &(gTypes[650]); break; case mx::ArraySubscriptExpr::static_kind(): - tp = &(gTypes[647]); + tp = &(gTypes[651]); break; case mx::ArrayInitLoopExpr::static_kind(): - tp = &(gTypes[648]); + tp = &(gTypes[652]); break; case mx::ArrayInitIndexExpr::static_kind(): - tp = &(gTypes[649]); + tp = &(gTypes[653]); break; case mx::AddrLabelExpr::static_kind(): - tp = &(gTypes[650]); + tp = &(gTypes[654]); break; case mx::ConditionalOperator::static_kind(): - tp = &(gTypes[652]); + tp = &(gTypes[656]); break; case mx::BinaryConditionalOperator::static_kind(): - tp = &(gTypes[653]); + tp = &(gTypes[657]); break; case mx::VAArgExpr::static_kind(): - tp = &(gTypes[654]); + tp = &(gTypes[658]); break; case mx::UnaryOperator::static_kind(): - tp = &(gTypes[655]); + tp = &(gTypes[659]); break; case mx::UnaryExprOrTypeTraitExpr::static_kind(): - tp = &(gTypes[656]); + tp = &(gTypes[660]); break; case mx::TypoExpr::static_kind(): - tp = &(gTypes[657]); + tp = &(gTypes[661]); break; case mx::TypeTraitExpr::static_kind(): - tp = &(gTypes[658]); + tp = &(gTypes[662]); break; case mx::SubstNonTypeTemplateParmPackExpr::static_kind(): - tp = &(gTypes[659]); + tp = &(gTypes[663]); break; case mx::SubstNonTypeTemplateParmExpr::static_kind(): - tp = &(gTypes[660]); + tp = &(gTypes[664]); break; case mx::StringLiteral::static_kind(): - tp = &(gTypes[661]); + tp = &(gTypes[665]); break; case mx::StmtExpr::static_kind(): - tp = &(gTypes[662]); + tp = &(gTypes[666]); break; case mx::SourceLocExpr::static_kind(): - tp = &(gTypes[663]); + tp = &(gTypes[667]); break; case mx::SizeOfPackExpr::static_kind(): - tp = &(gTypes[664]); + tp = &(gTypes[668]); break; case mx::ShuffleVectorExpr::static_kind(): - tp = &(gTypes[665]); + tp = &(gTypes[669]); break; case mx::SYCLUniqueStableNameExpr::static_kind(): - tp = &(gTypes[666]); + tp = &(gTypes[670]); break; case mx::RequiresExpr::static_kind(): - tp = &(gTypes[667]); + tp = &(gTypes[671]); break; case mx::RecoveryExpr::static_kind(): - tp = &(gTypes[668]); + tp = &(gTypes[672]); break; case mx::PseudoObjectExpr::static_kind(): - tp = &(gTypes[669]); + tp = &(gTypes[673]); break; case mx::PredefinedExpr::static_kind(): - tp = &(gTypes[670]); + tp = &(gTypes[674]); break; case mx::ParenListExpr::static_kind(): - tp = &(gTypes[671]); + tp = &(gTypes[675]); break; case mx::ParenExpr::static_kind(): - tp = &(gTypes[672]); + tp = &(gTypes[676]); break; case mx::PackExpansionExpr::static_kind(): - tp = &(gTypes[673]); + tp = &(gTypes[677]); break; case mx::UnresolvedMemberExpr::static_kind(): - tp = &(gTypes[675]); + tp = &(gTypes[679]); break; case mx::UnresolvedLookupExpr::static_kind(): - tp = &(gTypes[676]); + tp = &(gTypes[680]); break; case mx::OpaqueValueExpr::static_kind(): - tp = &(gTypes[677]); + tp = &(gTypes[681]); break; case mx::OffsetOfExpr::static_kind(): - tp = &(gTypes[678]); + tp = &(gTypes[682]); break; case mx::ObjCSubscriptRefExpr::static_kind(): - tp = &(gTypes[679]); + tp = &(gTypes[683]); break; case mx::ObjCStringLiteral::static_kind(): - tp = &(gTypes[680]); + tp = &(gTypes[684]); break; case mx::ObjCSelectorExpr::static_kind(): - tp = &(gTypes[681]); + tp = &(gTypes[685]); break; case mx::ObjCProtocolExpr::static_kind(): - tp = &(gTypes[682]); + tp = &(gTypes[686]); break; case mx::ObjCPropertyRefExpr::static_kind(): - tp = &(gTypes[683]); + tp = &(gTypes[687]); break; case mx::ObjCMessageExpr::static_kind(): - tp = &(gTypes[684]); + tp = &(gTypes[688]); break; case mx::ObjCIvarRefExpr::static_kind(): - tp = &(gTypes[685]); + tp = &(gTypes[689]); break; case mx::ObjCIsaExpr::static_kind(): - tp = &(gTypes[686]); + tp = &(gTypes[690]); break; case mx::ObjCIndirectCopyRestoreExpr::static_kind(): - tp = &(gTypes[687]); + tp = &(gTypes[691]); break; case mx::ObjCEncodeExpr::static_kind(): - tp = &(gTypes[688]); + tp = &(gTypes[692]); break; case mx::ObjCDictionaryLiteral::static_kind(): - tp = &(gTypes[689]); + tp = &(gTypes[693]); break; case mx::ObjCBoxedExpr::static_kind(): - tp = &(gTypes[690]); + tp = &(gTypes[694]); break; case mx::ObjCBoolLiteralExpr::static_kind(): - tp = &(gTypes[691]); + tp = &(gTypes[695]); break; case mx::ObjCAvailabilityCheckExpr::static_kind(): - tp = &(gTypes[692]); + tp = &(gTypes[696]); break; case mx::ObjCArrayLiteral::static_kind(): - tp = &(gTypes[693]); + tp = &(gTypes[697]); break; case mx::OMPIteratorExpr::static_kind(): - tp = &(gTypes[694]); + tp = &(gTypes[698]); break; case mx::OMPArrayShapingExpr::static_kind(): - tp = &(gTypes[695]); + tp = &(gTypes[699]); break; case mx::OMPArraySectionExpr::static_kind(): - tp = &(gTypes[696]); + tp = &(gTypes[700]); break; case mx::NoInitExpr::static_kind(): - tp = &(gTypes[697]); + tp = &(gTypes[701]); break; case mx::MemberExpr::static_kind(): - tp = &(gTypes[698]); + tp = &(gTypes[702]); break; case mx::MatrixSubscriptExpr::static_kind(): - tp = &(gTypes[699]); + tp = &(gTypes[703]); break; case mx::MaterializeTemporaryExpr::static_kind(): - tp = &(gTypes[700]); + tp = &(gTypes[704]); break; case mx::MSPropertySubscriptExpr::static_kind(): - tp = &(gTypes[701]); + tp = &(gTypes[705]); break; case mx::MSPropertyRefExpr::static_kind(): - tp = &(gTypes[702]); + tp = &(gTypes[706]); break; case mx::LambdaExpr::static_kind(): - tp = &(gTypes[703]); + tp = &(gTypes[707]); break; case mx::IntegerLiteral::static_kind(): - tp = &(gTypes[704]); + tp = &(gTypes[708]); break; case mx::InitListExpr::static_kind(): - tp = &(gTypes[705]); + tp = &(gTypes[709]); break; case mx::ImplicitValueInitExpr::static_kind(): - tp = &(gTypes[706]); + tp = &(gTypes[710]); break; case mx::ImaginaryLiteral::static_kind(): - tp = &(gTypes[707]); + tp = &(gTypes[711]); break; case mx::GenericSelectionExpr::static_kind(): - tp = &(gTypes[708]); + tp = &(gTypes[712]); break; case mx::GNUNullExpr::static_kind(): - tp = &(gTypes[709]); + tp = &(gTypes[713]); break; case mx::FunctionParmPackExpr::static_kind(): - tp = &(gTypes[710]); + tp = &(gTypes[714]); break; case mx::ExprWithCleanups::static_kind(): - tp = &(gTypes[712]); + tp = &(gTypes[716]); break; case mx::ConstantExpr::static_kind(): - tp = &(gTypes[713]); + tp = &(gTypes[717]); break; case mx::FloatingLiteral::static_kind(): - tp = &(gTypes[714]); + tp = &(gTypes[718]); break; case mx::FixedPointLiteral::static_kind(): - tp = &(gTypes[715]); + tp = &(gTypes[719]); break; case mx::ExtVectorElementExpr::static_kind(): - tp = &(gTypes[716]); + tp = &(gTypes[720]); break; case mx::ExpressionTraitExpr::static_kind(): - tp = &(gTypes[717]); + tp = &(gTypes[721]); break; case mx::AttributedStmt::static_kind(): - tp = &(gTypes[718]); + tp = &(gTypes[722]); break; case mx::SwitchStmt::static_kind(): - tp = &(gTypes[719]); + tp = &(gTypes[723]); break; case mx::DefaultStmt::static_kind(): - tp = &(gTypes[721]); + tp = &(gTypes[725]); break; case mx::CaseStmt::static_kind(): - tp = &(gTypes[722]); + tp = &(gTypes[726]); break; } @@ -1378,7 +1378,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -1408,7 +1408,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[473]); + PyTypeObject * const tp = &(gTypes[477]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/StmtAttr.cpp b/bindings/Python/Generated/AST/StmtAttr.cpp index dd7caf8d6..4c9b6caed 100644 --- a/bindings/Python/Generated/AST/StmtAttr.cpp +++ b/bindings/Python/Generated/AST/StmtAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[48]) || tp >= &(gTypes[55])) { + if (tp < &(gTypes[52]) || tp >= &(gTypes[59])) { return std::nullopt; } @@ -88,27 +88,27 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OpenCLUnrollHintAttr::static_kind(): - tp = &(gTypes[49]); + tp = &(gTypes[53]); break; case mx::MustTailAttr::static_kind(): - tp = &(gTypes[50]); + tp = &(gTypes[54]); break; case mx::LikelyAttr::static_kind(): - tp = &(gTypes[51]); + tp = &(gTypes[55]); break; case mx::FallThroughAttr::static_kind(): - tp = &(gTypes[52]); + tp = &(gTypes[56]); break; case mx::CodeAlignAttr::static_kind(): - tp = &(gTypes[53]); + tp = &(gTypes[57]); break; case mx::UnlikelyAttr::static_kind(): - tp = &(gTypes[54]); + tp = &(gTypes[58]); break; } @@ -282,7 +282,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -334,7 +334,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[48]); + PyTypeObject * const tp = &(gTypes[52]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -349,12 +349,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/StmtExpr.cpp b/bindings/Python/Generated/AST/StmtExpr.cpp index f5ce5e917..782630322 100644 --- a/bindings/Python/Generated/AST/StmtExpr.cpp +++ b/bindings/Python/Generated/AST/StmtExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[662]) || tp >= &(gTypes[663])) { + if (tp < &(gTypes[666]) || tp >= &(gTypes[667])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::StmtExpr::static_kind(): - tp = &(gTypes[662]); + tp = &(gTypes[666]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[662]); + PyTypeObject * const tp = &(gTypes[666]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/StrictFPAttr.cpp b/bindings/Python/Generated/AST/StrictFPAttr.cpp index e043a32ea..c21a3e2b3 100644 --- a/bindings/Python/Generated/AST/StrictFPAttr.cpp +++ b/bindings/Python/Generated/AST/StrictFPAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[260]) || tp >= &(gTypes[261])) { + if (tp < &(gTypes[264]) || tp >= &(gTypes[265])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::StrictFPAttr::static_kind(): - tp = &(gTypes[260]); + tp = &(gTypes[264]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[260]); + PyTypeObject * const tp = &(gTypes[264]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp b/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp index c26016890..36962214f 100644 --- a/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp +++ b/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[259]) || tp >= &(gTypes[260])) { + if (tp < &(gTypes[263]) || tp >= &(gTypes[264])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::StrictGuardStackCheckAttr::static_kind(): - tp = &(gTypes[259]); + tp = &(gTypes[263]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[259]); + PyTypeObject * const tp = &(gTypes[263]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/StringLiteral.cpp b/bindings/Python/Generated/AST/StringLiteral.cpp index 6bae4242a..e01aa296d 100644 --- a/bindings/Python/Generated/AST/StringLiteral.cpp +++ b/bindings/Python/Generated/AST/StringLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[661]) || tp >= &(gTypes[662])) { + if (tp < &(gTypes[665]) || tp >= &(gTypes[666])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::StringLiteral::static_kind(): - tp = &(gTypes[661]); + tp = &(gTypes[665]); break; } @@ -479,7 +479,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -509,7 +509,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[661]); + PyTypeObject * const tp = &(gTypes[665]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -524,12 +524,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp index 819bd5a94..5220ae81e 100644 --- a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp +++ b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[660]) || tp >= &(gTypes[661])) { + if (tp < &(gTypes[664]) || tp >= &(gTypes[665])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SubstNonTypeTemplateParmExpr::static_kind(): - tp = &(gTypes[660]); + tp = &(gTypes[664]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[660]); + PyTypeObject * const tp = &(gTypes[664]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp index d17bfd532..0e2902e72 100644 --- a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp +++ b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[659]) || tp >= &(gTypes[660])) { + if (tp < &(gTypes[663]) || tp >= &(gTypes[664])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SubstNonTypeTemplateParmPackExpr::static_kind(): - tp = &(gTypes[659]); + tp = &(gTypes[663]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[659]); + PyTypeObject * const tp = &(gTypes[663]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp b/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp index 21b38a308..2453e7475 100644 --- a/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp +++ b/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[417]) || tp >= &(gTypes[418])) { + if (tp < &(gTypes[421]) || tp >= &(gTypes[422])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SubstTemplateTypeParmPackType::static_kind(): - tp = &(gTypes[417]); + tp = &(gTypes[421]); break; } @@ -313,7 +313,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -365,7 +365,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[417]); + PyTypeObject * const tp = &(gTypes[421]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -380,12 +380,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp b/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp index 63b27f028..5be80143a 100644 --- a/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp +++ b/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[416]) || tp >= &(gTypes[417])) { + if (tp < &(gTypes[420]) || tp >= &(gTypes[421])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SubstTemplateTypeParmType::static_kind(): - tp = &(gTypes[416]); + tp = &(gTypes[420]); break; } @@ -323,7 +323,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -375,7 +375,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[416]); + PyTypeObject * const tp = &(gTypes[420]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -390,12 +390,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SuppressAttr.cpp b/bindings/Python/Generated/AST/SuppressAttr.cpp index 60ad62f2e..821e200d8 100644 --- a/bindings/Python/Generated/AST/SuppressAttr.cpp +++ b/bindings/Python/Generated/AST/SuppressAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[116]) || tp >= &(gTypes[117])) { + if (tp < &(gTypes[120]) || tp >= &(gTypes[121])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SuppressAttr::static_kind(): - tp = &(gTypes[116]); + tp = &(gTypes[120]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[116]); + PyTypeObject * const tp = &(gTypes[120]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[114].tp_hash; - tp->tp_richcompare = gTypes[114].tp_richcompare; + tp->tp_hash = gTypes[118].tp_hash; + tp->tp_richcompare = gTypes[118].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[114]); + tp->tp_base = &(gTypes[118]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp index 58f274ad4..b31c7a093 100644 --- a/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[258]) || tp >= &(gTypes[259])) { + if (tp < &(gTypes[262]) || tp >= &(gTypes[263])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftAsyncAttr::static_kind(): - tp = &(gTypes[258]); + tp = &(gTypes[262]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[258]); + PyTypeObject * const tp = &(gTypes[262]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp index 8683565bf..052628cca 100644 --- a/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[257]) || tp >= &(gTypes[258])) { + if (tp < &(gTypes[261]) || tp >= &(gTypes[262])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftAsyncCallAttr::static_kind(): - tp = &(gTypes[257]); + tp = &(gTypes[261]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[257]); + PyTypeObject * const tp = &(gTypes[261]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp index 521ccddae..59700b65f 100644 --- a/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[403]) || tp >= &(gTypes[404])) { + if (tp < &(gTypes[407]) || tp >= &(gTypes[408])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftAsyncContextAttr::static_kind(): - tp = &(gTypes[403]); + tp = &(gTypes[407]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[403]); + PyTypeObject * const tp = &(gTypes[407]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[399].tp_hash; - tp->tp_richcompare = gTypes[399].tp_richcompare; + tp->tp_hash = gTypes[403].tp_hash; + tp->tp_richcompare = gTypes[403].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[399]); + tp->tp_base = &(gTypes[403]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp index 061e944df..f0c3cf38a 100644 --- a/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[256]) || tp >= &(gTypes[257])) { + if (tp < &(gTypes[260]) || tp >= &(gTypes[261])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftAsyncErrorAttr::static_kind(): - tp = &(gTypes[256]); + tp = &(gTypes[260]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[256]); + PyTypeObject * const tp = &(gTypes[260]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp index efba67cba..59c2f8d95 100644 --- a/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[255]) || tp >= &(gTypes[256])) { + if (tp < &(gTypes[259]) || tp >= &(gTypes[260])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftAsyncNameAttr::static_kind(): - tp = &(gTypes[255]); + tp = &(gTypes[259]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[255]); + PyTypeObject * const tp = &(gTypes[259]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftAttrAttr.cpp b/bindings/Python/Generated/AST/SwiftAttrAttr.cpp index 3e855bcc1..a707dc713 100644 --- a/bindings/Python/Generated/AST/SwiftAttrAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftAttrAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[254]) || tp >= &(gTypes[255])) { + if (tp < &(gTypes[258]) || tp >= &(gTypes[259])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftAttrAttr::static_kind(): - tp = &(gTypes[254]); + tp = &(gTypes[258]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[254]); + PyTypeObject * const tp = &(gTypes[258]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp b/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp index 8fd0c1f7d..40521d8ab 100644 --- a/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[253]) || tp >= &(gTypes[254])) { + if (tp < &(gTypes[257]) || tp >= &(gTypes[258])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftBridgeAttr::static_kind(): - tp = &(gTypes[253]); + tp = &(gTypes[257]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[253]); + PyTypeObject * const tp = &(gTypes[257]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp b/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp index 5eb50dc14..3076a54f3 100644 --- a/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[252]) || tp >= &(gTypes[253])) { + if (tp < &(gTypes[256]) || tp >= &(gTypes[257])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftBridgedTypedefAttr::static_kind(): - tp = &(gTypes[252]); + tp = &(gTypes[256]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[252]); + PyTypeObject * const tp = &(gTypes[256]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftCallAttr.cpp b/bindings/Python/Generated/AST/SwiftCallAttr.cpp index 509999b9c..10a2da85c 100644 --- a/bindings/Python/Generated/AST/SwiftCallAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[251]) || tp >= &(gTypes[252])) { + if (tp < &(gTypes[255]) || tp >= &(gTypes[256])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftCallAttr::static_kind(): - tp = &(gTypes[251]); + tp = &(gTypes[255]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[251]); + PyTypeObject * const tp = &(gTypes[255]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftContextAttr.cpp b/bindings/Python/Generated/AST/SwiftContextAttr.cpp index 0224695bf..de0a64f7a 100644 --- a/bindings/Python/Generated/AST/SwiftContextAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftContextAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[402]) || tp >= &(gTypes[403])) { + if (tp < &(gTypes[406]) || tp >= &(gTypes[407])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftContextAttr::static_kind(): - tp = &(gTypes[402]); + tp = &(gTypes[406]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[402]); + PyTypeObject * const tp = &(gTypes[406]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[399].tp_hash; - tp->tp_richcompare = gTypes[399].tp_richcompare; + tp->tp_hash = gTypes[403].tp_hash; + tp->tp_richcompare = gTypes[403].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[399]); + tp->tp_base = &(gTypes[403]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftErrorAttr.cpp b/bindings/Python/Generated/AST/SwiftErrorAttr.cpp index f765eb5fb..28a9ef250 100644 --- a/bindings/Python/Generated/AST/SwiftErrorAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftErrorAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[250]) || tp >= &(gTypes[251])) { + if (tp < &(gTypes[254]) || tp >= &(gTypes[255])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftErrorAttr::static_kind(): - tp = &(gTypes[250]); + tp = &(gTypes[254]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[250]); + PyTypeObject * const tp = &(gTypes[254]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp b/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp index 7d28a408a..289d415f4 100644 --- a/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[401]) || tp >= &(gTypes[402])) { + if (tp < &(gTypes[405]) || tp >= &(gTypes[406])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftErrorResultAttr::static_kind(): - tp = &(gTypes[401]); + tp = &(gTypes[405]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[401]); + PyTypeObject * const tp = &(gTypes[405]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[399].tp_hash; - tp->tp_richcompare = gTypes[399].tp_richcompare; + tp->tp_hash = gTypes[403].tp_hash; + tp->tp_richcompare = gTypes[403].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[399]); + tp->tp_base = &(gTypes[403]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp b/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp index 3a306843f..1f3ee0457 100644 --- a/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[249]) || tp >= &(gTypes[250])) { + if (tp < &(gTypes[253]) || tp >= &(gTypes[254])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftImportAsNonGenericAttr::static_kind(): - tp = &(gTypes[249]); + tp = &(gTypes[253]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[249]); + PyTypeObject * const tp = &(gTypes[253]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp b/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp index 58cc1ae42..9000cacfb 100644 --- a/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[248]) || tp >= &(gTypes[249])) { + if (tp < &(gTypes[252]) || tp >= &(gTypes[253])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftImportPropertyAsAccessorsAttr::static_kind(): - tp = &(gTypes[248]); + tp = &(gTypes[252]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[248]); + PyTypeObject * const tp = &(gTypes[252]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp b/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp index d6e97a386..7cfb9d06f 100644 --- a/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[400]) || tp >= &(gTypes[401])) { + if (tp < &(gTypes[404]) || tp >= &(gTypes[405])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftIndirectResultAttr::static_kind(): - tp = &(gTypes[400]); + tp = &(gTypes[404]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[400]); + PyTypeObject * const tp = &(gTypes[404]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[399].tp_hash; - tp->tp_richcompare = gTypes[399].tp_richcompare; + tp->tp_hash = gTypes[403].tp_hash; + tp->tp_richcompare = gTypes[403].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[399]); + tp->tp_base = &(gTypes[403]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftNameAttr.cpp b/bindings/Python/Generated/AST/SwiftNameAttr.cpp index 66a7bc2ae..5a2086a0e 100644 --- a/bindings/Python/Generated/AST/SwiftNameAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftNameAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[247]) || tp >= &(gTypes[248])) { + if (tp < &(gTypes[251]) || tp >= &(gTypes[252])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftNameAttr::static_kind(): - tp = &(gTypes[247]); + tp = &(gTypes[251]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[247]); + PyTypeObject * const tp = &(gTypes[251]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp b/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp index a9212887b..dd8ef6386 100644 --- a/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[246]) || tp >= &(gTypes[247])) { + if (tp < &(gTypes[250]) || tp >= &(gTypes[251])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftNewTypeAttr::static_kind(): - tp = &(gTypes[246]); + tp = &(gTypes[250]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[246]); + PyTypeObject * const tp = &(gTypes[250]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp b/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp index fbe4548c9..ddafc4540 100644 --- a/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[47]) || tp >= &(gTypes[48])) { + if (tp < &(gTypes[51]) || tp >= &(gTypes[52])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftObjCMembersAttr::static_kind(): - tp = &(gTypes[47]); + tp = &(gTypes[51]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[47]); + PyTypeObject * const tp = &(gTypes[51]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp b/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp index 23080bbc7..e9920b7a1 100644 --- a/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[245]) || tp >= &(gTypes[246])) { + if (tp < &(gTypes[249]) || tp >= &(gTypes[250])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftPrivateAttr::static_kind(): - tp = &(gTypes[245]); + tp = &(gTypes[249]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[245]); + PyTypeObject * const tp = &(gTypes[249]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp b/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp index be3f0b602..526a082fb 100644 --- a/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[46]) || tp >= &(gTypes[47])) { + if (tp < &(gTypes[50]) || tp >= &(gTypes[51])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftVersionedAdditionAttr::static_kind(): - tp = &(gTypes[46]); + tp = &(gTypes[50]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[46]); + PyTypeObject * const tp = &(gTypes[50]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp b/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp index b2952c164..8675cf425 100644 --- a/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp +++ b/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[45]) || tp >= &(gTypes[46])) { + if (tp < &(gTypes[49]) || tp >= &(gTypes[50])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwiftVersionedRemovalAttr::static_kind(): - tp = &(gTypes[45]); + tp = &(gTypes[49]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[45]); + PyTypeObject * const tp = &(gTypes[49]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwitchCase.cpp b/bindings/Python/Generated/AST/SwitchCase.cpp index 89836b075..42176d379 100644 --- a/bindings/Python/Generated/AST/SwitchCase.cpp +++ b/bindings/Python/Generated/AST/SwitchCase.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[720]) || tp >= &(gTypes[723])) { + if (tp < &(gTypes[724]) || tp >= &(gTypes[727])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DefaultStmt::static_kind(): - tp = &(gTypes[721]); + tp = &(gTypes[725]); break; case mx::CaseStmt::static_kind(): - tp = &(gTypes[722]); + tp = &(gTypes[726]); break; } @@ -346,7 +346,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -376,7 +376,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[720]); + PyTypeObject * const tp = &(gTypes[724]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -391,12 +391,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SwitchStmt.cpp b/bindings/Python/Generated/AST/SwitchStmt.cpp index 789776568..95b53c172 100644 --- a/bindings/Python/Generated/AST/SwitchStmt.cpp +++ b/bindings/Python/Generated/AST/SwitchStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[719]) || tp >= &(gTypes[720])) { + if (tp < &(gTypes[723]) || tp >= &(gTypes[724])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SwitchStmt::static_kind(): - tp = &(gTypes[719]); + tp = &(gTypes[723]); break; } @@ -439,7 +439,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -469,7 +469,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[719]); + PyTypeObject * const tp = &(gTypes[723]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -484,12 +484,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/SysVABIAttr.cpp b/bindings/Python/Generated/AST/SysVABIAttr.cpp index 29db06731..81865dae4 100644 --- a/bindings/Python/Generated/AST/SysVABIAttr.cpp +++ b/bindings/Python/Generated/AST/SysVABIAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[244]) || tp >= &(gTypes[245])) { + if (tp < &(gTypes[248]) || tp >= &(gTypes[249])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SysVABIAttr::static_kind(): - tp = &(gTypes[244]); + tp = &(gTypes[248]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[244]); + PyTypeObject * const tp = &(gTypes[248]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TLSModelAttr.cpp b/bindings/Python/Generated/AST/TLSModelAttr.cpp index 5c08180bc..8a02fb99a 100644 --- a/bindings/Python/Generated/AST/TLSModelAttr.cpp +++ b/bindings/Python/Generated/AST/TLSModelAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[243]) || tp >= &(gTypes[244])) { + if (tp < &(gTypes[247]) || tp >= &(gTypes[248])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TLSModelAttr::static_kind(): - tp = &(gTypes[243]); + tp = &(gTypes[247]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[243]); + PyTypeObject * const tp = &(gTypes[247]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TagDecl.cpp b/bindings/Python/Generated/AST/TagDecl.cpp index 8dc4d126c..e07ab4046 100644 --- a/bindings/Python/Generated/AST/TagDecl.cpp +++ b/bindings/Python/Generated/AST/TagDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[781]) || tp >= &(gTypes[787])) { + if (tp < &(gTypes[785]) || tp >= &(gTypes[791])) { return std::nullopt; } @@ -88,23 +88,23 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RecordDecl::static_kind(): - tp = &(gTypes[782]); + tp = &(gTypes[786]); break; case mx::CXXRecordDecl::static_kind(): - tp = &(gTypes[783]); + tp = &(gTypes[787]); break; case mx::ClassTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[784]); + tp = &(gTypes[788]); break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; case mx::EnumDecl::static_kind(): - tp = &(gTypes[786]); + tp = &(gTypes[790]); break; } @@ -568,7 +568,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -620,7 +620,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[781]); + PyTypeObject * const tp = &(gTypes[785]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -635,12 +635,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[779].tp_hash; - tp->tp_richcompare = gTypes[779].tp_richcompare; + tp->tp_hash = gTypes[783].tp_hash; + tp->tp_richcompare = gTypes[783].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[779]); + tp->tp_base = &(gTypes[783]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TagType.cpp b/bindings/Python/Generated/AST/TagType.cpp index 9398108f4..ff9c91b7c 100644 --- a/bindings/Python/Generated/AST/TagType.cpp +++ b/bindings/Python/Generated/AST/TagType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[413]) || tp >= &(gTypes[416])) { + if (tp < &(gTypes[417]) || tp >= &(gTypes[420])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::RecordType::static_kind(): - tp = &(gTypes[414]); + tp = &(gTypes[418]); break; case mx::EnumType::static_kind(): - tp = &(gTypes[415]); + tp = &(gTypes[419]); break; } @@ -270,7 +270,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -322,7 +322,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[413]); + PyTypeObject * const tp = &(gTypes[417]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -337,12 +337,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TargetAttr.cpp b/bindings/Python/Generated/AST/TargetAttr.cpp index cb69128e3..081bd2e27 100644 --- a/bindings/Python/Generated/AST/TargetAttr.cpp +++ b/bindings/Python/Generated/AST/TargetAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[242]) || tp >= &(gTypes[243])) { + if (tp < &(gTypes[246]) || tp >= &(gTypes[247])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TargetAttr::static_kind(): - tp = &(gTypes[242]); + tp = &(gTypes[246]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[242]); + PyTypeObject * const tp = &(gTypes[246]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TargetClonesAttr.cpp b/bindings/Python/Generated/AST/TargetClonesAttr.cpp index 56651c795..6ee045c83 100644 --- a/bindings/Python/Generated/AST/TargetClonesAttr.cpp +++ b/bindings/Python/Generated/AST/TargetClonesAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[241]) || tp >= &(gTypes[242])) { + if (tp < &(gTypes[245]) || tp >= &(gTypes[246])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TargetClonesAttr::static_kind(): - tp = &(gTypes[241]); + tp = &(gTypes[245]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[241]); + PyTypeObject * const tp = &(gTypes[245]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TargetVersionAttr.cpp b/bindings/Python/Generated/AST/TargetVersionAttr.cpp index ff2c1cabd..54d1b802c 100644 --- a/bindings/Python/Generated/AST/TargetVersionAttr.cpp +++ b/bindings/Python/Generated/AST/TargetVersionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[240]) || tp >= &(gTypes[241])) { + if (tp < &(gTypes[244]) || tp >= &(gTypes[245])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TargetVersionAttr::static_kind(): - tp = &(gTypes[240]); + tp = &(gTypes[244]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[240]); + PyTypeObject * const tp = &(gTypes[244]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TemplateArgument.cpp b/bindings/Python/Generated/AST/TemplateArgument.cpp index fbc4cb5a6..6c2b18cdd 100644 --- a/bindings/Python/Generated/AST/TemplateArgument.cpp +++ b/bindings/Python/Generated/AST/TemplateArgument.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[5]) || tp >= &(gTypes[6])) { + if (tp < &(gTypes[9]) || tp >= &(gTypes[10])) { return std::nullopt; } @@ -414,7 +414,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -488,7 +488,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[5]); + PyTypeObject * const tp = &(gTypes[9]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/TemplateDecl.cpp b/bindings/Python/Generated/AST/TemplateDecl.cpp index 6a26aac52..61896228f 100644 --- a/bindings/Python/Generated/AST/TemplateDecl.cpp +++ b/bindings/Python/Generated/AST/TemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[792]) || tp >= &(gTypes[801])) { + if (tp < &(gTypes[796]) || tp >= &(gTypes[805])) { return std::nullopt; } @@ -88,31 +88,31 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::FunctionTemplateDecl::static_kind(): - tp = &(gTypes[794]); + tp = &(gTypes[798]); break; case mx::ClassTemplateDecl::static_kind(): - tp = &(gTypes[795]); + tp = &(gTypes[799]); break; case mx::VarTemplateDecl::static_kind(): - tp = &(gTypes[796]); + tp = &(gTypes[800]); break; case mx::TypeAliasTemplateDecl::static_kind(): - tp = &(gTypes[797]); + tp = &(gTypes[801]); break; case mx::ConceptDecl::static_kind(): - tp = &(gTypes[798]); + tp = &(gTypes[802]); break; case mx::BuiltinTemplateDecl::static_kind(): - tp = &(gTypes[799]); + tp = &(gTypes[803]); break; case mx::TemplateTemplateParmDecl::static_kind(): - tp = &(gTypes[800]); + tp = &(gTypes[804]); break; } @@ -396,7 +396,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -426,7 +426,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[792]); + PyTypeObject * const tp = &(gTypes[796]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -441,12 +441,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp b/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp index b86d8723b..6bb72a9ed 100644 --- a/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp +++ b/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[747]) || tp >= &(gTypes[748])) { + if (tp < &(gTypes[751]) || tp >= &(gTypes[752])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TemplateParamObjectDecl::static_kind(): - tp = &(gTypes[747]); + tp = &(gTypes[751]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[747]); + PyTypeObject * const tp = &(gTypes[751]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TemplateParameterList.cpp b/bindings/Python/Generated/AST/TemplateParameterList.cpp index e9d7e7589..09d1878d6 100644 --- a/bindings/Python/Generated/AST/TemplateParameterList.cpp +++ b/bindings/Python/Generated/AST/TemplateParameterList.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[4]) || tp >= &(gTypes[5])) { + if (tp < &(gTypes[8]) || tp >= &(gTypes[9])) { return std::nullopt; } @@ -366,7 +366,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -440,7 +440,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[4]); + PyTypeObject * const tp = &(gTypes[8]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/TemplateSpecializationType.cpp b/bindings/Python/Generated/AST/TemplateSpecializationType.cpp index af6c226f2..2726c3b20 100644 --- a/bindings/Python/Generated/AST/TemplateSpecializationType.cpp +++ b/bindings/Python/Generated/AST/TemplateSpecializationType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[412]) || tp >= &(gTypes[413])) { + if (tp < &(gTypes[416]) || tp >= &(gTypes[417])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TemplateSpecializationType::static_kind(): - tp = &(gTypes[412]); + tp = &(gTypes[416]); break; } @@ -323,7 +323,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -397,7 +397,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[412]); + PyTypeObject * const tp = &(gTypes[416]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -412,12 +412,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp b/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp index 7981e6552..160090bd0 100644 --- a/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp +++ b/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[800]) || tp >= &(gTypes[801])) { + if (tp < &(gTypes[804]) || tp >= &(gTypes[805])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TemplateTemplateParmDecl::static_kind(): - tp = &(gTypes[800]); + tp = &(gTypes[804]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[800]); + PyTypeObject * const tp = &(gTypes[804]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[792].tp_hash; - tp->tp_richcompare = gTypes[792].tp_richcompare; + tp->tp_hash = gTypes[796].tp_hash; + tp->tp_richcompare = gTypes[796].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[792]); + tp->tp_base = &(gTypes[796]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp b/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp index afdd800c2..898291738 100644 --- a/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp +++ b/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[780]) || tp >= &(gTypes[781])) { + if (tp < &(gTypes[784]) || tp >= &(gTypes[785])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TemplateTypeParmDecl::static_kind(): - tp = &(gTypes[780]); + tp = &(gTypes[784]); break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -489,7 +489,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[780]); + PyTypeObject * const tp = &(gTypes[784]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -504,12 +504,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[779].tp_hash; - tp->tp_richcompare = gTypes[779].tp_richcompare; + tp->tp_hash = gTypes[783].tp_hash; + tp->tp_richcompare = gTypes[783].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[779]); + tp->tp_base = &(gTypes[783]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TemplateTypeParmType.cpp b/bindings/Python/Generated/AST/TemplateTypeParmType.cpp index 14abde391..e751f42d5 100644 --- a/bindings/Python/Generated/AST/TemplateTypeParmType.cpp +++ b/bindings/Python/Generated/AST/TemplateTypeParmType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[411]) || tp >= &(gTypes[412])) { + if (tp < &(gTypes[415]) || tp >= &(gTypes[416])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TemplateTypeParmType::static_kind(): - tp = &(gTypes[411]); + tp = &(gTypes[415]); break; } @@ -313,7 +313,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -365,7 +365,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[411]); + PyTypeObject * const tp = &(gTypes[415]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -380,12 +380,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TestTypestateAttr.cpp b/bindings/Python/Generated/AST/TestTypestateAttr.cpp index d1f305d66..6a64a7d43 100644 --- a/bindings/Python/Generated/AST/TestTypestateAttr.cpp +++ b/bindings/Python/Generated/AST/TestTypestateAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[239]) || tp >= &(gTypes[240])) { + if (tp < &(gTypes[243]) || tp >= &(gTypes[244])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TestTypestateAttr::static_kind(): - tp = &(gTypes[239]); + tp = &(gTypes[243]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[239]); + PyTypeObject * const tp = &(gTypes[243]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ThisCallAttr.cpp b/bindings/Python/Generated/AST/ThisCallAttr.cpp index 96026c3be..19578d13f 100644 --- a/bindings/Python/Generated/AST/ThisCallAttr.cpp +++ b/bindings/Python/Generated/AST/ThisCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[238]) || tp >= &(gTypes[239])) { + if (tp < &(gTypes[242]) || tp >= &(gTypes[243])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ThisCallAttr::static_kind(): - tp = &(gTypes[238]); + tp = &(gTypes[242]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[238]); + PyTypeObject * const tp = &(gTypes[242]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ThreadAttr.cpp b/bindings/Python/Generated/AST/ThreadAttr.cpp index 09b3ca56d..94b949c92 100644 --- a/bindings/Python/Generated/AST/ThreadAttr.cpp +++ b/bindings/Python/Generated/AST/ThreadAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[44]) || tp >= &(gTypes[45])) { + if (tp < &(gTypes[48]) || tp >= &(gTypes[49])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ThreadAttr::static_kind(): - tp = &(gTypes[44]); + tp = &(gTypes[48]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[44]); + PyTypeObject * const tp = &(gTypes[48]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp b/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp index ace5c5d27..e914bb167 100644 --- a/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp +++ b/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[732]) || tp >= &(gTypes[733])) { + if (tp < &(gTypes[736]) || tp >= &(gTypes[737])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TopLevelStmtDecl::static_kind(): - tp = &(gTypes[732]); + tp = &(gTypes[736]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[732]); + PyTypeObject * const tp = &(gTypes[736]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TranslationUnitDecl.cpp b/bindings/Python/Generated/AST/TranslationUnitDecl.cpp index e4f9d177e..d83ed3e95 100644 --- a/bindings/Python/Generated/AST/TranslationUnitDecl.cpp +++ b/bindings/Python/Generated/AST/TranslationUnitDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[731]) || tp >= &(gTypes[732])) { + if (tp < &(gTypes[735]) || tp >= &(gTypes[736])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TranslationUnitDecl::static_kind(): - tp = &(gTypes[731]); + tp = &(gTypes[735]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[731]); + PyTypeObject * const tp = &(gTypes[735]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[723].tp_hash; - tp->tp_richcompare = gTypes[723].tp_richcompare; + tp->tp_hash = gTypes[727].tp_hash; + tp->tp_richcompare = gTypes[727].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[723]); + tp->tp_base = &(gTypes[727]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TransparentUnionAttr.cpp b/bindings/Python/Generated/AST/TransparentUnionAttr.cpp index 310d7a398..59694766d 100644 --- a/bindings/Python/Generated/AST/TransparentUnionAttr.cpp +++ b/bindings/Python/Generated/AST/TransparentUnionAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[237]) || tp >= &(gTypes[238])) { + if (tp < &(gTypes[241]) || tp >= &(gTypes[242])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TransparentUnionAttr::static_kind(): - tp = &(gTypes[237]); + tp = &(gTypes[241]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[237]); + PyTypeObject * const tp = &(gTypes[241]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TrivialABIAttr.cpp b/bindings/Python/Generated/AST/TrivialABIAttr.cpp index 7934122d6..138e7c287 100644 --- a/bindings/Python/Generated/AST/TrivialABIAttr.cpp +++ b/bindings/Python/Generated/AST/TrivialABIAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[236]) || tp >= &(gTypes[237])) { + if (tp < &(gTypes[240]) || tp >= &(gTypes[241])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TrivialABIAttr::static_kind(): - tp = &(gTypes[236]); + tp = &(gTypes[240]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[236]); + PyTypeObject * const tp = &(gTypes[240]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp b/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp index c3af82195..34b738fc1 100644 --- a/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp +++ b/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[235]) || tp >= &(gTypes[236])) { + if (tp < &(gTypes[239]) || tp >= &(gTypes[240])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TryAcquireCapabilityAttr::static_kind(): - tp = &(gTypes[235]); + tp = &(gTypes[239]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[235]); + PyTypeObject * const tp = &(gTypes[239]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/Type.cpp b/bindings/Python/Generated/AST/Type.cpp index 6ca7ed80d..27709bb88 100644 --- a/bindings/Python/Generated/AST/Type.cpp +++ b/bindings/Python/Generated/AST/Type.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[410]) || tp >= &(gTypes[473])) { + if (tp < &(gTypes[414]) || tp >= &(gTypes[477])) { return std::nullopt; } @@ -88,223 +88,223 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TemplateTypeParmType::static_kind(): - tp = &(gTypes[411]); + tp = &(gTypes[415]); break; case mx::TemplateSpecializationType::static_kind(): - tp = &(gTypes[412]); + tp = &(gTypes[416]); break; case mx::RecordType::static_kind(): - tp = &(gTypes[414]); + tp = &(gTypes[418]); break; case mx::EnumType::static_kind(): - tp = &(gTypes[415]); + tp = &(gTypes[419]); break; case mx::SubstTemplateTypeParmType::static_kind(): - tp = &(gTypes[416]); + tp = &(gTypes[420]); break; case mx::SubstTemplateTypeParmPackType::static_kind(): - tp = &(gTypes[417]); + tp = &(gTypes[421]); break; case mx::RValueReferenceType::static_kind(): - tp = &(gTypes[419]); + tp = &(gTypes[423]); break; case mx::LValueReferenceType::static_kind(): - tp = &(gTypes[420]); + tp = &(gTypes[424]); break; case mx::QualifiedType::static_kind(): - tp = &(gTypes[421]); + tp = &(gTypes[425]); break; case mx::PointerType::static_kind(): - tp = &(gTypes[422]); + tp = &(gTypes[426]); break; case mx::PipeType::static_kind(): - tp = &(gTypes[423]); + tp = &(gTypes[427]); break; case mx::ParenType::static_kind(): - tp = &(gTypes[424]); + tp = &(gTypes[428]); break; case mx::PackExpansionType::static_kind(): - tp = &(gTypes[425]); + tp = &(gTypes[429]); break; case mx::ObjCTypeParamType::static_kind(): - tp = &(gTypes[426]); + tp = &(gTypes[430]); break; case mx::ObjCObjectType::static_kind(): - tp = &(gTypes[427]); + tp = &(gTypes[431]); break; case mx::ObjCInterfaceType::static_kind(): - tp = &(gTypes[428]); + tp = &(gTypes[432]); break; case mx::ObjCObjectPointerType::static_kind(): - tp = &(gTypes[429]); + tp = &(gTypes[433]); break; case mx::MemberPointerType::static_kind(): - tp = &(gTypes[430]); + tp = &(gTypes[434]); break; case mx::DependentSizedMatrixType::static_kind(): - tp = &(gTypes[432]); + tp = &(gTypes[436]); break; case mx::ConstantMatrixType::static_kind(): - tp = &(gTypes[433]); + tp = &(gTypes[437]); break; case mx::MacroQualifiedType::static_kind(): - tp = &(gTypes[434]); + tp = &(gTypes[438]); break; case mx::InjectedClassNameType::static_kind(): - tp = &(gTypes[435]); + tp = &(gTypes[439]); break; case mx::FunctionProtoType::static_kind(): - tp = &(gTypes[437]); + tp = &(gTypes[441]); break; case mx::FunctionNoProtoType::static_kind(): - tp = &(gTypes[438]); + tp = &(gTypes[442]); break; case mx::DependentVectorType::static_kind(): - tp = &(gTypes[439]); + tp = &(gTypes[443]); break; case mx::DependentSizedExtVectorType::static_kind(): - tp = &(gTypes[440]); + tp = &(gTypes[444]); break; case mx::DependentBitIntType::static_kind(): - tp = &(gTypes[441]); + tp = &(gTypes[445]); break; case mx::DependentAddressSpaceType::static_kind(): - tp = &(gTypes[442]); + tp = &(gTypes[446]); break; case mx::DeducedTemplateSpecializationType::static_kind(): - tp = &(gTypes[444]); + tp = &(gTypes[448]); break; case mx::AutoType::static_kind(): - tp = &(gTypes[445]); + tp = &(gTypes[449]); break; case mx::DecltypeType::static_kind(): - tp = &(gTypes[446]); + tp = &(gTypes[450]); break; case mx::ComplexType::static_kind(): - tp = &(gTypes[447]); + tp = &(gTypes[451]); break; case mx::BuiltinType::static_kind(): - tp = &(gTypes[448]); + tp = &(gTypes[452]); break; case mx::BlockPointerType::static_kind(): - tp = &(gTypes[449]); + tp = &(gTypes[453]); break; case mx::BitIntType::static_kind(): - tp = &(gTypes[450]); + tp = &(gTypes[454]); break; case mx::BTFTagAttributedType::static_kind(): - tp = &(gTypes[451]); + tp = &(gTypes[455]); break; case mx::AttributedType::static_kind(): - tp = &(gTypes[452]); + tp = &(gTypes[456]); break; case mx::AtomicType::static_kind(): - tp = &(gTypes[453]); + tp = &(gTypes[457]); break; case mx::VariableArrayType::static_kind(): - tp = &(gTypes[455]); + tp = &(gTypes[459]); break; case mx::IncompleteArrayType::static_kind(): - tp = &(gTypes[456]); + tp = &(gTypes[460]); break; case mx::DependentSizedArrayType::static_kind(): - tp = &(gTypes[457]); + tp = &(gTypes[461]); break; case mx::ConstantArrayType::static_kind(): - tp = &(gTypes[458]); + tp = &(gTypes[462]); break; case mx::AdjustedType::static_kind(): - tp = &(gTypes[459]); + tp = &(gTypes[463]); break; case mx::DecayedType::static_kind(): - tp = &(gTypes[460]); + tp = &(gTypes[464]); break; case mx::ElaboratedType::static_kind(): - tp = &(gTypes[462]); + tp = &(gTypes[466]); break; case mx::DependentTemplateSpecializationType::static_kind(): - tp = &(gTypes[463]); + tp = &(gTypes[467]); break; case mx::DependentNameType::static_kind(): - tp = &(gTypes[464]); + tp = &(gTypes[468]); break; case mx::VectorType::static_kind(): - tp = &(gTypes[465]); + tp = &(gTypes[469]); break; case mx::ExtVectorType::static_kind(): - tp = &(gTypes[466]); + tp = &(gTypes[470]); break; case mx::UsingType::static_kind(): - tp = &(gTypes[467]); + tp = &(gTypes[471]); break; case mx::UnresolvedUsingType::static_kind(): - tp = &(gTypes[468]); + tp = &(gTypes[472]); break; case mx::UnaryTransformType::static_kind(): - tp = &(gTypes[469]); + tp = &(gTypes[473]); break; case mx::TypedefType::static_kind(): - tp = &(gTypes[470]); + tp = &(gTypes[474]); break; case mx::TypeOfType::static_kind(): - tp = &(gTypes[471]); + tp = &(gTypes[475]); break; case mx::TypeOfExprType::static_kind(): - tp = &(gTypes[472]); + tp = &(gTypes[476]); break; } @@ -670,7 +670,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -722,7 +722,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[410]); + PyTypeObject * const tp = &(gTypes[414]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/AST/TypeAliasDecl.cpp b/bindings/Python/Generated/AST/TypeAliasDecl.cpp index 7dd2d8a10..c5931911f 100644 --- a/bindings/Python/Generated/AST/TypeAliasDecl.cpp +++ b/bindings/Python/Generated/AST/TypeAliasDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[790]) || tp >= &(gTypes[791])) { + if (tp < &(gTypes[794]) || tp >= &(gTypes[795])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeAliasDecl::static_kind(): - tp = &(gTypes[790]); + tp = &(gTypes[794]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[790]); + PyTypeObject * const tp = &(gTypes[794]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[788].tp_hash; - tp->tp_richcompare = gTypes[788].tp_richcompare; + tp->tp_hash = gTypes[792].tp_hash; + tp->tp_richcompare = gTypes[792].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[788]); + tp->tp_base = &(gTypes[792]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp b/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp index 664e26d75..fe343d92d 100644 --- a/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp +++ b/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[797]) || tp >= &(gTypes[798])) { + if (tp < &(gTypes[801]) || tp >= &(gTypes[802])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeAliasTemplateDecl::static_kind(): - tp = &(gTypes[797]); + tp = &(gTypes[801]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[797]); + PyTypeObject * const tp = &(gTypes[801]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[793].tp_hash; - tp->tp_richcompare = gTypes[793].tp_richcompare; + tp->tp_hash = gTypes[797].tp_hash; + tp->tp_richcompare = gTypes[797].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[793]); + tp->tp_base = &(gTypes[797]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeAttr.cpp b/bindings/Python/Generated/AST/TypeAttr.cpp index 080a21870..f1c92787f 100644 --- a/bindings/Python/Generated/AST/TypeAttr.cpp +++ b/bindings/Python/Generated/AST/TypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[10]) || tp >= &(gTypes[44])) { + if (tp < &(gTypes[14]) || tp >= &(gTypes[48])) { return std::nullopt; } @@ -88,135 +88,135 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SPtrAttr::static_kind(): - tp = &(gTypes[11]); + tp = &(gTypes[15]); break; case mx::Ptr64Attr::static_kind(): - tp = &(gTypes[12]); + tp = &(gTypes[16]); break; case mx::Ptr32Attr::static_kind(): - tp = &(gTypes[13]); + tp = &(gTypes[17]); break; case mx::OpenCLPrivateAddressSpaceAttr::static_kind(): - tp = &(gTypes[14]); + tp = &(gTypes[18]); break; case mx::OpenCLLocalAddressSpaceAttr::static_kind(): - tp = &(gTypes[15]); + tp = &(gTypes[19]); break; case mx::OpenCLGlobalHostAddressSpaceAttr::static_kind(): - tp = &(gTypes[16]); + tp = &(gTypes[20]); break; case mx::OpenCLGlobalDeviceAddressSpaceAttr::static_kind(): - tp = &(gTypes[17]); + tp = &(gTypes[21]); break; case mx::OpenCLGlobalAddressSpaceAttr::static_kind(): - tp = &(gTypes[18]); + tp = &(gTypes[22]); break; case mx::OpenCLGenericAddressSpaceAttr::static_kind(): - tp = &(gTypes[19]); + tp = &(gTypes[23]); break; case mx::OpenCLConstantAddressSpaceAttr::static_kind(): - tp = &(gTypes[20]); + tp = &(gTypes[24]); break; case mx::ObjCKindOfAttr::static_kind(): - tp = &(gTypes[21]); + tp = &(gTypes[25]); break; case mx::ObjCInertUnsafeUnretainedAttr::static_kind(): - tp = &(gTypes[22]); + tp = &(gTypes[26]); break; case mx::ObjCGCAttr::static_kind(): - tp = &(gTypes[23]); + tp = &(gTypes[27]); break; case mx::NoDerefAttr::static_kind(): - tp = &(gTypes[24]); + tp = &(gTypes[28]); break; case mx::HLSLParamModifierAttr::static_kind(): - tp = &(gTypes[25]); + tp = &(gTypes[29]); break; case mx::HLSLGroupSharedAddressSpaceAttr::static_kind(): - tp = &(gTypes[26]); + tp = &(gTypes[30]); break; case mx::CmseNSCallAttr::static_kind(): - tp = &(gTypes[27]); + tp = &(gTypes[31]); break; case mx::BTFTypeTagAttr::static_kind(): - tp = &(gTypes[28]); + tp = &(gTypes[32]); break; case mx::ArmStreamingCompatibleAttr::static_kind(): - tp = &(gTypes[29]); + tp = &(gTypes[33]); break; case mx::ArmStreamingAttr::static_kind(): - tp = &(gTypes[30]); + tp = &(gTypes[34]); break; case mx::ArmPreservesAttr::static_kind(): - tp = &(gTypes[31]); + tp = &(gTypes[35]); break; case mx::ArmOutAttr::static_kind(): - tp = &(gTypes[32]); + tp = &(gTypes[36]); break; case mx::ArmMveStrictPolymorphismAttr::static_kind(): - tp = &(gTypes[33]); + tp = &(gTypes[37]); break; case mx::ArmInOutAttr::static_kind(): - tp = &(gTypes[34]); + tp = &(gTypes[38]); break; case mx::ArmInAttr::static_kind(): - tp = &(gTypes[35]); + tp = &(gTypes[39]); break; case mx::AnnotateTypeAttr::static_kind(): - tp = &(gTypes[36]); + tp = &(gTypes[40]); break; case mx::AddressSpaceAttr::static_kind(): - tp = &(gTypes[37]); + tp = &(gTypes[41]); break; case mx::WebAssemblyFuncrefAttr::static_kind(): - tp = &(gTypes[38]); + tp = &(gTypes[42]); break; case mx::UPtrAttr::static_kind(): - tp = &(gTypes[39]); + tp = &(gTypes[43]); break; case mx::TypeNullableResultAttr::static_kind(): - tp = &(gTypes[40]); + tp = &(gTypes[44]); break; case mx::TypeNullableAttr::static_kind(): - tp = &(gTypes[41]); + tp = &(gTypes[45]); break; case mx::TypeNullUnspecifiedAttr::static_kind(): - tp = &(gTypes[42]); + tp = &(gTypes[46]); break; case mx::TypeNonNullAttr::static_kind(): - tp = &(gTypes[43]); + tp = &(gTypes[47]); break; } @@ -390,7 +390,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -442,7 +442,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[10]); + PyTypeObject * const tp = &(gTypes[14]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -457,12 +457,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[6].tp_hash; - tp->tp_richcompare = gTypes[6].tp_richcompare; + tp->tp_hash = gTypes[10].tp_hash; + tp->tp_richcompare = gTypes[10].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[6]); + tp->tp_base = &(gTypes[10]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeDecl.cpp b/bindings/Python/Generated/AST/TypeDecl.cpp index 971988456..69b653250 100644 --- a/bindings/Python/Generated/AST/TypeDecl.cpp +++ b/bindings/Python/Generated/AST/TypeDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[779]) || tp >= &(gTypes[792])) { + if (tp < &(gTypes[783]) || tp >= &(gTypes[796])) { return std::nullopt; } @@ -88,43 +88,43 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TemplateTypeParmDecl::static_kind(): - tp = &(gTypes[780]); + tp = &(gTypes[784]); break; case mx::RecordDecl::static_kind(): - tp = &(gTypes[782]); + tp = &(gTypes[786]); break; case mx::CXXRecordDecl::static_kind(): - tp = &(gTypes[783]); + tp = &(gTypes[787]); break; case mx::ClassTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[784]); + tp = &(gTypes[788]); break; case mx::ClassTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[785]); + tp = &(gTypes[789]); break; case mx::EnumDecl::static_kind(): - tp = &(gTypes[786]); + tp = &(gTypes[790]); break; case mx::UnresolvedUsingTypenameDecl::static_kind(): - tp = &(gTypes[787]); + tp = &(gTypes[791]); break; case mx::TypedefDecl::static_kind(): - tp = &(gTypes[789]); + tp = &(gTypes[793]); break; case mx::TypeAliasDecl::static_kind(): - tp = &(gTypes[790]); + tp = &(gTypes[794]); break; case mx::ObjCTypeParamDecl::static_kind(): - tp = &(gTypes[791]); + tp = &(gTypes[795]); break; } @@ -378,7 +378,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -408,7 +408,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[779]); + PyTypeObject * const tp = &(gTypes[783]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -423,12 +423,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeNonNullAttr.cpp b/bindings/Python/Generated/AST/TypeNonNullAttr.cpp index 1675d7d3f..4f63eb06c 100644 --- a/bindings/Python/Generated/AST/TypeNonNullAttr.cpp +++ b/bindings/Python/Generated/AST/TypeNonNullAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[43]) || tp >= &(gTypes[44])) { + if (tp < &(gTypes[47]) || tp >= &(gTypes[48])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeNonNullAttr::static_kind(): - tp = &(gTypes[43]); + tp = &(gTypes[47]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[43]); + PyTypeObject * const tp = &(gTypes[47]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp b/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp index 6900e2cee..0995bc01f 100644 --- a/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp +++ b/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[42]) || tp >= &(gTypes[43])) { + if (tp < &(gTypes[46]) || tp >= &(gTypes[47])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeNullUnspecifiedAttr::static_kind(): - tp = &(gTypes[42]); + tp = &(gTypes[46]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[42]); + PyTypeObject * const tp = &(gTypes[46]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeNullableAttr.cpp b/bindings/Python/Generated/AST/TypeNullableAttr.cpp index b2d20d1b5..b75d34dae 100644 --- a/bindings/Python/Generated/AST/TypeNullableAttr.cpp +++ b/bindings/Python/Generated/AST/TypeNullableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[41]) || tp >= &(gTypes[42])) { + if (tp < &(gTypes[45]) || tp >= &(gTypes[46])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeNullableAttr::static_kind(): - tp = &(gTypes[41]); + tp = &(gTypes[45]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[41]); + PyTypeObject * const tp = &(gTypes[45]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp b/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp index 63820a31a..d9aa4078d 100644 --- a/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp +++ b/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[40]) || tp >= &(gTypes[41])) { + if (tp < &(gTypes[44]) || tp >= &(gTypes[45])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeNullableResultAttr::static_kind(): - tp = &(gTypes[40]); + tp = &(gTypes[44]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[40]); + PyTypeObject * const tp = &(gTypes[44]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeOfExprType.cpp b/bindings/Python/Generated/AST/TypeOfExprType.cpp index 2587cbd31..d96189968 100644 --- a/bindings/Python/Generated/AST/TypeOfExprType.cpp +++ b/bindings/Python/Generated/AST/TypeOfExprType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[472]) || tp >= &(gTypes[473])) { + if (tp < &(gTypes[476]) || tp >= &(gTypes[477])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeOfExprType::static_kind(): - tp = &(gTypes[472]); + tp = &(gTypes[476]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[472]); + PyTypeObject * const tp = &(gTypes[476]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeOfType.cpp b/bindings/Python/Generated/AST/TypeOfType.cpp index ab8510c3b..e74075868 100644 --- a/bindings/Python/Generated/AST/TypeOfType.cpp +++ b/bindings/Python/Generated/AST/TypeOfType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[471]) || tp >= &(gTypes[472])) { + if (tp < &(gTypes[475]) || tp >= &(gTypes[476])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeOfType::static_kind(): - tp = &(gTypes[471]); + tp = &(gTypes[475]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[471]); + PyTypeObject * const tp = &(gTypes[475]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp b/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp index 588616eda..ff4e73e4f 100644 --- a/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp +++ b/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[234]) || tp >= &(gTypes[235])) { + if (tp < &(gTypes[238]) || tp >= &(gTypes[239])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeTagForDatatypeAttr::static_kind(): - tp = &(gTypes[234]); + tp = &(gTypes[238]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[234]); + PyTypeObject * const tp = &(gTypes[238]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeTraitExpr.cpp b/bindings/Python/Generated/AST/TypeTraitExpr.cpp index 3d0d45cbd..aeb8c7191 100644 --- a/bindings/Python/Generated/AST/TypeTraitExpr.cpp +++ b/bindings/Python/Generated/AST/TypeTraitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[658]) || tp >= &(gTypes[659])) { + if (tp < &(gTypes[662]) || tp >= &(gTypes[663])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeTraitExpr::static_kind(): - tp = &(gTypes[658]); + tp = &(gTypes[662]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -411,7 +411,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[658]); + PyTypeObject * const tp = &(gTypes[662]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -426,12 +426,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp b/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp index 1336bb36b..258af07de 100644 --- a/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp +++ b/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[233]) || tp >= &(gTypes[234])) { + if (tp < &(gTypes[237]) || tp >= &(gTypes[238])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypeVisibilityAttr::static_kind(): - tp = &(gTypes[233]); + tp = &(gTypes[237]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[233]); + PyTypeObject * const tp = &(gTypes[237]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypeWithKeyword.cpp b/bindings/Python/Generated/AST/TypeWithKeyword.cpp index 1e49955a5..6d71c7b31 100644 --- a/bindings/Python/Generated/AST/TypeWithKeyword.cpp +++ b/bindings/Python/Generated/AST/TypeWithKeyword.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[461]) || tp >= &(gTypes[465])) { + if (tp < &(gTypes[465]) || tp >= &(gTypes[469])) { return std::nullopt; } @@ -88,15 +88,15 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ElaboratedType::static_kind(): - tp = &(gTypes[462]); + tp = &(gTypes[466]); break; case mx::DependentTemplateSpecializationType::static_kind(): - tp = &(gTypes[463]); + tp = &(gTypes[467]); break; case mx::DependentNameType::static_kind(): - tp = &(gTypes[464]); + tp = &(gTypes[468]); break; } @@ -264,7 +264,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -316,7 +316,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[461]); + PyTypeObject * const tp = &(gTypes[465]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -331,12 +331,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypedefDecl.cpp b/bindings/Python/Generated/AST/TypedefDecl.cpp index 674f1295d..46e7fd68f 100644 --- a/bindings/Python/Generated/AST/TypedefDecl.cpp +++ b/bindings/Python/Generated/AST/TypedefDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[789]) || tp >= &(gTypes[790])) { + if (tp < &(gTypes[793]) || tp >= &(gTypes[794])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypedefDecl::static_kind(): - tp = &(gTypes[789]); + tp = &(gTypes[793]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[789]); + PyTypeObject * const tp = &(gTypes[793]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[788].tp_hash; - tp->tp_richcompare = gTypes[788].tp_richcompare; + tp->tp_hash = gTypes[792].tp_hash; + tp->tp_richcompare = gTypes[792].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[788]); + tp->tp_base = &(gTypes[792]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypedefNameDecl.cpp b/bindings/Python/Generated/AST/TypedefNameDecl.cpp index 308ce02ff..6a25ce25f 100644 --- a/bindings/Python/Generated/AST/TypedefNameDecl.cpp +++ b/bindings/Python/Generated/AST/TypedefNameDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[788]) || tp >= &(gTypes[792])) { + if (tp < &(gTypes[792]) || tp >= &(gTypes[796])) { return std::nullopt; } @@ -88,15 +88,15 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypedefDecl::static_kind(): - tp = &(gTypes[789]); + tp = &(gTypes[793]); break; case mx::TypeAliasDecl::static_kind(): - tp = &(gTypes[790]); + tp = &(gTypes[794]); break; case mx::ObjCTypeParamDecl::static_kind(): - tp = &(gTypes[791]); + tp = &(gTypes[795]); break; } @@ -380,7 +380,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -410,7 +410,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[788]); + PyTypeObject * const tp = &(gTypes[792]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -425,12 +425,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[779].tp_hash; - tp->tp_richcompare = gTypes[779].tp_richcompare; + tp->tp_hash = gTypes[783].tp_hash; + tp->tp_richcompare = gTypes[783].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[779]); + tp->tp_base = &(gTypes[783]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypedefType.cpp b/bindings/Python/Generated/AST/TypedefType.cpp index f1340671e..e29703f2d 100644 --- a/bindings/Python/Generated/AST/TypedefType.cpp +++ b/bindings/Python/Generated/AST/TypedefType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[470]) || tp >= &(gTypes[471])) { + if (tp < &(gTypes[474]) || tp >= &(gTypes[475])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypedefType::static_kind(): - tp = &(gTypes[470]); + tp = &(gTypes[474]); break; } @@ -293,7 +293,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -345,7 +345,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[470]); + PyTypeObject * const tp = &(gTypes[474]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -360,12 +360,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/TypoExpr.cpp b/bindings/Python/Generated/AST/TypoExpr.cpp index a8691005c..8196cc3c9 100644 --- a/bindings/Python/Generated/AST/TypoExpr.cpp +++ b/bindings/Python/Generated/AST/TypoExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[657]) || tp >= &(gTypes[658])) { + if (tp < &(gTypes[661]) || tp >= &(gTypes[662])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TypoExpr::static_kind(): - tp = &(gTypes[657]); + tp = &(gTypes[661]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[657]); + PyTypeObject * const tp = &(gTypes[661]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UPtrAttr.cpp b/bindings/Python/Generated/AST/UPtrAttr.cpp index 4d32334de..ca61672ca 100644 --- a/bindings/Python/Generated/AST/UPtrAttr.cpp +++ b/bindings/Python/Generated/AST/UPtrAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[39]) || tp >= &(gTypes[40])) { + if (tp < &(gTypes[43]) || tp >= &(gTypes[44])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UPtrAttr::static_kind(): - tp = &(gTypes[39]); + tp = &(gTypes[43]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[39]); + PyTypeObject * const tp = &(gTypes[43]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp b/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp index 313d384cf..f0bdefcfe 100644 --- a/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp +++ b/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[656]) || tp >= &(gTypes[657])) { + if (tp < &(gTypes[660]) || tp >= &(gTypes[661])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnaryExprOrTypeTraitExpr::static_kind(): - tp = &(gTypes[656]); + tp = &(gTypes[660]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[656]); + PyTypeObject * const tp = &(gTypes[660]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnaryOperator.cpp b/bindings/Python/Generated/AST/UnaryOperator.cpp index 7a63b11a4..2f75d6d88 100644 --- a/bindings/Python/Generated/AST/UnaryOperator.cpp +++ b/bindings/Python/Generated/AST/UnaryOperator.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[655]) || tp >= &(gTypes[656])) { + if (tp < &(gTypes[659]) || tp >= &(gTypes[660])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnaryOperator::static_kind(): - tp = &(gTypes[655]); + tp = &(gTypes[659]); break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -459,7 +459,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[655]); + PyTypeObject * const tp = &(gTypes[659]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -474,12 +474,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnaryTransformType.cpp b/bindings/Python/Generated/AST/UnaryTransformType.cpp index f64f600f2..835ba6721 100644 --- a/bindings/Python/Generated/AST/UnaryTransformType.cpp +++ b/bindings/Python/Generated/AST/UnaryTransformType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[469]) || tp >= &(gTypes[470])) { + if (tp < &(gTypes[473]) || tp >= &(gTypes[474])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnaryTransformType::static_kind(): - tp = &(gTypes[469]); + tp = &(gTypes[473]); break; } @@ -303,7 +303,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -355,7 +355,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[469]); + PyTypeObject * const tp = &(gTypes[473]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -370,12 +370,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnavailableAttr.cpp b/bindings/Python/Generated/AST/UnavailableAttr.cpp index f1ee62170..ec96d5222 100644 --- a/bindings/Python/Generated/AST/UnavailableAttr.cpp +++ b/bindings/Python/Generated/AST/UnavailableAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[232]) || tp >= &(gTypes[233])) { + if (tp < &(gTypes[236]) || tp >= &(gTypes[237])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnavailableAttr::static_kind(): - tp = &(gTypes[232]); + tp = &(gTypes[236]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[232]); + PyTypeObject * const tp = &(gTypes[236]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UninitializedAttr.cpp b/bindings/Python/Generated/AST/UninitializedAttr.cpp index 4fdd4ecbb..f90f9802e 100644 --- a/bindings/Python/Generated/AST/UninitializedAttr.cpp +++ b/bindings/Python/Generated/AST/UninitializedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[231]) || tp >= &(gTypes[232])) { + if (tp < &(gTypes[235]) || tp >= &(gTypes[236])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UninitializedAttr::static_kind(): - tp = &(gTypes[231]); + tp = &(gTypes[235]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[231]); + PyTypeObject * const tp = &(gTypes[235]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnlikelyAttr.cpp b/bindings/Python/Generated/AST/UnlikelyAttr.cpp index 8be0d6a00..95d3bfa66 100644 --- a/bindings/Python/Generated/AST/UnlikelyAttr.cpp +++ b/bindings/Python/Generated/AST/UnlikelyAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[54]) || tp >= &(gTypes[55])) { + if (tp < &(gTypes[58]) || tp >= &(gTypes[59])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnlikelyAttr::static_kind(): - tp = &(gTypes[54]); + tp = &(gTypes[58]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[54]); + PyTypeObject * const tp = &(gTypes[58]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[48].tp_hash; - tp->tp_richcompare = gTypes[48].tp_richcompare; + tp->tp_hash = gTypes[52].tp_hash; + tp->tp_richcompare = gTypes[52].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[48]); + tp->tp_base = &(gTypes[52]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp b/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp index 437a1fd3b..511688253 100644 --- a/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp +++ b/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[746]) || tp >= &(gTypes[747])) { + if (tp < &(gTypes[750]) || tp >= &(gTypes[751])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnnamedGlobalConstantDecl::static_kind(): - tp = &(gTypes[746]); + tp = &(gTypes[750]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[746]); + PyTypeObject * const tp = &(gTypes[750]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp b/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp index 0b4666706..4b98a22a4 100644 --- a/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp +++ b/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[676]) || tp >= &(gTypes[677])) { + if (tp < &(gTypes[680]) || tp >= &(gTypes[681])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedLookupExpr::static_kind(): - tp = &(gTypes[676]); + tp = &(gTypes[680]); break; } @@ -339,7 +339,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[676]); + PyTypeObject * const tp = &(gTypes[680]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -384,12 +384,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[674].tp_hash; - tp->tp_richcompare = gTypes[674].tp_richcompare; + tp->tp_hash = gTypes[678].tp_hash; + tp->tp_richcompare = gTypes[678].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[674]); + tp->tp_base = &(gTypes[678]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp b/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp index 61c80f84c..b279fbe14 100644 --- a/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp +++ b/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[675]) || tp >= &(gTypes[676])) { + if (tp < &(gTypes[679]) || tp >= &(gTypes[680])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedMemberExpr::static_kind(): - tp = &(gTypes[675]); + tp = &(gTypes[679]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[675]); + PyTypeObject * const tp = &(gTypes[679]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[674].tp_hash; - tp->tp_richcompare = gTypes[674].tp_richcompare; + tp->tp_hash = gTypes[678].tp_hash; + tp->tp_richcompare = gTypes[678].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[674]); + tp->tp_base = &(gTypes[678]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp b/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp index 3bef961d8..40faf599e 100644 --- a/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp +++ b/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[778]) || tp >= &(gTypes[779])) { + if (tp < &(gTypes[782]) || tp >= &(gTypes[783])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedUsingIfExistsDecl::static_kind(): - tp = &(gTypes[778]); + tp = &(gTypes[782]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[778]); + PyTypeObject * const tp = &(gTypes[782]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnresolvedUsingType.cpp b/bindings/Python/Generated/AST/UnresolvedUsingType.cpp index ecd1f4a4f..723e6ced6 100644 --- a/bindings/Python/Generated/AST/UnresolvedUsingType.cpp +++ b/bindings/Python/Generated/AST/UnresolvedUsingType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[468]) || tp >= &(gTypes[469])) { + if (tp < &(gTypes[472]) || tp >= &(gTypes[473])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedUsingType::static_kind(): - tp = &(gTypes[468]); + tp = &(gTypes[472]); break; } @@ -283,7 +283,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -335,7 +335,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[468]); + PyTypeObject * const tp = &(gTypes[472]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -350,12 +350,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp b/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp index f01e91b4a..f076667fe 100644 --- a/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp +++ b/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[787]) || tp >= &(gTypes[788])) { + if (tp < &(gTypes[791]) || tp >= &(gTypes[792])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedUsingTypenameDecl::static_kind(): - tp = &(gTypes[787]); + tp = &(gTypes[791]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[787]); + PyTypeObject * const tp = &(gTypes[791]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[779].tp_hash; - tp->tp_richcompare = gTypes[779].tp_richcompare; + tp->tp_hash = gTypes[783].tp_hash; + tp->tp_richcompare = gTypes[783].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[779]); + tp->tp_base = &(gTypes[783]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp b/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp index 26ca8d2f0..ddc620704 100644 --- a/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp +++ b/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[745]) || tp >= &(gTypes[746])) { + if (tp < &(gTypes[749]) || tp >= &(gTypes[750])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedUsingValueDecl::static_kind(): - tp = &(gTypes[745]); + tp = &(gTypes[749]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[745]); + PyTypeObject * const tp = &(gTypes[749]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[744].tp_hash; - tp->tp_richcompare = gTypes[744].tp_richcompare; + tp->tp_hash = gTypes[748].tp_hash; + tp->tp_richcompare = gTypes[748].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[744]); + tp->tp_base = &(gTypes[748]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp b/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp index e3bb0dada..27331af6c 100644 --- a/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp +++ b/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[230]) || tp >= &(gTypes[231])) { + if (tp < &(gTypes[234]) || tp >= &(gTypes[235])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnsafeBufferUsageAttr::static_kind(): - tp = &(gTypes[230]); + tp = &(gTypes[234]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[230]); + PyTypeObject * const tp = &(gTypes[234]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UnusedAttr.cpp b/bindings/Python/Generated/AST/UnusedAttr.cpp index 751869246..449656c19 100644 --- a/bindings/Python/Generated/AST/UnusedAttr.cpp +++ b/bindings/Python/Generated/AST/UnusedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[229]) || tp >= &(gTypes[230])) { + if (tp < &(gTypes[233]) || tp >= &(gTypes[234])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnusedAttr::static_kind(): - tp = &(gTypes[229]); + tp = &(gTypes[233]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[229]); + PyTypeObject * const tp = &(gTypes[233]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UseHandleAttr.cpp b/bindings/Python/Generated/AST/UseHandleAttr.cpp index c2eae0e0f..53e783227 100644 --- a/bindings/Python/Generated/AST/UseHandleAttr.cpp +++ b/bindings/Python/Generated/AST/UseHandleAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[396]) || tp >= &(gTypes[397])) { + if (tp < &(gTypes[400]) || tp >= &(gTypes[401])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UseHandleAttr::static_kind(): - tp = &(gTypes[396]); + tp = &(gTypes[400]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[396]); + PyTypeObject * const tp = &(gTypes[400]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[392].tp_hash; - tp->tp_richcompare = gTypes[392].tp_richcompare; + tp->tp_hash = gTypes[396].tp_hash; + tp->tp_richcompare = gTypes[396].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[392]); + tp->tp_base = &(gTypes[396]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsedAttr.cpp b/bindings/Python/Generated/AST/UsedAttr.cpp index aa90b3a1e..a6453e28c 100644 --- a/bindings/Python/Generated/AST/UsedAttr.cpp +++ b/bindings/Python/Generated/AST/UsedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[228]) || tp >= &(gTypes[229])) { + if (tp < &(gTypes[232]) || tp >= &(gTypes[233])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsedAttr::static_kind(): - tp = &(gTypes[228]); + tp = &(gTypes[232]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[228]); + PyTypeObject * const tp = &(gTypes[232]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UserDefinedLiteral.cpp b/bindings/Python/Generated/AST/UserDefinedLiteral.cpp index cbdca6605..7f706a32a 100644 --- a/bindings/Python/Generated/AST/UserDefinedLiteral.cpp +++ b/bindings/Python/Generated/AST/UserDefinedLiteral.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[617]) || tp >= &(gTypes[618])) { + if (tp < &(gTypes[621]) || tp >= &(gTypes[622])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UserDefinedLiteral::static_kind(): - tp = &(gTypes[617]); + tp = &(gTypes[621]); break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[617]); + PyTypeObject * const tp = &(gTypes[621]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[613].tp_hash; - tp->tp_richcompare = gTypes[613].tp_richcompare; + tp->tp_hash = gTypes[617].tp_hash; + tp->tp_richcompare = gTypes[617].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[613]); + tp->tp_base = &(gTypes[617]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsingDecl.cpp b/bindings/Python/Generated/AST/UsingDecl.cpp index 55e9acb46..ec18ce461 100644 --- a/bindings/Python/Generated/AST/UsingDecl.cpp +++ b/bindings/Python/Generated/AST/UsingDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[743]) || tp >= &(gTypes[744])) { + if (tp < &(gTypes[747]) || tp >= &(gTypes[748])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingDecl::static_kind(): - tp = &(gTypes[743]); + tp = &(gTypes[747]); break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -409,7 +409,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[743]); + PyTypeObject * const tp = &(gTypes[747]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -424,12 +424,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[741].tp_hash; - tp->tp_richcompare = gTypes[741].tp_richcompare; + tp->tp_hash = gTypes[745].tp_hash; + tp->tp_richcompare = gTypes[745].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[741]); + tp->tp_base = &(gTypes[745]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp b/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp index f22a2bd97..621ac58cc 100644 --- a/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp +++ b/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[777]) || tp >= &(gTypes[778])) { + if (tp < &(gTypes[781]) || tp >= &(gTypes[782])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingDirectiveDecl::static_kind(): - tp = &(gTypes[777]); + tp = &(gTypes[781]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[777]); + PyTypeObject * const tp = &(gTypes[781]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsingEnumDecl.cpp b/bindings/Python/Generated/AST/UsingEnumDecl.cpp index 39945ec2a..70ffbb132 100644 --- a/bindings/Python/Generated/AST/UsingEnumDecl.cpp +++ b/bindings/Python/Generated/AST/UsingEnumDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[742]) || tp >= &(gTypes[743])) { + if (tp < &(gTypes[746]) || tp >= &(gTypes[747])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingEnumDecl::static_kind(): - tp = &(gTypes[742]); + tp = &(gTypes[746]); break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[742]); + PyTypeObject * const tp = &(gTypes[746]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -434,12 +434,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[741].tp_hash; - tp->tp_richcompare = gTypes[741].tp_richcompare; + tp->tp_hash = gTypes[745].tp_hash; + tp->tp_richcompare = gTypes[745].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[741]); + tp->tp_base = &(gTypes[745]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp b/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp index b17253919..5545639a3 100644 --- a/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp +++ b/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[227]) || tp >= &(gTypes[228])) { + if (tp < &(gTypes[231]) || tp >= &(gTypes[232])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingIfExistsAttr::static_kind(): - tp = &(gTypes[227]); + tp = &(gTypes[231]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[227]); + PyTypeObject * const tp = &(gTypes[231]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsingPackDecl.cpp b/bindings/Python/Generated/AST/UsingPackDecl.cpp index 5c4f683a5..284db3fb3 100644 --- a/bindings/Python/Generated/AST/UsingPackDecl.cpp +++ b/bindings/Python/Generated/AST/UsingPackDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[776]) || tp >= &(gTypes[777])) { + if (tp < &(gTypes[780]) || tp >= &(gTypes[781])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingPackDecl::static_kind(): - tp = &(gTypes[776]); + tp = &(gTypes[780]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -421,7 +421,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[776]); + PyTypeObject * const tp = &(gTypes[780]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -436,12 +436,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsingShadowDecl.cpp b/bindings/Python/Generated/AST/UsingShadowDecl.cpp index f1e5a3209..3b40dff90 100644 --- a/bindings/Python/Generated/AST/UsingShadowDecl.cpp +++ b/bindings/Python/Generated/AST/UsingShadowDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[774]) || tp >= &(gTypes[776])) { + if (tp < &(gTypes[778]) || tp >= &(gTypes[780])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingShadowDecl::static_kind(): - tp = &(gTypes[774]); + tp = &(gTypes[778]); break; case mx::ConstructorUsingShadowDecl::static_kind(): - tp = &(gTypes[775]); + tp = &(gTypes[779]); break; } @@ -383,7 +383,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -413,7 +413,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[774]); + PyTypeObject * const tp = &(gTypes[778]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -428,12 +428,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UsingType.cpp b/bindings/Python/Generated/AST/UsingType.cpp index b119d2443..a254b34e7 100644 --- a/bindings/Python/Generated/AST/UsingType.cpp +++ b/bindings/Python/Generated/AST/UsingType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[467]) || tp >= &(gTypes[468])) { + if (tp < &(gTypes[471]) || tp >= &(gTypes[472])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UsingType::static_kind(): - tp = &(gTypes[467]); + tp = &(gTypes[471]); break; } @@ -303,7 +303,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -355,7 +355,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[467]); + PyTypeObject * const tp = &(gTypes[471]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -370,12 +370,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/UuidAttr.cpp b/bindings/Python/Generated/AST/UuidAttr.cpp index cb98d79c0..32dac27de 100644 --- a/bindings/Python/Generated/AST/UuidAttr.cpp +++ b/bindings/Python/Generated/AST/UuidAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[226]) || tp >= &(gTypes[227])) { + if (tp < &(gTypes[230]) || tp >= &(gTypes[231])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UuidAttr::static_kind(): - tp = &(gTypes[226]); + tp = &(gTypes[230]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[226]); + PyTypeObject * const tp = &(gTypes[230]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VAArgExpr.cpp b/bindings/Python/Generated/AST/VAArgExpr.cpp index 363dd19d2..c7185ba16 100644 --- a/bindings/Python/Generated/AST/VAArgExpr.cpp +++ b/bindings/Python/Generated/AST/VAArgExpr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[654]) || tp >= &(gTypes[655])) { + if (tp < &(gTypes[658]) || tp >= &(gTypes[659])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VAArgExpr::static_kind(): - tp = &(gTypes[654]); + tp = &(gTypes[658]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[654]); + PyTypeObject * const tp = &(gTypes[658]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[586].tp_hash; - tp->tp_richcompare = gTypes[586].tp_richcompare; + tp->tp_hash = gTypes[590].tp_hash; + tp->tp_richcompare = gTypes[590].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[586]); + tp->tp_base = &(gTypes[590]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ValueDecl.cpp b/bindings/Python/Generated/AST/ValueDecl.cpp index b551e7d28..6dc737299 100644 --- a/bindings/Python/Generated/AST/ValueDecl.cpp +++ b/bindings/Python/Generated/AST/ValueDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[744]) || tp >= &(gTypes[774])) { + if (tp < &(gTypes[748]) || tp >= &(gTypes[778])) { return std::nullopt; } @@ -88,111 +88,111 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UnresolvedUsingValueDecl::static_kind(): - tp = &(gTypes[745]); + tp = &(gTypes[749]); break; case mx::UnnamedGlobalConstantDecl::static_kind(): - tp = &(gTypes[746]); + tp = &(gTypes[750]); break; case mx::TemplateParamObjectDecl::static_kind(): - tp = &(gTypes[747]); + tp = &(gTypes[751]); break; case mx::OMPDeclareReductionDecl::static_kind(): - tp = &(gTypes[748]); + tp = &(gTypes[752]); break; case mx::MSGuidDecl::static_kind(): - tp = &(gTypes[749]); + tp = &(gTypes[753]); break; case mx::IndirectFieldDecl::static_kind(): - tp = &(gTypes[750]); + tp = &(gTypes[754]); break; case mx::EnumConstantDecl::static_kind(): - tp = &(gTypes[751]); + tp = &(gTypes[755]); break; case mx::VarDecl::static_kind(): - tp = &(gTypes[753]); + tp = &(gTypes[757]); break; case mx::ParmVarDecl::static_kind(): - tp = &(gTypes[754]); + tp = &(gTypes[758]); break; case mx::OMPCapturedExprDecl::static_kind(): - tp = &(gTypes[755]); + tp = &(gTypes[759]); break; case mx::ImplicitParamDecl::static_kind(): - tp = &(gTypes[756]); + tp = &(gTypes[760]); break; case mx::DecompositionDecl::static_kind(): - tp = &(gTypes[757]); + tp = &(gTypes[761]); break; case mx::VarTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[758]); + tp = &(gTypes[762]); break; case mx::VarTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[759]); + tp = &(gTypes[763]); break; case mx::NonTypeTemplateParmDecl::static_kind(): - tp = &(gTypes[760]); + tp = &(gTypes[764]); break; case mx::MSPropertyDecl::static_kind(): - tp = &(gTypes[761]); + tp = &(gTypes[765]); break; case mx::FunctionDecl::static_kind(): - tp = &(gTypes[762]); + tp = &(gTypes[766]); break; case mx::CXXMethodDecl::static_kind(): - tp = &(gTypes[763]); + tp = &(gTypes[767]); break; case mx::CXXDestructorDecl::static_kind(): - tp = &(gTypes[764]); + tp = &(gTypes[768]); break; case mx::CXXConversionDecl::static_kind(): - tp = &(gTypes[765]); + tp = &(gTypes[769]); break; case mx::CXXConstructorDecl::static_kind(): - tp = &(gTypes[766]); + tp = &(gTypes[770]); break; case mx::CXXDeductionGuideDecl::static_kind(): - tp = &(gTypes[767]); + tp = &(gTypes[771]); break; case mx::FieldDecl::static_kind(): - tp = &(gTypes[768]); + tp = &(gTypes[772]); break; case mx::ObjCIvarDecl::static_kind(): - tp = &(gTypes[769]); + tp = &(gTypes[773]); break; case mx::ObjCAtDefsFieldDecl::static_kind(): - tp = &(gTypes[770]); + tp = &(gTypes[774]); break; case mx::BindingDecl::static_kind(): - tp = &(gTypes[771]); + tp = &(gTypes[775]); break; case mx::OMPDeclareMapperDecl::static_kind(): - tp = &(gTypes[773]); + tp = &(gTypes[777]); break; } @@ -476,7 +476,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -506,7 +506,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[744]); + PyTypeObject * const tp = &(gTypes[748]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -521,12 +521,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[738].tp_hash; - tp->tp_richcompare = gTypes[738].tp_richcompare; + tp->tp_hash = gTypes[742].tp_hash; + tp->tp_richcompare = gTypes[742].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[738]); + tp->tp_base = &(gTypes[742]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ValueStmt.cpp b/bindings/Python/Generated/AST/ValueStmt.cpp index f2a670f5c..bb29e38a1 100644 --- a/bindings/Python/Generated/AST/ValueStmt.cpp +++ b/bindings/Python/Generated/AST/ValueStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[584]) || tp >= &(gTypes[719])) { + if (tp < &(gTypes[588]) || tp >= &(gTypes[723])) { return std::nullopt; } @@ -88,507 +88,507 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::LabelStmt::static_kind(): - tp = &(gTypes[585]); + tp = &(gTypes[589]); break; case mx::DesignatedInitUpdateExpr::static_kind(): - tp = &(gTypes[587]); + tp = &(gTypes[591]); break; case mx::DesignatedInitExpr::static_kind(): - tp = &(gTypes[588]); + tp = &(gTypes[592]); break; case mx::DependentScopeDeclRefExpr::static_kind(): - tp = &(gTypes[589]); + tp = &(gTypes[593]); break; case mx::DependentCoawaitExpr::static_kind(): - tp = &(gTypes[590]); + tp = &(gTypes[594]); break; case mx::DeclRefExpr::static_kind(): - tp = &(gTypes[591]); + tp = &(gTypes[595]); break; case mx::CoawaitExpr::static_kind(): - tp = &(gTypes[593]); + tp = &(gTypes[597]); break; case mx::CoyieldExpr::static_kind(): - tp = &(gTypes[594]); + tp = &(gTypes[598]); break; case mx::ConvertVectorExpr::static_kind(): - tp = &(gTypes[595]); + tp = &(gTypes[599]); break; case mx::ConceptSpecializationExpr::static_kind(): - tp = &(gTypes[596]); + tp = &(gTypes[600]); break; case mx::CompoundLiteralExpr::static_kind(): - tp = &(gTypes[597]); + tp = &(gTypes[601]); break; case mx::ChooseExpr::static_kind(): - tp = &(gTypes[598]); + tp = &(gTypes[602]); break; case mx::CharacterLiteral::static_kind(): - tp = &(gTypes[599]); + tp = &(gTypes[603]); break; case mx::ImplicitCastExpr::static_kind(): - tp = &(gTypes[601]); + tp = &(gTypes[605]); break; case mx::CXXDynamicCastExpr::static_kind(): - tp = &(gTypes[604]); + tp = &(gTypes[608]); break; case mx::CXXConstCastExpr::static_kind(): - tp = &(gTypes[605]); + tp = &(gTypes[609]); break; case mx::CXXAddrspaceCastExpr::static_kind(): - tp = &(gTypes[606]); + tp = &(gTypes[610]); break; case mx::CXXStaticCastExpr::static_kind(): - tp = &(gTypes[607]); + tp = &(gTypes[611]); break; case mx::CXXReinterpretCastExpr::static_kind(): - tp = &(gTypes[608]); + tp = &(gTypes[612]); break; case mx::CXXFunctionalCastExpr::static_kind(): - tp = &(gTypes[609]); + tp = &(gTypes[613]); break; case mx::CStyleCastExpr::static_kind(): - tp = &(gTypes[610]); + tp = &(gTypes[614]); break; case mx::BuiltinBitCastExpr::static_kind(): - tp = &(gTypes[611]); + tp = &(gTypes[615]); break; case mx::ObjCBridgedCastExpr::static_kind(): - tp = &(gTypes[612]); + tp = &(gTypes[616]); break; case mx::CallExpr::static_kind(): - tp = &(gTypes[613]); + tp = &(gTypes[617]); break; case mx::CXXOperatorCallExpr::static_kind(): - tp = &(gTypes[614]); + tp = &(gTypes[618]); break; case mx::CXXMemberCallExpr::static_kind(): - tp = &(gTypes[615]); + tp = &(gTypes[619]); break; case mx::CUDAKernelCallExpr::static_kind(): - tp = &(gTypes[616]); + tp = &(gTypes[620]); break; case mx::UserDefinedLiteral::static_kind(): - tp = &(gTypes[617]); + tp = &(gTypes[621]); break; case mx::CXXUuidofExpr::static_kind(): - tp = &(gTypes[618]); + tp = &(gTypes[622]); break; case mx::CXXUnresolvedConstructExpr::static_kind(): - tp = &(gTypes[619]); + tp = &(gTypes[623]); break; case mx::CXXTypeidExpr::static_kind(): - tp = &(gTypes[620]); + tp = &(gTypes[624]); break; case mx::CXXThrowExpr::static_kind(): - tp = &(gTypes[621]); + tp = &(gTypes[625]); break; case mx::CXXThisExpr::static_kind(): - tp = &(gTypes[622]); + tp = &(gTypes[626]); break; case mx::CXXStdInitializerListExpr::static_kind(): - tp = &(gTypes[623]); + tp = &(gTypes[627]); break; case mx::CXXScalarValueInitExpr::static_kind(): - tp = &(gTypes[624]); + tp = &(gTypes[628]); break; case mx::CXXRewrittenBinaryOperator::static_kind(): - tp = &(gTypes[625]); + tp = &(gTypes[629]); break; case mx::CXXPseudoDestructorExpr::static_kind(): - tp = &(gTypes[626]); + tp = &(gTypes[630]); break; case mx::CXXParenListInitExpr::static_kind(): - tp = &(gTypes[627]); + tp = &(gTypes[631]); break; case mx::CXXNullPtrLiteralExpr::static_kind(): - tp = &(gTypes[628]); + tp = &(gTypes[632]); break; case mx::CXXNoexceptExpr::static_kind(): - tp = &(gTypes[629]); + tp = &(gTypes[633]); break; case mx::CXXNewExpr::static_kind(): - tp = &(gTypes[630]); + tp = &(gTypes[634]); break; case mx::CXXInheritedCtorInitExpr::static_kind(): - tp = &(gTypes[631]); + tp = &(gTypes[635]); break; case mx::CXXFoldExpr::static_kind(): - tp = &(gTypes[632]); + tp = &(gTypes[636]); break; case mx::CXXDependentScopeMemberExpr::static_kind(): - tp = &(gTypes[633]); + tp = &(gTypes[637]); break; case mx::CXXDeleteExpr::static_kind(): - tp = &(gTypes[634]); + tp = &(gTypes[638]); break; case mx::CXXDefaultInitExpr::static_kind(): - tp = &(gTypes[635]); + tp = &(gTypes[639]); break; case mx::CXXDefaultArgExpr::static_kind(): - tp = &(gTypes[636]); + tp = &(gTypes[640]); break; case mx::CXXConstructExpr::static_kind(): - tp = &(gTypes[637]); + tp = &(gTypes[641]); break; case mx::CXXTemporaryObjectExpr::static_kind(): - tp = &(gTypes[638]); + tp = &(gTypes[642]); break; case mx::CXXBoolLiteralExpr::static_kind(): - tp = &(gTypes[639]); + tp = &(gTypes[643]); break; case mx::CXXBindTemporaryExpr::static_kind(): - tp = &(gTypes[640]); + tp = &(gTypes[644]); break; case mx::BlockExpr::static_kind(): - tp = &(gTypes[641]); + tp = &(gTypes[645]); break; case mx::BinaryOperator::static_kind(): - tp = &(gTypes[642]); + tp = &(gTypes[646]); break; case mx::CompoundAssignOperator::static_kind(): - tp = &(gTypes[643]); + tp = &(gTypes[647]); break; case mx::AtomicExpr::static_kind(): - tp = &(gTypes[644]); + tp = &(gTypes[648]); break; case mx::AsTypeExpr::static_kind(): - tp = &(gTypes[645]); + tp = &(gTypes[649]); break; case mx::ArrayTypeTraitExpr::static_kind(): - tp = &(gTypes[646]); + tp = &(gTypes[650]); break; case mx::ArraySubscriptExpr::static_kind(): - tp = &(gTypes[647]); + tp = &(gTypes[651]); break; case mx::ArrayInitLoopExpr::static_kind(): - tp = &(gTypes[648]); + tp = &(gTypes[652]); break; case mx::ArrayInitIndexExpr::static_kind(): - tp = &(gTypes[649]); + tp = &(gTypes[653]); break; case mx::AddrLabelExpr::static_kind(): - tp = &(gTypes[650]); + tp = &(gTypes[654]); break; case mx::ConditionalOperator::static_kind(): - tp = &(gTypes[652]); + tp = &(gTypes[656]); break; case mx::BinaryConditionalOperator::static_kind(): - tp = &(gTypes[653]); + tp = &(gTypes[657]); break; case mx::VAArgExpr::static_kind(): - tp = &(gTypes[654]); + tp = &(gTypes[658]); break; case mx::UnaryOperator::static_kind(): - tp = &(gTypes[655]); + tp = &(gTypes[659]); break; case mx::UnaryExprOrTypeTraitExpr::static_kind(): - tp = &(gTypes[656]); + tp = &(gTypes[660]); break; case mx::TypoExpr::static_kind(): - tp = &(gTypes[657]); + tp = &(gTypes[661]); break; case mx::TypeTraitExpr::static_kind(): - tp = &(gTypes[658]); + tp = &(gTypes[662]); break; case mx::SubstNonTypeTemplateParmPackExpr::static_kind(): - tp = &(gTypes[659]); + tp = &(gTypes[663]); break; case mx::SubstNonTypeTemplateParmExpr::static_kind(): - tp = &(gTypes[660]); + tp = &(gTypes[664]); break; case mx::StringLiteral::static_kind(): - tp = &(gTypes[661]); + tp = &(gTypes[665]); break; case mx::StmtExpr::static_kind(): - tp = &(gTypes[662]); + tp = &(gTypes[666]); break; case mx::SourceLocExpr::static_kind(): - tp = &(gTypes[663]); + tp = &(gTypes[667]); break; case mx::SizeOfPackExpr::static_kind(): - tp = &(gTypes[664]); + tp = &(gTypes[668]); break; case mx::ShuffleVectorExpr::static_kind(): - tp = &(gTypes[665]); + tp = &(gTypes[669]); break; case mx::SYCLUniqueStableNameExpr::static_kind(): - tp = &(gTypes[666]); + tp = &(gTypes[670]); break; case mx::RequiresExpr::static_kind(): - tp = &(gTypes[667]); + tp = &(gTypes[671]); break; case mx::RecoveryExpr::static_kind(): - tp = &(gTypes[668]); + tp = &(gTypes[672]); break; case mx::PseudoObjectExpr::static_kind(): - tp = &(gTypes[669]); + tp = &(gTypes[673]); break; case mx::PredefinedExpr::static_kind(): - tp = &(gTypes[670]); + tp = &(gTypes[674]); break; case mx::ParenListExpr::static_kind(): - tp = &(gTypes[671]); + tp = &(gTypes[675]); break; case mx::ParenExpr::static_kind(): - tp = &(gTypes[672]); + tp = &(gTypes[676]); break; case mx::PackExpansionExpr::static_kind(): - tp = &(gTypes[673]); + tp = &(gTypes[677]); break; case mx::UnresolvedMemberExpr::static_kind(): - tp = &(gTypes[675]); + tp = &(gTypes[679]); break; case mx::UnresolvedLookupExpr::static_kind(): - tp = &(gTypes[676]); + tp = &(gTypes[680]); break; case mx::OpaqueValueExpr::static_kind(): - tp = &(gTypes[677]); + tp = &(gTypes[681]); break; case mx::OffsetOfExpr::static_kind(): - tp = &(gTypes[678]); + tp = &(gTypes[682]); break; case mx::ObjCSubscriptRefExpr::static_kind(): - tp = &(gTypes[679]); + tp = &(gTypes[683]); break; case mx::ObjCStringLiteral::static_kind(): - tp = &(gTypes[680]); + tp = &(gTypes[684]); break; case mx::ObjCSelectorExpr::static_kind(): - tp = &(gTypes[681]); + tp = &(gTypes[685]); break; case mx::ObjCProtocolExpr::static_kind(): - tp = &(gTypes[682]); + tp = &(gTypes[686]); break; case mx::ObjCPropertyRefExpr::static_kind(): - tp = &(gTypes[683]); + tp = &(gTypes[687]); break; case mx::ObjCMessageExpr::static_kind(): - tp = &(gTypes[684]); + tp = &(gTypes[688]); break; case mx::ObjCIvarRefExpr::static_kind(): - tp = &(gTypes[685]); + tp = &(gTypes[689]); break; case mx::ObjCIsaExpr::static_kind(): - tp = &(gTypes[686]); + tp = &(gTypes[690]); break; case mx::ObjCIndirectCopyRestoreExpr::static_kind(): - tp = &(gTypes[687]); + tp = &(gTypes[691]); break; case mx::ObjCEncodeExpr::static_kind(): - tp = &(gTypes[688]); + tp = &(gTypes[692]); break; case mx::ObjCDictionaryLiteral::static_kind(): - tp = &(gTypes[689]); + tp = &(gTypes[693]); break; case mx::ObjCBoxedExpr::static_kind(): - tp = &(gTypes[690]); + tp = &(gTypes[694]); break; case mx::ObjCBoolLiteralExpr::static_kind(): - tp = &(gTypes[691]); + tp = &(gTypes[695]); break; case mx::ObjCAvailabilityCheckExpr::static_kind(): - tp = &(gTypes[692]); + tp = &(gTypes[696]); break; case mx::ObjCArrayLiteral::static_kind(): - tp = &(gTypes[693]); + tp = &(gTypes[697]); break; case mx::OMPIteratorExpr::static_kind(): - tp = &(gTypes[694]); + tp = &(gTypes[698]); break; case mx::OMPArrayShapingExpr::static_kind(): - tp = &(gTypes[695]); + tp = &(gTypes[699]); break; case mx::OMPArraySectionExpr::static_kind(): - tp = &(gTypes[696]); + tp = &(gTypes[700]); break; case mx::NoInitExpr::static_kind(): - tp = &(gTypes[697]); + tp = &(gTypes[701]); break; case mx::MemberExpr::static_kind(): - tp = &(gTypes[698]); + tp = &(gTypes[702]); break; case mx::MatrixSubscriptExpr::static_kind(): - tp = &(gTypes[699]); + tp = &(gTypes[703]); break; case mx::MaterializeTemporaryExpr::static_kind(): - tp = &(gTypes[700]); + tp = &(gTypes[704]); break; case mx::MSPropertySubscriptExpr::static_kind(): - tp = &(gTypes[701]); + tp = &(gTypes[705]); break; case mx::MSPropertyRefExpr::static_kind(): - tp = &(gTypes[702]); + tp = &(gTypes[706]); break; case mx::LambdaExpr::static_kind(): - tp = &(gTypes[703]); + tp = &(gTypes[707]); break; case mx::IntegerLiteral::static_kind(): - tp = &(gTypes[704]); + tp = &(gTypes[708]); break; case mx::InitListExpr::static_kind(): - tp = &(gTypes[705]); + tp = &(gTypes[709]); break; case mx::ImplicitValueInitExpr::static_kind(): - tp = &(gTypes[706]); + tp = &(gTypes[710]); break; case mx::ImaginaryLiteral::static_kind(): - tp = &(gTypes[707]); + tp = &(gTypes[711]); break; case mx::GenericSelectionExpr::static_kind(): - tp = &(gTypes[708]); + tp = &(gTypes[712]); break; case mx::GNUNullExpr::static_kind(): - tp = &(gTypes[709]); + tp = &(gTypes[713]); break; case mx::FunctionParmPackExpr::static_kind(): - tp = &(gTypes[710]); + tp = &(gTypes[714]); break; case mx::ExprWithCleanups::static_kind(): - tp = &(gTypes[712]); + tp = &(gTypes[716]); break; case mx::ConstantExpr::static_kind(): - tp = &(gTypes[713]); + tp = &(gTypes[717]); break; case mx::FloatingLiteral::static_kind(): - tp = &(gTypes[714]); + tp = &(gTypes[718]); break; case mx::FixedPointLiteral::static_kind(): - tp = &(gTypes[715]); + tp = &(gTypes[719]); break; case mx::ExtVectorElementExpr::static_kind(): - tp = &(gTypes[716]); + tp = &(gTypes[720]); break; case mx::ExpressionTraitExpr::static_kind(): - tp = &(gTypes[717]); + tp = &(gTypes[721]); break; case mx::AttributedStmt::static_kind(): - tp = &(gTypes[718]); + tp = &(gTypes[722]); break; } @@ -812,7 +812,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -842,7 +842,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[584]); + PyTypeObject * const tp = &(gTypes[588]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -857,12 +857,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VarDecl.cpp b/bindings/Python/Generated/AST/VarDecl.cpp index c1e0d6d19..81badc4f9 100644 --- a/bindings/Python/Generated/AST/VarDecl.cpp +++ b/bindings/Python/Generated/AST/VarDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[753]) || tp >= &(gTypes[760])) { + if (tp < &(gTypes[757]) || tp >= &(gTypes[764])) { return std::nullopt; } @@ -88,31 +88,31 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VarDecl::static_kind(): - tp = &(gTypes[753]); + tp = &(gTypes[757]); break; case mx::ParmVarDecl::static_kind(): - tp = &(gTypes[754]); + tp = &(gTypes[758]); break; case mx::OMPCapturedExprDecl::static_kind(): - tp = &(gTypes[755]); + tp = &(gTypes[759]); break; case mx::ImplicitParamDecl::static_kind(): - tp = &(gTypes[756]); + tp = &(gTypes[760]); break; case mx::DecompositionDecl::static_kind(): - tp = &(gTypes[757]); + tp = &(gTypes[761]); break; case mx::VarTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[758]); + tp = &(gTypes[762]); break; case mx::VarTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[759]); + tp = &(gTypes[763]); break; } @@ -803,7 +803,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -833,7 +833,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[753]); + PyTypeObject * const tp = &(gTypes[757]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -848,12 +848,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[752].tp_hash; - tp->tp_richcompare = gTypes[752].tp_richcompare; + tp->tp_hash = gTypes[756].tp_hash; + tp->tp_richcompare = gTypes[756].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[752]); + tp->tp_base = &(gTypes[756]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VarTemplateDecl.cpp b/bindings/Python/Generated/AST/VarTemplateDecl.cpp index f85cfd8d9..ba904d10f 100644 --- a/bindings/Python/Generated/AST/VarTemplateDecl.cpp +++ b/bindings/Python/Generated/AST/VarTemplateDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[796]) || tp >= &(gTypes[797])) { + if (tp < &(gTypes[800]) || tp >= &(gTypes[801])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VarTemplateDecl::static_kind(): - tp = &(gTypes[796]); + tp = &(gTypes[800]); break; } @@ -359,7 +359,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -389,7 +389,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[796]); + PyTypeObject * const tp = &(gTypes[800]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -404,12 +404,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[793].tp_hash; - tp->tp_richcompare = gTypes[793].tp_richcompare; + tp->tp_hash = gTypes[797].tp_hash; + tp->tp_richcompare = gTypes[797].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[793]); + tp->tp_base = &(gTypes[797]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp b/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp index 924595f71..2747bf35a 100644 --- a/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp +++ b/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[759]) || tp >= &(gTypes[760])) { + if (tp < &(gTypes[763]) || tp >= &(gTypes[764])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VarTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[759]); + tp = &(gTypes[763]); break; } @@ -369,7 +369,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[759]); + PyTypeObject * const tp = &(gTypes[763]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -414,12 +414,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[758].tp_hash; - tp->tp_richcompare = gTypes[758].tp_richcompare; + tp->tp_hash = gTypes[762].tp_hash; + tp->tp_richcompare = gTypes[762].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[758]); + tp->tp_base = &(gTypes[762]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp b/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp index 12b514eab..e5f4bcf0a 100644 --- a/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp +++ b/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[758]) || tp >= &(gTypes[760])) { + if (tp < &(gTypes[762]) || tp >= &(gTypes[764])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VarTemplateSpecializationDecl::static_kind(): - tp = &(gTypes[758]); + tp = &(gTypes[762]); break; case mx::VarTemplatePartialSpecializationDecl::static_kind(): - tp = &(gTypes[759]); + tp = &(gTypes[763]); break; } @@ -443,7 +443,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -495,7 +495,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[758]); + PyTypeObject * const tp = &(gTypes[762]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -510,12 +510,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[753].tp_hash; - tp->tp_richcompare = gTypes[753].tp_richcompare; + tp->tp_hash = gTypes[757].tp_hash; + tp->tp_richcompare = gTypes[757].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[753]); + tp->tp_base = &(gTypes[757]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VariableArrayType.cpp b/bindings/Python/Generated/AST/VariableArrayType.cpp index f5af80730..9ab104495 100644 --- a/bindings/Python/Generated/AST/VariableArrayType.cpp +++ b/bindings/Python/Generated/AST/VariableArrayType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[455]) || tp >= &(gTypes[456])) { + if (tp < &(gTypes[459]) || tp >= &(gTypes[460])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VariableArrayType::static_kind(): - tp = &(gTypes[455]); + tp = &(gTypes[459]); break; } @@ -313,7 +313,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -365,7 +365,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[455]); + PyTypeObject * const tp = &(gTypes[459]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -380,12 +380,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[454].tp_hash; - tp->tp_richcompare = gTypes[454].tp_richcompare; + tp->tp_hash = gTypes[458].tp_hash; + tp->tp_richcompare = gTypes[458].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[454]); + tp->tp_base = &(gTypes[458]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VecReturnAttr.cpp b/bindings/Python/Generated/AST/VecReturnAttr.cpp index 34be6b5fc..f8678abea 100644 --- a/bindings/Python/Generated/AST/VecReturnAttr.cpp +++ b/bindings/Python/Generated/AST/VecReturnAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[225]) || tp >= &(gTypes[226])) { + if (tp < &(gTypes[229]) || tp >= &(gTypes[230])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VecReturnAttr::static_kind(): - tp = &(gTypes[225]); + tp = &(gTypes[229]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[225]); + PyTypeObject * const tp = &(gTypes[229]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VecTypeHintAttr.cpp b/bindings/Python/Generated/AST/VecTypeHintAttr.cpp index c18563fc2..3f260e5f1 100644 --- a/bindings/Python/Generated/AST/VecTypeHintAttr.cpp +++ b/bindings/Python/Generated/AST/VecTypeHintAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[224]) || tp >= &(gTypes[225])) { + if (tp < &(gTypes[228]) || tp >= &(gTypes[229])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VecTypeHintAttr::static_kind(): - tp = &(gTypes[224]); + tp = &(gTypes[228]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[224]); + PyTypeObject * const tp = &(gTypes[228]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VectorCallAttr.cpp b/bindings/Python/Generated/AST/VectorCallAttr.cpp index f0efad797..1cbb97b0b 100644 --- a/bindings/Python/Generated/AST/VectorCallAttr.cpp +++ b/bindings/Python/Generated/AST/VectorCallAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[223]) || tp >= &(gTypes[224])) { + if (tp < &(gTypes[227]) || tp >= &(gTypes[228])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VectorCallAttr::static_kind(): - tp = &(gTypes[223]); + tp = &(gTypes[227]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[223]); + PyTypeObject * const tp = &(gTypes[227]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VectorType.cpp b/bindings/Python/Generated/AST/VectorType.cpp index e4396aeba..305469712 100644 --- a/bindings/Python/Generated/AST/VectorType.cpp +++ b/bindings/Python/Generated/AST/VectorType.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[465]) || tp >= &(gTypes[467])) { + if (tp < &(gTypes[469]) || tp >= &(gTypes[471])) { return std::nullopt; } @@ -88,11 +88,11 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VectorType::static_kind(): - tp = &(gTypes[465]); + tp = &(gTypes[469]); break; case mx::ExtVectorType::static_kind(): - tp = &(gTypes[466]); + tp = &(gTypes[470]); break; } @@ -297,7 +297,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -349,7 +349,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[465]); + PyTypeObject * const tp = &(gTypes[469]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -364,12 +364,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[410].tp_hash; - tp->tp_richcompare = gTypes[410].tp_richcompare; + tp->tp_hash = gTypes[414].tp_hash; + tp->tp_richcompare = gTypes[414].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[410]); + tp->tp_base = &(gTypes[414]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/VisibilityAttr.cpp b/bindings/Python/Generated/AST/VisibilityAttr.cpp index da37dec43..69e92dced 100644 --- a/bindings/Python/Generated/AST/VisibilityAttr.cpp +++ b/bindings/Python/Generated/AST/VisibilityAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[222]) || tp >= &(gTypes[223])) { + if (tp < &(gTypes[226]) || tp >= &(gTypes[227])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::VisibilityAttr::static_kind(): - tp = &(gTypes[222]); + tp = &(gTypes[226]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[222]); + PyTypeObject * const tp = &(gTypes[226]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WarnUnusedAttr.cpp b/bindings/Python/Generated/AST/WarnUnusedAttr.cpp index e5dc68e5b..ae8a4f730 100644 --- a/bindings/Python/Generated/AST/WarnUnusedAttr.cpp +++ b/bindings/Python/Generated/AST/WarnUnusedAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[221]) || tp >= &(gTypes[222])) { + if (tp < &(gTypes[225]) || tp >= &(gTypes[226])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WarnUnusedAttr::static_kind(): - tp = &(gTypes[221]); + tp = &(gTypes[225]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[221]); + PyTypeObject * const tp = &(gTypes[225]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp b/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp index 27f765e40..1338f016b 100644 --- a/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp +++ b/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[220]) || tp >= &(gTypes[221])) { + if (tp < &(gTypes[224]) || tp >= &(gTypes[225])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WarnUnusedResultAttr::static_kind(): - tp = &(gTypes[220]); + tp = &(gTypes[224]); break; } @@ -319,7 +319,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -371,7 +371,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[220]); + PyTypeObject * const tp = &(gTypes[224]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -386,12 +386,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WeakAttr.cpp b/bindings/Python/Generated/AST/WeakAttr.cpp index 3c23e9b47..c16586333 100644 --- a/bindings/Python/Generated/AST/WeakAttr.cpp +++ b/bindings/Python/Generated/AST/WeakAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[219]) || tp >= &(gTypes[220])) { + if (tp < &(gTypes[223]) || tp >= &(gTypes[224])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WeakAttr::static_kind(): - tp = &(gTypes[219]); + tp = &(gTypes[223]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[219]); + PyTypeObject * const tp = &(gTypes[223]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WeakImportAttr.cpp b/bindings/Python/Generated/AST/WeakImportAttr.cpp index 59435cd8d..b0d729452 100644 --- a/bindings/Python/Generated/AST/WeakImportAttr.cpp +++ b/bindings/Python/Generated/AST/WeakImportAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[218]) || tp >= &(gTypes[219])) { + if (tp < &(gTypes[222]) || tp >= &(gTypes[223])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WeakImportAttr::static_kind(): - tp = &(gTypes[218]); + tp = &(gTypes[222]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[218]); + PyTypeObject * const tp = &(gTypes[222]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WeakRefAttr.cpp b/bindings/Python/Generated/AST/WeakRefAttr.cpp index 241f98181..cf56d2a6f 100644 --- a/bindings/Python/Generated/AST/WeakRefAttr.cpp +++ b/bindings/Python/Generated/AST/WeakRefAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[217]) || tp >= &(gTypes[218])) { + if (tp < &(gTypes[221]) || tp >= &(gTypes[222])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WeakRefAttr::static_kind(): - tp = &(gTypes[217]); + tp = &(gTypes[221]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[217]); + PyTypeObject * const tp = &(gTypes[221]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp index c62fcacee..72c8d5578 100644 --- a/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp +++ b/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[216]) || tp >= &(gTypes[217])) { + if (tp < &(gTypes[220]) || tp >= &(gTypes[221])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WebAssemblyExportNameAttr::static_kind(): - tp = &(gTypes[216]); + tp = &(gTypes[220]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[216]); + PyTypeObject * const tp = &(gTypes[220]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp index 25ecbc0dd..d7174e67a 100644 --- a/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp +++ b/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[38]) || tp >= &(gTypes[39])) { + if (tp < &(gTypes[42]) || tp >= &(gTypes[43])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WebAssemblyFuncrefAttr::static_kind(): - tp = &(gTypes[38]); + tp = &(gTypes[42]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[38]); + PyTypeObject * const tp = &(gTypes[42]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[10].tp_hash; - tp->tp_richcompare = gTypes[10].tp_richcompare; + tp->tp_hash = gTypes[14].tp_hash; + tp->tp_richcompare = gTypes[14].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[10]); + tp->tp_base = &(gTypes[14]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp index 49d64ea1e..be1bf65a3 100644 --- a/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp +++ b/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[215]) || tp >= &(gTypes[216])) { + if (tp < &(gTypes[219]) || tp >= &(gTypes[220])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WebAssemblyImportModuleAttr::static_kind(): - tp = &(gTypes[215]); + tp = &(gTypes[219]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[215]); + PyTypeObject * const tp = &(gTypes[219]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp index 6507e76d2..8d23827b5 100644 --- a/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp +++ b/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[214]) || tp >= &(gTypes[215])) { + if (tp < &(gTypes[218]) || tp >= &(gTypes[219])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WebAssemblyImportNameAttr::static_kind(): - tp = &(gTypes[214]); + tp = &(gTypes[218]); break; } @@ -299,7 +299,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -351,7 +351,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[214]); + PyTypeObject * const tp = &(gTypes[218]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -366,12 +366,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WhileStmt.cpp b/bindings/Python/Generated/AST/WhileStmt.cpp index a9c4d2586..c26b6c6dd 100644 --- a/bindings/Python/Generated/AST/WhileStmt.cpp +++ b/bindings/Python/Generated/AST/WhileStmt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[583]) || tp >= &(gTypes[584])) { + if (tp < &(gTypes[587]) || tp >= &(gTypes[588])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WhileStmt::static_kind(): - tp = &(gTypes[583]); + tp = &(gTypes[587]); break; } @@ -399,7 +399,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -429,7 +429,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[583]); + PyTypeObject * const tp = &(gTypes[587]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -444,12 +444,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[473].tp_hash; - tp->tp_richcompare = gTypes[473].tp_richcompare; + tp->tp_hash = gTypes[477].tp_hash; + tp->tp_richcompare = gTypes[477].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[473]); + tp->tp_base = &(gTypes[477]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp b/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp index 4e35f2810..fd2da4648 100644 --- a/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp +++ b/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[213]) || tp >= &(gTypes[214])) { + if (tp < &(gTypes[217]) || tp >= &(gTypes[218])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::WorkGroupSizeHintAttr::static_kind(): - tp = &(gTypes[213]); + tp = &(gTypes[217]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[213]); + PyTypeObject * const tp = &(gTypes[217]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp b/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp index 9e120e5d7..f8ac15048 100644 --- a/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp +++ b/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[212]) || tp >= &(gTypes[213])) { + if (tp < &(gTypes[216]) || tp >= &(gTypes[217])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::X86ForceAlignArgPointerAttr::static_kind(): - tp = &(gTypes[212]); + tp = &(gTypes[216]); break; } @@ -279,7 +279,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -331,7 +331,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[212]); + PyTypeObject * const tp = &(gTypes[216]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -346,12 +346,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp b/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp index 3b6c7e8c2..bbf5c989a 100644 --- a/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp +++ b/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[211]) || tp >= &(gTypes[212])) { + if (tp < &(gTypes[215]) || tp >= &(gTypes[216])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::XRayInstrumentAttr::static_kind(): - tp = &(gTypes[211]); + tp = &(gTypes[215]); break; } @@ -309,7 +309,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -361,7 +361,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[211]); + PyTypeObject * const tp = &(gTypes[215]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -376,12 +376,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp b/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp index 844a8178f..be4473e6d 100644 --- a/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp +++ b/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[210]) || tp >= &(gTypes[211])) { + if (tp < &(gTypes[214]) || tp >= &(gTypes[215])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::XRayLogArgsAttr::static_kind(): - tp = &(gTypes[210]); + tp = &(gTypes[214]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[210]); + PyTypeObject * const tp = &(gTypes[214]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp b/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp index f32073d8b..9a14bca7b 100644 --- a/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp +++ b/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[209]) || tp >= &(gTypes[210])) { + if (tp < &(gTypes[213]) || tp >= &(gTypes[214])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ZeroCallUsedRegsAttr::static_kind(): - tp = &(gTypes[209]); + tp = &(gTypes[213]); break; } @@ -289,7 +289,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -341,7 +341,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[209]); + PyTypeObject * const tp = &(gTypes[213]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -356,12 +356,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[76].tp_hash; - tp->tp_richcompare = gTypes[76].tp_richcompare; + tp->tp_hash = gTypes[80].tp_hash; + tp->tp_richcompare = gTypes[80].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[76]); + tp->tp_base = &(gTypes[80]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Bindings.cpp b/bindings/Python/Generated/Bindings.cpp index 3ff27cc3d..9ad62ccb8 100644 --- a/bindings/Python/Generated/Bindings.cpp +++ b/bindings/Python/Generated/Bindings.cpp @@ -11,6 +11,13 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -22,10907 +29,10967 @@ template MX_EXPORT SharedPyObject *mx::to_python>(std: // The rest are auto-generated... +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>>::Type> +from_python>>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>>::Type> -from_python>>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional>::Type> from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>>::Type> +from_python>>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional>::Type> +from_python>(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>>::Type> -from_python>>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional>::Type> -from_python>(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; + +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; template MX_EXPORT std::optional::Type> from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; - -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT std::optional::Type> +from_python(BorrowedPyObject *obj) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBAttrSpelling) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCDesignatedInitializerAttrSpelling) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmNewAttr) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT std::optional::Type> -from_python(BorrowedPyObject *obj) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCProtocolExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExcludeFromExplicitInstantiationAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBLeafAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnavailableAttrImplicitReason) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AcquiredBeforeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DecltypeType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmLocallyStreamingAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprConstantExprKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCMessageExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnavailableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnumExtensibilityAttrKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AcquiredAfterAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectMembersAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmBuiltinAliasAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprLValueClassification) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UninitializedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCIvarRefExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AcquireHandleAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnumExtensibilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BlockPointerType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCExceptionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprNullPointerConstantKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnlikelyAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprNullPointerConstantValueDependence) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnsafeBufferUsageAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ErrorAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AcquireCapabilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCExplicitProtocolImplAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BitIntType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArgumentWithTypeTagAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprSideEffectsKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCIsaExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnusedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AVRSignalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExcludeFromExplicitInstantiationAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BTFTagAttributedType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCExternallyRetainedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprisModifiableLvalueResult) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UseHandleAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArcWeakrefUnavailableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AVRInterruptAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AttributedType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCIndirectCopyRestoreExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExternalSourceSymbolAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprConstantExprKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCGCAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FallThroughAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCfCheckAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UserDefinedLiteralLiteralOperatorKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ARMInterruptAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprLValueClassification) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AtomicType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCIndependentClassAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FastCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingIfExistsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUWavesPerEUAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IncompleteArrayType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCEncodeExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FinalAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UuidAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprNullPointerConstantKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumVGPRAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCIvarDeclAccessControl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentSizedArrayType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCallerSavedRegistersAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FlagEnumAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VarDeclDefinitionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCDictionaryLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FlattenAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VarDeclInitializationStyle) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprNullPointerConstantValueDependence) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumSGPRAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCMessageExprReceiverKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstantArrayType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnyX86InterruptAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FormatArgAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VarDeclTLSKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoxedExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUKernelCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AdjustedType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprSideEffectsKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamilyAttrFamilyKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FormatAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VecReturnAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnalyzerNoReturnAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoolLiteralExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUFlatWorkGroupSizeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprisModifiableLvalueResult) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DecayedType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamilyAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionDeclTemplatedKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VectorCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionReturnThunksAttrKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExternalSourceSymbolAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VisibilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCNSObjectAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AArch64VectorPcsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlwaysDestroyAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeWithKeyword) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionReturnThunksAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAvailabilityCheckExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VisibilityAttrVisibilityType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AArch64SVEPcsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FallThroughAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ElaboratedType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonLazyClassAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AllocSizeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionTypeAArch64SMETypeAttributes) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCArrayLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ZeroCallUsedRegsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentTemplateSpecializationType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FastCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonRuntimeProtocolAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionTypeArmStateValue) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedResultAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GNUInlineAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WeakAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AllocAlignAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::XRayLogArgsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPIteratorExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentNameType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GuardedVarAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FinalAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WeakImportAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCOwnershipAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::XRayInstrumentAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VectorType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HIPManagedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WeakRefAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::X86ForceAlignArgPointerAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FlagEnumAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExtVectorType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPreciseLifetimeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLParamModifierAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlignedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyExportNameAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPArrayShapingExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLShaderAttrShaderType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FlattenAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportModuleAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyDeclPropertyControl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WorkGroupSizeHintAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlignNaturalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPArraySectionExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HotAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportNameAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportNameAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FormatArgAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingShadowDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyDeclSetterKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IBActionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::X86ForceAlignArgPointerAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlignMac68kAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AllocSizeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoInitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportModuleAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FormatAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IBOutletAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyImplDeclKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::XRayInstrumentAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BaseUsingDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionDeclTemplatedKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresPropertyDefsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IBOutletCollectionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::XRayLogArgsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AcquiredBeforeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyExportNameAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MemberExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IFuncAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionReturnThunksAttrKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ZeroCallUsedRegsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresSuperAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WeakRefAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnaryTransformType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AcquiredAfterAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MatrixSubscriptExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImplicitCastExprOnStack) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionReturnThunksAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCReturnsInnerPointerAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WeakImportAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingTypenameDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InitPriorityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ASTDumpOutputFormat) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AcquireHandleAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IntelOclBiccAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MaterializeTemporaryExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AccessSpecifier) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WeakAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionTypeAArch64SMETypeAttributes) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypedefType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRootClassAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InternalLinkageAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionTypeArmStateValue) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AddrSpaceMapMangling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeNameAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedResultAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AcquireCapabilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeOfType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LTOVisibilityPublicAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlignRequirementKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LifetimeExtendedTemporaryDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GNUInlineAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeVisibleAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeOfExprType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AVRSignalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LeafAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSPropertySubscriptExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AltivecSrcCompatKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GuardedVarAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LifetimeBoundAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubclassingRestrictedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArgumentKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VisibilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SEHTryStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AVRInterruptAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LikelyAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HIPManagedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArraySizeModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLAccessAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VectorCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSPropertyRefExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SEHExceptStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LoaderUninitializedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArrayTypeTrait) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Index) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VecTypeHintAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLParamModifierAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CompoundStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLConstantAddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttrLoopHintState) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ARMInterruptAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AtomicScopeModelKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUKernelCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttrOptionType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSPropertyDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AutoTypeKeyword) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLShaderAttrShaderType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VecReturnAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGenericAddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SEHFinallyStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUWavesPerEUAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LambdaExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AvailabilityResult) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HotAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UuidAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalAddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SEHLeaveStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::M68kRTDAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BinaryOperatorKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumVGPRAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSGuidDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IntegerLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IBActionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MIGServerRoutineAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Bits) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSABIAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXConstructionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IBOutletAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingIfExistsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalHostAddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCForCollectionStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumSGPRAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImplicitValueInitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSInheritanceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXNewInitializationStyle) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAutoreleasePoolStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IBOutletCollectionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSP430InterruptAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLKernelAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallingConv) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUKernelCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnusedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImaginaryLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtTryStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSStructAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CanThrowResult) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IFuncAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLLocalAddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MayAliasAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CapturedRegionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnsafeBufferUsageAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUFlatWorkGroupSizeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtFinallyStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GenericSelectionExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MaybeUndefAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CastKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImplicitCastExprOnStack) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UninitializedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLPrivateAddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtCatchStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MicroMipsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InitPriorityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CharacterLiteralKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OptimizeNoneAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnavailableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AArch64VectorPcsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtThrowStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MinSizeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GNUNullExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ClangABI) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IntelOclBiccAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MinVectorWidthAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OverloadableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CommentKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeVisibilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AArch64SVEPcsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtSynchronizedStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionParmPackExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InternalLinkageAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Mips16AttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OwnershipAttrOwnershipKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ComparisonCategoryResult) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeTagForDatatypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPExecutableDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ZeroCallUsedRegsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FullExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MipsInterruptAttrInterruptType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LTOVisibilityPublicAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ComparisonCategoryType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OwnershipAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(FilePathMap) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TryAcquireCapabilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CapturedStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MipsInterruptAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CompilingModuleKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LeafAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PackedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MipsLongCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::XRayLogArgsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ComplexRangeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TrivialABIAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprWithCleanups) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CapturedDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MipsShortCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LifetimeBoundAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstantResultStorageKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParamTypestateAttrConsumedState) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TransparentUnionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPErrorDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::XRayInstrumentAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ModeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstantExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstexprSpecKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUKernelCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ThisCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LikelyAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDispatchDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParamTypestateAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MustTailAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoreFoundationABI) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::X86ForceAlignArgPointerAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSConsumedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FloatingLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DataPositionTy) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LoaderUninitializedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TestTypestateAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PascalAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDepobjDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSConsumesSelfAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeductionCandidate) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttrLoopHintState) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TargetVersionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PassObjectSizeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPCriticalDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WorkGroupSizeHintAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsAutoreleasedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DefaultArgKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TargetClonesAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FixedPointLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPCancellationPointDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttrOptionType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsNotRetainedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PatchableFunctionEntryAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DefaultCallingConvention) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportNameAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExtVectorElementExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsRetainedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DefaultVisiblityExportMapping) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TargetAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPCancelDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PcsAttrPCSType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NVPTXKernelAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DesignatorKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportModuleAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TLSModelAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExpressionTraitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPBarrierDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::M68kRTDAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NakedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PcsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DiagnosticLevelMask) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SysVABIAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPAtomicDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NamedDeclExplicitVisibilityKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ElaboratedTypeKeyword) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MIGServerRoutineAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoBuiltinAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreferredNameAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EscapeChar) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyExportNameAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftPrivateAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AttributedStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoCommonAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExceptionHandlingKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSABIAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftNewTypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreferredTypeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskyieldDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WeakRefAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDebugAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExceptionSpecificationType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwitchStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftNameAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskwaitDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSInheritanceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDerefAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreserveAllAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExcessPrecisionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDestroyAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExplicitSpecKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftImportPropertyAsAccessorsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskgroupDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WeakImportAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwitchCase) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDuplicateAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSP430InterruptAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprDependence) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreserveMostAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftImportAsNonGenericAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoEscapeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprObjectKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSStructAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PtGuardedVarAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WeakAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetUpdateDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DefaultStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoInlineAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprOffsets) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoInstrumentFunctionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MayAliasAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprValueKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PureAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedResultAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CaseStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoMergeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MaybeUndefAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExpressionTrait) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypeDestructionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftBridgedTypedefAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AccessSpecDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MicroMipsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypeNonConstantStorageReason) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoMicroMipsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExtKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Decl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftBridgeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypePrimitiveCopyKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetExitDataDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MinSizeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoMips16AttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VisibilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExtendArgsKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoProfileFunctionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclarativeDirectiveDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FPEvalMethodKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAttrAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MinVectorWidthAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelSectionsDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypePrimitiveDefaultInitializeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoRandomizeLayoutAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VectorCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FPExceptionModeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPThreadPrivateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncNameAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetEnterDataDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Mips16AttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RISCVInterruptAttrInterruptType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoReturnAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VecTypeHintAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FPModeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPRequiresDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncErrorAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MipsInterruptAttrInterruptType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RISCVInterruptAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoSanitizeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Flags) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoSpeculativeLoadHardeningAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MipsInterruptAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GC) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RandomizeLayoutAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetDataDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VecReturnAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPAllocateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoSplitStackAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GCMode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPSingleDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MipsLongCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReadOnlyPlacementAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UuidAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoStackProtectorAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TranslationUnitDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GPUDefaultStreamKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Stmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MipsShortCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StrictGuardStackCheckAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RegCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPSectionsDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoThreadSafetyAnalysisAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GVALinkage) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSGuidDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoThrowAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TopLevelStmtDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GetBuiltinTypeError) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ModeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StrictFPAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReinitializesAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPSectionDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MustTailAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReleaseCapabilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingIfExistsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoUniqueAddressAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLLangStd) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StdCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StaticAssertDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPScopeDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoUwtableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSConsumedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ID) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReleaseHandleAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StandaloneDebugAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPScanDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaDetectMismatchDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Compilation) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NonNullAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IdentifierInfoFlag) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSConsumesSelfAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RequiresCapabilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NotTailCalledAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IfStatementKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnusedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SpeculativeLoadHardeningAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaCommentDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMasterDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsAutoreleasedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPAllocateDeclAttrAllocatorTypeTy) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RestrictAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImplicitParamKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SharedTrylockFunctionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMaskedDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareSimdDeclAttrBranchStateTy) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsNotRetainedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InClassInitStyle) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RetainAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnsafeBufferUsageAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SetTypestateAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLBufferDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareTargetDeclAttrDevTypeTy) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsRetainedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InheritedDesignatedInitializersState) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnTypestateAttrConsumedState) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UninitializedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingEnumDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareTargetDeclAttrMapTypeTy) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InitStorageKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SentinelAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NVPTXKernelAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPOrderedDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnTypestateAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSConsumedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InlineVariableDefinitionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SelectAnyAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnavailableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPMetaDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnumDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSConsumesThisAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InterestingIdentifierKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NakedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnsNonNullAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SectionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPMasterDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsNotRetainedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Kinds) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NamedDeclExplicitVisibilityKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AArch64VectorPcsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnsTwiceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeVisibilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnumConstantDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LambdaCaptureDefault) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ScopedLockableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPMaskedDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoBuiltinAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SYCLKernelAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnNonZeroAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeTagForDatatypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LambdaCaptureKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUFlatWorkGroupSizeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SYCLSpecialClassAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPLoopBasedDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoCommonAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SYCLSpecialClassAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnZeroAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LangAS) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TryAcquireCapabilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingValueDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AliasAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SYCLKernelAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDebugAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPLoopTransformationDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ScopedLockableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoxableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LangFeatures) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumSGPRAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDerefAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlignedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SectionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TrivialABIAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Language) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnnamedGlobalConstantDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnsTwiceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPUnrollDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDestroyAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeMutableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SelectAnyAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LanguageLinkage) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TransparentUnionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnsNonNullAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTileDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateParamObjectDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumVGPRAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeRelatedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDuplicateAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LaxVectorConversionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SentinelAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnTypestateAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ThisCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCClassStubAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareReductionDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Level) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoEscapeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCDesignatedInitializerAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SetTypestateAttrConsumedState) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Linkage) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RetainAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPGenericLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoInlineAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SetTypestateAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LinkageSpecLanguageIDs) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TestTypestateAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPCapturedExprDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RestrictAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPForSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoInstrumentFunctionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Fragment) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SpeculativeLoadHardeningAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TargetVersionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectMembersAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DecompositionDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSInheritanceModel) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoMergeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StandaloneDebugAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RequiresCapabilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPForDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TargetClonesAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCExceptionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSVCMajorVersion) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoMicroMipsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCExplicitProtocolImplAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StdCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSVtorDispMode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReqdWorkGroupSizeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BindingDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoMips16AttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroVAOptArgument) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StmtLikelihood) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TargetAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VarTemplateSpecializationDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroConcatenate) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoProfileFunctionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroStringify) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StmtKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TLSModelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VarTemplatePartialSpecializationDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroExpansion) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoRandomizeLayoutAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SuppressAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Macro) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AArch64VectorPcsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SysVABIAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroArgument) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXConversionDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoReturnAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncAttrKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroParameterSubstitution) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoSanitizeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftPrivateAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXDeductionGuideDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroParameter) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IRInstruction) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoSpeculativeLoadHardeningAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftNewTypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtDefsFieldDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoSplitStackAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncContextAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UndefineMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftNameAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclarativeDirectiveValueDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OtherMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoStackProtectorAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncErrorAttrConventionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConditionalMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoThreadSafetyAnalysisAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncErrorAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftImportPropertyAsAccessorsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EndIfMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareMapperDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoThrowAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ElseMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftImportAsNonGenericAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstructorUsingShadowDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ElseIfNotDefinedMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoUniqueAddressAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftContextAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingPackDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ElseIfDefinedMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoUwtableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorAttrConventionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NonNullAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlwaysDestroyAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorResultAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ElseIfMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingDirectiveDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NotTailCalledAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUFlatWorkGroupSizeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IfNotDefinedMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftIndirectResultAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftBridgedTypedefAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlwaysInlineAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IfDefinedMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPAllocateDeclAttrAllocatorTypeTy) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnnotateAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftNewTypeAttrNewtypeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftBridgeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnnotateTypeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingIfExistsDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IfMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareSimdDeclAttrBranchStateTy) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftNewTypeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnyX86InterruptAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IncludeLikeMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareTargetDeclAttrDevTypeTy) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SysVABIAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAttrAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCallerSavedRegistersAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ClassTemplateSpecializationDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImportMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareTargetDeclAttrMapTypeTy) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCfCheckAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TLSModelAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IRObject) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncNameAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ClassTemplatePartialSpecializationDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArcWeakrefUnavailableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(EntityId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IncludeMacrosMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSConsumedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TargetAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArgumentWithTypeTagAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IncludeNextMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmBuiltinAliasAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncErrorAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypedefDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSConsumesThisAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TargetClonesAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IncludeMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsNotRetainedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmMveStrictPolymorphismAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TargetVersionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeAliasDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArtificialAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AsmLabelAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateArgumentKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssertCapabilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssumeAlignedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeAliasTemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(VariantEntity) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnNonZeroAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TestTypestateAttrConsumedState) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssumptionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AtomicExprAtomicOp) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StrictGuardStackCheckAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnZeroAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TestTypestateAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AvailabilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinTemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoxableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AvailableOnlyInDefaultEvalMethodAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ThisCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StrictFPAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedStmtId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveAccessIndexAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateTemplateParmDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveStaticOffsetAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TransparentUnionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StdCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCCompatibleAliasDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BTFDeclTagAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeMutableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TrivialABIAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BTFTypeTagAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BlocksAttrBlockType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StandaloneDebugAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BlocksAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeRelatedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TryAcquireCapabilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinAliasAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(std::filesystem::path) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCClassStubAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinTypeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeScalarTypeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SpeculativeLoadHardeningAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LinkageSpecDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CDeclAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstantMatrixType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFAuditedTransferAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImportDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroQualifiedType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFConsumedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FriendTemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ComplexType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFGuardAttrGuardArg) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedAttrId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InjectedClassNameType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFGuardAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FileScopeAsmDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExternCContextDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFICanonicalJumpTableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedMacroId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsNotRetainedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionProtoType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExportDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsRetainedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionNoProtoType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EmptyDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFUnknownTransferAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentVectorType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CPUDispatchAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CPUSpecificAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(std::string_view) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentSizedExtVectorType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroSubstitution) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAConstantAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentBitIntType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroVAOpt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentAddressSpaceType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EmptyTokenTreeNode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinTextureTypeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAGlobalAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeducedType) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedTypeId) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenTokenTreeNode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAHostAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeducedTemplateSpecializationType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDALaunchBoundsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ChoiceTokenTreeNode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedTemplateArgumentId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDASharedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AutoType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SubstitutionTokenTreeNode) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXX11NoReturnAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConceptDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SequenceTokenTreeNode) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedTemplateParameterListId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXRecordDeclLambdaDependencyKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DecltypeType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallExprADLCallKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroVAOptArgument) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallableWhenAttrConsumedState) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedCXXBaseSpecifierId) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroConcatenate) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallableWhenAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BlockPointerType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroStringify) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallbackAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedDesignatorId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CalledOnceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BitIntType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroExpansion) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CapabilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BTFTagAttributedType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroArgument) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AVRSignalAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedCXXCtorInitializerId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CapturedStmtVariableCaptureKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AttributedType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroParameterSubstitution) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CarriesDependencyAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AbiTagAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AtomicType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroParameter) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CleanupAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CodeAlignAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IncompleteArrayType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CodeModelAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ColdAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentSizedArrayType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CommonAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UndefineMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstantArrayType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OtherMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstInitAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstructorAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AdjustedType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAttrConsumedState) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConditionalMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DecayedType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedFileId) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EndIfMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAutoCastAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeWithKeyword) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ElseMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConsumableSetOnReadAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ElaboratedType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConvergentAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ElseIfNotDefinedMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroDisableLifetimeBoundAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentTemplateSpecializationType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroLifetimeBoundAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ElseIfDefinedMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroOnlyDestroyWhenCompleteAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(EntityId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentNameType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroReturnTypeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ElseIfMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::variant) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroWrapperAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VectorType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IfNotDefinedMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CountedByAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedFragmentId) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExtVectorType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DLLExportAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IfDefinedMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DLLImportAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IfMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclFriendObjectKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingShadowDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedCompilationId) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IncludeLikeMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclIdentifierNamespace) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclModuleOwnershipKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BaseUsingDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImportMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclObjCDeclQualifier) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeprecatedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IncludeMacrosMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(PackedDeclId) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(VariantEntity) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DestructorAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnaryTransformType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IncludeNextMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseAsBuiltinAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseIfAttrDiagnosticType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingTypenameDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IncludeMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DisableSanitizerInstrumentationAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DisableTailCallsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypedefType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeOfType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedStmtId) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBLeafAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnumExtensibilityAttrKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeOfExprType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::File) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnumExtensibilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SEHTryStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ErrorAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SEHExceptStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReleaseCapabilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CStyleCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CompoundStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReinitializesAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinBitCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SEHFinallyStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RegCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgedCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SEHLeaveStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReadOnlyPlacementAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RandomizeLayoutAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(std::filesystem::path) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXOperatorCallExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCForCollectionStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RISCVInterruptAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXMemberCallExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAutoreleasePoolStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NamespaceDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtTryStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PureAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAKernelCallExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedAttrId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PtGuardedVarAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtFinallyStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UserDefinedLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtCatchStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PtGuardedByAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXUuidofExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedMacroId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtThrowStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreserveMostAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtSynchronizedStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXUnresolvedConstructExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPExecutableDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreserveAllAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXTypeidExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(std::string_view) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CapturedStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreferredTypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXThrowExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CapturedDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreferredNameAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPErrorDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXNewExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangTextSectionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXThisExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDispatchDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedTypeId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangRodataSectionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXStdInitializerListExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDepobjDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPCriticalDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::vector) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedTemplateArgumentId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangRelroSectionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXScalarValueInitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPCancellationPointDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangDataSectionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedTemplateParameterListId) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXRewrittenBinaryOperator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPCancelDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPBarrierDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangBSSSectionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXPseudoDestructorExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedCXXBaseSpecifierId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PointerAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPAtomicDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXParenListInitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PcsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedDesignatorId) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXNullPtrLiteralExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskyieldDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PatchableFunctionEntryAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskwaitDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXNoexceptExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedCXXCtorInitializerId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PascalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskgroupDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXConstructExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AVRSignalAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParamTypestateAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXInheritedCtorInitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetUpdateDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PackedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AbiTagAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXFoldExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OwnershipAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXDependentScopeMemberExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetExitDataDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OwnerAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXDeleteExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelSectionsDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OverrideAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXDefaultInitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetEnterDataDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OptimizeNoneAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXDefaultArgExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedFileId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLKernelAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetDataDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXTemporaryObjectExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPSingleDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLIntelReqdSubGroupSizeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXBoolLiteralExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPSectionsDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubclassingRestrictedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXBindTemporaryExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPSectionDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRootClassAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPScopeDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BlockExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCReturnsInnerPointerAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AcquireHandleAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BlockDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPScanDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresSuperAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BinaryOperator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AddressSpaceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMasterDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresPropertyDefsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CompoundAssignOperator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPreciseLifetimeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AtomicExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Attr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCOwnershipAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AsTypeExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::File) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCNSObjectAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArrayTypeTraitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Macro) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamilyAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArraySubscriptExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Reference) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NamespaceAliasDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReferenceKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCIndependentClassAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArrayInitLoopExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Type) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCExternallyRetainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArrayInitIndexExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateArgument) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCExplicitProtocolImplAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AbstractConditionalOperator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateParameterList) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXBaseSpecifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCExceptionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConditionalOperator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Designator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeRelatedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BinaryConditionalOperator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXCtorInitializer) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeMutableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VAArgExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AllocAlignAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FieldDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnaryOperator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclaratorDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ValueDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnZeroAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnaryExprOrTypeTraitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NamedDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnNonZeroAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypoExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VarDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VarTemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeTraitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RedeclarableTemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsNotRetainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Expr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SubstNonTypeTemplateParmPackExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ValueStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSConsumesThisAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NonTypeTemplateParmDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyRefExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPThreadPrivateDeclAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SubstNonTypeTemplateParmExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCInterfaceDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCContainerDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareVariantAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StmtExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareTargetDeclAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SourceLocExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCIvarDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPCaptureNoInitAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImplicitParamDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SizeOfPackExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParmVarDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPAllocateDeclAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ShuffleVectorExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCProtocolDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCImplementationDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NotTailCalledAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SYCLUniqueStableNameExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCImplDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyImplDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoUwtableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCCategoryDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RequiresExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoUniqueAddressAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCCategoryImplDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RequiresExprBodyDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VariableArrayType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArrayType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IndirectFieldDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoThrowAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RecoveryExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXRecordDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoThreadSafetyAnalysisAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PseudoObjectExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RecordDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TagDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoStackProtectorAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PredefinedExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypedefNameDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXConstructorDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoSplitStackAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParenListExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXMethodDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoSpeculativeLoadHardeningAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParenExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionTemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FriendDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ClassTemplateDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoSanitizeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PackExpansionExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXDestructorDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenContext) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumSGPRAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoReturnAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedMemberExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUNumVGPRAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoRandomizeLayoutAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenTree) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OffsetOfExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenTreeNode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoProfileFunctionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RegexQuery) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubscriptRefExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DefineMacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoMips16Attr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCStringLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExternalSourceSymbolAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Decl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoMicroMipsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCSelectorExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InheritableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoInstrumentFunctionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCProtocolExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlignValueAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AliasAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDuplicateAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::variant) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCMessageExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDestroyAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCIvarRefExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlignedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDebugAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCIsaExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoCommonAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCIndirectCopyRestoreExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoAliasAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCEncodeExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NakedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCDictionaryLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AllocSizeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RegexQueryMatch) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NVPTXKernelAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoxedExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenRange) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsRetainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoolLiteralExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsNotRetainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAvailabilityCheckExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsAutoreleasedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCArrayLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSErrorDomainAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPIteratorExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSConsumesSelfAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPArrayShapingExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MipsShortCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPArraySectionExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MipsLongCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoInitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(FragmentIdList) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCExternallyRetainedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeParallelForSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCGCAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeParallelForDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCIndependentClassAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCIvarDeclAccessControl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCMessageExprReceiverKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsGenericLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamilyAttrFamilyKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamilyAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeParallelForSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCNSObjectAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonLazyClassAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeParallelForDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonRuntimeProtocolAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCOwnershipAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskLoopSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPreciseLifetimeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyDeclPropertyControl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyDeclSetterKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsGenericLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyImplDeclKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresPropertyDefsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresSuperAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeParallelForSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCReturnsInnerPointerAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMasterTaskLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRootClassAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeParallelForDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeNameAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeVisibleAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubclassingRestrictedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLAccessAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelGenericLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLConstantAddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGenericAddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelForSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalAddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelForDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalHostAddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLKernelAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMasterTaskLoopSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLLocalAddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMaskedTaskLoopSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLPrivateAddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMaskedTaskLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OptimizeNoneAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OverloadableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelGenericLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OwnershipAttrOwnershipKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelForSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OwnershipAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelForDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PackedAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParamTypestateAttrConsumedState) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPMasterTaskLoopSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParamTypestateAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPMasterTaskLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PascalAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPMaskedTaskLoopSimdDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PassObjectSizeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PatchableFunctionEntryAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPMaskedTaskLoopDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PcsAttrPCSType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPInteropDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PcsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPFlushDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreferredNameAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreferredTypeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPCanonicalLoop) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreserveAllAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclRefExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PreserveMostAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NullStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PtGuardedVarAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PureAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSDependentExistsStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypeDestructionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IndirectGotoStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypeNonConstantStorageReason) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LabelDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypePrimitiveCopyKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::QualifiedTypePrimitiveDefaultInitializeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LabelStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RISCVInterruptAttrInterruptType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXTryStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RISCVInterruptAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IfStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RandomizeLayoutAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReadOnlyPlacementAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RegCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GotoStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReinitializesAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ForStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReleaseCapabilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReleaseHandleAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DoStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RequiresCapabilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroutineBodyStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RestrictAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoreturnStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RetainAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnTypestateAttrConsumedState) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ContinueStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnTypestateAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXCatchStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnsNonNullAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXForRangeStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReturnsTwiceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SYCLKernelAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BreakStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SYCLSpecialClassAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AsmStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ScopedLockableAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSAsmStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SectionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SelectAnyAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GCCAsmStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SentinelAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StringLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SetTypestateAttrConsumedState) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AddrLabelExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SetTypestateAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SpeculativeLoadHardeningAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WhileStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StandaloneDebugAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DesignatedInitUpdateExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StdCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InitListExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(uint32_t) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StmtLikelihood) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StmtKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DesignatedInitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SuppressAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentScopeDeclRefExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(uint64_t) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncAttrKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentCoawaitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedLookupExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncContextAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OverloadExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(bool) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncErrorAttrConventionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroutineSuspendExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncErrorAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpaqueValueExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftContextAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoawaitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorAttrConventionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoyieldExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorResultAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(uint32_t) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftIndirectResultAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConvertVectorExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftNewTypeAttrNewtypeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(uint64_t) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConceptSpecializationExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftNewTypeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImplicitConceptSpecializationDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SysVABIAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(bool) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TLSModelAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CompoundLiteralExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TargetAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ChooseExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TargetClonesAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CharacterLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TargetVersionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AttrKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateArgumentKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TestTypestateAttrConsumedState) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AliasAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImplicitCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SharedTrylockFunctionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TestTypestateAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AArch64SVEPcsAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AbiTagAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SetTypestateAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExplicitCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ThisCallAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SentinelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TransparentUnionAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXNamedCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SPtrAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TrivialABIAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SelectAnyAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXDynamicCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Ptr64Attr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TryAcquireCapabilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SectionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenContext) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Ptr32Attr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXConstCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ScopedLockableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeScalarTypeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLPrivateAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXAddrspaceCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SYCLSpecialClassAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeTagForDatatypeAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXStaticCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLLocalAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeVisibilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SYCLKernelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXReinterpretCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalHostAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeVisibilityAttrVisibilityType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnsTwiceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnaryTransformTypeUTTKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalDeviceAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXFunctionalCastExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnsNonNullAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCGCAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MemberExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReturnTypestateAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGenericAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoDerefAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RetainAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MatrixSubscriptExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLConstantAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RestrictAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCKindOfAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLParamModifierAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RequiresCapabilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MaterializeTemporaryExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCInertUnsafeUnretainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReqdWorkGroupSizeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLGroupSharedAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCGCAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LifetimeExtendedTemporaryDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReleaseCapabilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDerefAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReinitializesAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CmseNSCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLParamModifierAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSPropertySubscriptExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RegCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLGroupSharedAddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReadOnlyPlacementAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnnotateTypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CmseNSCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSPropertyRefExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RandomizeLayoutAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnnotateTypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BTFTypeTagAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RISCVInterruptAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSPropertyDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BTFTypeTagAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PureAttr) noexcept; template MX_EXPORT SharedPyObject *to_python(mx::ArmStreamingCompatibleAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PtGuardedVarAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LambdaExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmStreamingAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PtGuardedByAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmStreamingAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmPreservesAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IntegerLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreserveMostAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmPreservesAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImplicitValueInitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmOutAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreserveAllAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmMveStrictPolymorphismAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreferredTypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmOutAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmInOutAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImaginaryLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PreferredNameAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmInAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangTextSectionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmMveStrictPolymorphismAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AddressSpaceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GenericSelectionExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangRodataSectionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyFuncrefAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmInOutAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangRelroSectionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GNUNullExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UPtrAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangDataSectionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeNullableResultAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmInAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaClangBSSSectionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionParmPackExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeNullableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PointerAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeNullUnspecifiedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PcsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeNonNullAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FullExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PatchableFunctionEntryAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ThreadAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PascalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyFuncrefAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftVersionedRemovalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParamTypestateAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExprWithCleanups) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftVersionedAdditionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PackedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftObjCMembersAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OwnershipAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StmtAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UPtrAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OwnerAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstantExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLUnrollHintAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OverrideAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeNullableResultAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MustTailAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FloatingLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OptimizeNoneAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AllocAlignAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LikelyAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeNullableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLKernelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FixedPointLiteral) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FallThroughAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLIntelReqdSubGroupSizeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeNullUnspecifiedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CodeAlignAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExtVectorElementExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubclassingRestrictedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnlikelyAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRootClassAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeNonNullAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RenderScriptKernelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCReturnsInnerPointerAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExpressionTraitExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OverloadableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresSuperAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenCLAccessAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ThreadAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRequiresPropertyDefsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AttributedStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeVisibleAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftVersionedRemovalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPreciseLifetimeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwitchStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeNameAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCOwnershipAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonRuntimeProtocolAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCNSObjectAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftVersionedAdditionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwitchCase) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonLazyClassAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamilyAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectMembersAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftObjCMembersAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCIndependentClassAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DefaultStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoBuiltinAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCExternallyRetainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCExplicitProtocolImplAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StmtAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CaseStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCDesignatedInitializerAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCExceptionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCClassStubAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLUnrollHintAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeRelatedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AccessSpecDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoxableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeMutableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MustTailAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPReferencedVarAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclarativeDirectiveDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareSimdDeclAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnZeroAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPCaptureKindAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedOnNonZeroAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LikelyAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoEscapeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPThreadPrivateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsRetainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ModeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSReturnsNotRetainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FallThroughAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPRequiresDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSConsumesThisAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LoaderUninitializedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPThreadPrivateDeclAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CodeAlignAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InitSegAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareVariantAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IBOutletCollectionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPAllocateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareTargetDeclAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IBOutletAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnlikelyAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPCaptureNoInitAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TranslationUnitDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IBActionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPAllocateDeclAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RenderScriptKernelAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HotAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NotTailCalledAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TopLevelStmtDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLShaderAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoUwtableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OverloadableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLResourceBindingAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoUniqueAddressAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StaticAssertDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLResourceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoThrowAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLNumThreadsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLAccessAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoThreadSafetyAnalysisAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaDetectMismatchDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLAnnotationAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoStackProtectorAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeVisibleAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLSV_GroupIndexAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoSplitStackAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaCommentDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLSV_DispatchThreadIDAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCRuntimeNameAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoSpeculativeLoadHardeningAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLBufferDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HIPManagedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoSanitizeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonRuntimeProtocolAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GuardedVarAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoReturnAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingEnumDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GuardedByAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCNonLazyClassAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoRandomizeLayoutAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnumDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GNUInlineAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectMembersAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoProfileFunctionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnumConstantDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FunctionReturnThunksAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoMips16Attr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FormatAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoMicroMipsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoBuiltinAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Linkage) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedFragmentId) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCDirectAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingValueDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LinkageSpecLanguageIDs) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCDesignatedInitializerAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSInheritanceModel) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnnamedGlobalConstantDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCClassStubAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateParamObjectDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedCompilationId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBoxableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSVCMajorVersion) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareReductionDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPReferencedVarAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSVtorDispMode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPCapturedExprDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MethodRefFlags) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareSimdDeclAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DecompositionDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ModifiableType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPCaptureKindAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BindingDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MultiVersionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(PackedDeclId) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoEscapeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VarTemplateSpecializationDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NameKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NeedExtraManglingDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ModeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VarTemplatePartialSpecializationDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NestedNameSpecifierDependence) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LoopHintAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NonOdrUseReason) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXConversionDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NonceObjCInterface) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NullabilityKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LoaderUninitializedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXDeductionGuideDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InitSegAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareReductionInitKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeCastKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCAtDefsFieldDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCImplementationControl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IBOutletCollectionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclarativeDirectiveValueDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCInstanceTypeFamily) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IBOutletAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareMapperDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IBActionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCLifetime) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstructorUsingShadowDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamily) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HotAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingPackDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyQueryKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLShaderAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCStringFormatFamily) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UsingDirectiveDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLResourceBindingAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NamespaceDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubstitutionContext) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLResourceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedUsingIfExistsDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCTypeParamVariance) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLNumThreadsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OnOffSwitch) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ClassTemplateSpecializationDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLAnnotationAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OnStackType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ClassTemplatePartialSpecializationDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLSV_GroupIndexAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypedefDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPAdjustArgsOpKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HLSLSV_DispatchThreadIDAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPAtClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeAliasDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::HIPManagedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeAliasTemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPAtomicDefaultMemOrderClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPBindClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GuardedVarAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinTemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDefaultmapClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GuardedByAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateTemplateParmDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDefaultmapClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::GNUInlineAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCCompatibleAliasDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDependClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionReturnThunksAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NamespaceAliasDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDeviceClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FormatAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDeviceType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LinkageSpecDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDistScheduleClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FormatArgAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDoacrossClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImportDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPGrainsizeClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FlattenAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FriendTemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPLastprivateModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBLeafAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPLinearClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPMapClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FlagEnumAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FileScopeAsmDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPMapModifierKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FinalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExternCContextDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPMotionModifierKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FastCallAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPNumTasksClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExportDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPOrderClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPOrderClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExclusiveTrylockFunctionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EmptyDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPReductionClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExcludeFromExplicitInstantiationAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPScheduleClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ErrorAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroSubstitution) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPScheduleClauseModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnumExtensibilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroVAOpt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpenMPSeverityClauseKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OverloadedOperatorKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EmptyTokenTreeNode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OverloadsShown) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AcquireHandleAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParameterABI) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnableIfAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenTokenTreeNode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParenLocsOffsets) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AddressSpaceAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EmptyBasesAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ChoiceTokenTreeNode) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaFPKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaFloatControlKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DisableTailCallsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SubstitutionTokenTreeNode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaMSCommentKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DisableSanitizerInstrumentationAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SequenceTokenTreeNode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaMSPointersToMembersKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MipsInterruptAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaMSStructKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PragmaSectionFlag) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Mips16Attr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PredefinedIdentKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MinVectorWidthAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Qualified) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RangeExprOffset) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUWavesPerEUAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MinSizeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RangeLocOffset) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RecordArgPassingKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ARMInterruptAttrInterruptType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MicroMipsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RefQualifierKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReservedIdentifierStatus) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MaybeUndefAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReservedLiteralSuffixIdStatus) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RegexQueryMatch) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SFINAEResponse) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MayAliasAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SYCLMajorVersion) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MaxFieldAlignmentAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SanitizerOrdinal) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SelectorLocationsKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSVtorDispAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ShaderStage) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SignReturnAddressKeyKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSStructAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenRange) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SignReturnAddressScopeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SignedOverflowBehaviorTy) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSP430InterruptAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SourceLocIdentKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SpecialMemberFlags) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSNoVTableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SpecifierKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSInheritanceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StackProtectorMode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StorageClass) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSConstexprAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StorageDuration) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSAllocatorAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StoredNameKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MSABIAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StoredSpecifierKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StrictFlexArraysLevelKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MIGServerRoutineAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StringLiteralKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::M68kRTDAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SubExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SubStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::M68kInterruptAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SyncScope) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Syntax) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TQ) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LocksExcludedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TagTypeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LockReturnedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TailPaddingUseRules) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateArgumentDependence) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LifetimeBoundAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateNameDependence) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateSpecializationKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LeafAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TextDiagnosticFormat) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LayoutVersionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ThreadModelKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ThreadStorageClassSpecifier) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LTOVisibilityPublicAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TrailingAllocKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TranslationUnitKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InternalLinkageAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TrivialAutoVarInitKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IntelOclBiccAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeDependence) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InitPriorityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeLocClass) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeOfKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifierSign) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InheritableParamAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifierType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CarriesDependencyAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifierWidth) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifiersPipe) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFConsumedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeTrait) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnnotateAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnaryExprOrTypeTrait) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnaryOperatorKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UseHandleAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::APValueKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VectorKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoInstrumentFunctionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReleaseHandleAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Visibility) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDuplicateAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VisibilityForcedKinds) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PassObjectSizeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDestroyAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VisibilityFromDLLStorageClassKinds) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AttributeSyntax) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoDebugAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclCategory) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParameterABIAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoCommonAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PseudoKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftIndirectResultAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoAliasAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EntityCategory) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorResultAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IREntityKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NakedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NVPTXKernelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MacroKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftContextAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsRetainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinReferenceKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsNotRetainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSReturnsAutoreleasedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncContextAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSErrorDomainAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OSConsumedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenTreeNodeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSConsumesSelfAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MipsShortCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NonNullAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TokenCategory) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MipsLongCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IndexStatus) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IncludePathLocation) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NSConsumedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MipsInterruptAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PathKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Mips16Attr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FileType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MinVectorWidthAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IFuncAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CompilerName) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TargetLanguage) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MinSizeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CalledOnceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AcquireCapabilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlwaysDestroyAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ir::OpCode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MicroMipsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ir::ObjectKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MaybeUndefAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinAliasAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlwaysInlineAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ir::BlockKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnnotateAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MayAliasAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateTypeParmType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnnotateTypeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MaxFieldAlignmentAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnyX86InterruptAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateTypeParmDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSVtorDispAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCallerSavedRegistersAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCfCheckAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSStructAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateSpecializationType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArcWeakrefUnavailableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSP430InterruptAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArgumentWithTypeTagAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TagType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSNoVTableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmBuiltinAliasAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RecordType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArmMveStrictPolymorphismAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSInheritanceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArtificialAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSConstexprAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Token) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EnumType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AsmLabelAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSAllocatorAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SubstTemplateTypeParmType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssertCapabilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssumeAlignedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSABIAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssumptionAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MIGServerRoutineAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SubstTemplateTypeParmPackType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AtomicExprAtomicOp) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::M68kRTDAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AvailabilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReferenceType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AvailableOnlyInDefaultEvalMethodAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::M68kInterruptAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveAccessIndexAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LocksExcludedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RValueReferenceType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveStaticOffsetAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LockReturnedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BTFDeclTagAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::LValueReferenceType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BTFTypeTagAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LifetimeBoundAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::QualifiedType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BlocksAttrBlockType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LeafAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BlocksAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LayoutVersionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PointerType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinAliasAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinTypeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LTOVisibilityPublicAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CDeclAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PipeType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InternalLinkageAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFAuditedTransferAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IntelOclBiccAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFConsumedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFGuardAttrGuardArg) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InitPriorityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParenType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFGuardAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InheritableParamAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PackExpansionType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFICanonicalJumpTableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CarriesDependencyAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsNotRetainedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsRetainedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCTypeParamType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFConsumedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFUnknownTransferAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AnnotateAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CPUDispatchAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCObjectType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UseHandleAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CPUSpecificAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAConstantAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReleaseHandleAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCTypeParamDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PassObjectSizeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParameterABIAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinTextureTypeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAGlobalAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftIndirectResultAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCInterfaceType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAHostAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftErrorResultAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDALaunchBoundsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftContextAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDASharedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCObjectPointerType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXX11NoReturnAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SwiftAsyncContextAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MemberPointerType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXRecordDeclLambdaDependencyKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OSConsumedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallExprADLCallKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MatrixType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NonNullAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallableWhenAttrConsumedState) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallableWhenAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NSConsumedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentSizedMatrixType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallbackAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IFuncAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstantMatrixType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CalledOnceAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CalledOnceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CapabilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroQualifiedType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CapturedStmtVariableCaptureKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinAliasAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CarriesDependencyAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ComplexType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateTypeParmType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CleanupAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateTypeParmDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CodeAlignAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CodeModelAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InjectedClassNameType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TemplateSpecializationType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ColdAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TagType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CommonAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RecordType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstInitAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionProtoType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnumType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstructorAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SubstTemplateTypeParmType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionNoProtoType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAttrConsumedState) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SubstTemplateTypeParmPackType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentVectorType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAutoCastAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ReferenceType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConsumableSetOnReadAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IRFunction) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentSizedExtVectorType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RValueReferenceType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConvergentAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LValueReferenceType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroDisableLifetimeBoundAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentBitIntType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroLifetimeBoundAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::QualifiedType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroOnlyDestroyWhenCompleteAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PointerType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DependentAddressSpaceType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AttrKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroReturnTypeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PipeType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeducedType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroWrapperAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AArch64SVEPcsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CountedByAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeducedTemplateSpecializationType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParenType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DLLExportAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PackExpansionType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DLLImportAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCTypeParamType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AutoType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclFriendObjectKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConceptDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclIdentifierNamespace) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCObjectType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclModuleOwnershipKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCTypeParamDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclObjCDeclQualifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IRBlock) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCInterfaceType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeprecatedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DestructorAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCObjectPointerType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseAsBuiltinAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReferenceKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MemberPointerType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseIfAttrDiagnosticType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Type) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MatrixType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DisableSanitizerInstrumentationAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DisableTailCallsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentSizedMatrixType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateArgument) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FormatArgAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateParameterList) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMaskedDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXBaseSpecifier) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConceptSpecializationExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Fragment) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeTagForDatatypeAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(FragmentIdList) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FlattenAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Designator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImplicitConceptSpecializationDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AMDGPUWavesPerEUAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXCtorInitializer) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeVisibilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBLeafAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPOrderedDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FieldDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeVisibilityAttrVisibilityType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CompoundLiteralExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclaratorDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ValueDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnaryTransformTypeUTTKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FlagEnumAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPMetaDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NamedDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ChooseExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VarDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnavailableAttrImplicitReason) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FinalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VarTemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPMasterDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RedeclarableTemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CharacterLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnavailableAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FastCallAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPMaskedDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UninitializedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Expr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnlikelyAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExclusiveTrylockFunctionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPLoopBasedDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ValueStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImplicitCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnsafeBufferUsageAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyRefExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExcludeFromExplicitInstantiationAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPLoopTransformationDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCInterfaceDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExplicitCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnusedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCContainerDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ErrorAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPUnrollDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXNamedCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UseHandleAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCIvarDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ImplicitParamDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnumExtensibilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParmVarDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTileDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXDynamicCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCProtocolDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UserDefinedLiteralLiteralOperatorKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnforceTCBAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCImplementationDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXConstCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCImplDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UsingIfExistsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyImplDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EnableIfAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPGenericLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCCategoryDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXAddrspaceCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UuidAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCCategoryImplDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VariableArrayType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VarDeclDefinitionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EmptyBasesAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArrayType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPForSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IndirectFieldDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXStaticCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXRecordDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VarDeclInitializationStyle) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RecordDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DisableTailCallsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TagDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPForDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXReinterpretCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypedefNameDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VarDeclTLSKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXConstructorDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DisableSanitizerInstrumentationAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXFunctionalCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXMethodDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VecReturnAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ARMInterruptAttrInterruptType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VectorCallAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseIfAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FunctionTemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FriendDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeParallelForSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CStyleCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VisibilityAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ClassTemplateDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseAsBuiltinAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXXDestructorDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeParallelForDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenTree) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinBitCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VisibilityAttrVisibilityType) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RegexQuery) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DestructorAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenTreeNode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPDistributeDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgedCastExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DefineMacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::vector) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroDirective) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WarnUnusedResultAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ExternalSourceSymbolAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeprecatedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsGenericLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::InheritableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlignValueAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(FilePathMap) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WeakAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AliasAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclOrStmtAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AbiTagAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXOperatorCallExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WeakImportAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlwaysInlineAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SPtrAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Ptr64Attr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Stmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WeakRefAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeParallelForSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Ptr32Attr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLPrivateAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXMemberCallExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLLocalAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyExportNameAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SuppressAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeParallelForDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalHostAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalDeviceAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAKernelCallExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Index) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGlobalAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportModuleAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLGenericAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenCLConstantAddressSpaceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoMergeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTeamsDistributeDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UserDefinedLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WebAssemblyImportNameAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCKindOfAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCInertUnsafeUnretainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NoInlineAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskLoopSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXUuidofExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MethodRefFlags) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::X86ForceAlignArgPointerAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclCategory) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Token) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseIfAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::XRayInstrumentAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ModifiableType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DLLImportStaticLocalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PseudoKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTaskLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DiagnoseAsBuiltinAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXUnresolvedConstructExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::XRayLogArgsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MultiVersionKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DLLImportAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::EntityCategory) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsGenericLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DestructorAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXTypeidExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NameKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ZeroCallUsedRegsAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Attr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NeedExtraManglingDecl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeprecatedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DLLExportStaticLocalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXThrowExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NestedNameSpecifierDependence) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::MacroKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DeclOrStmtAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NonOdrUseReason) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ASTDumpOutputFormat) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinReferenceKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DLLExportAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlwaysInlineAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeParallelForSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NonceObjCInterface) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXNewExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AccessSpecifier) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NullabilityKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CountedByAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SuppressAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMasterTaskLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXThisExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AddrSpaceMapMangling) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OMPDeclareReductionInitKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroWrapperAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoMergeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeParallelForDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCBridgeCastKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AlignRequirementKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::NoInlineAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXStdInitializerListExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCImplementationControl) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenTreeNodeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AltivecSrcCompatKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroReturnTypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCInstanceTypeFamily) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetTeamsDistributeDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DLLImportStaticLocalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXScalarValueInitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArgumentKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCLifetime) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroOnlyDestroyWhenCompleteAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TokenCategory) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXRewrittenBinaryOperator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DLLImportAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArraySizeModifier) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCMethodFamily) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IndexStatus) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroLifetimeBoundAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DLLExportStaticLocalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArrayTypeTrait) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelGenericLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCPropertyQueryKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXPseudoDestructorExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::IncludePathLocation) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AtomicScopeModelKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCStringFormatFamily) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroDisableLifetimeBoundAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PathKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelForSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::DLLExportAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXParenListInitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubstitutionContext) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::FileType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CountedByAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AutoTypeKeyword) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ObjCTypeParamVariance) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConvergentAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CompilerName) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPTargetParallelForDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroWrapperAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXNullPtrLiteralExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AvailabilityResult) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OnOffSwitch) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TargetLanguage) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OnStackType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConsumableSetOnReadAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroReturnTypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AcquireCapabilityAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPAdjustArgsOpKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BinaryOperatorKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroOnlyDestroyWhenCompleteAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPAtClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroLifetimeBoundAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXNoexceptExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Bits) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPAtomicDefaultMemOrderClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAutoCastAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPBindClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CoroDisableLifetimeBoundAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMasterTaskLoopSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDefaultmapClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXConstructExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXConstructionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConvergentAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMaskedTaskLoopSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDefaultmapClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXInheritedCtorInitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConsumableSetOnReadAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXNewInitializationStyle) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstructorAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDependClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelMaskedTaskLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDeviceClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAutoCastAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallingConv) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXFoldExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDeviceType) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConsumableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CanThrowResult) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstInitAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDistScheduleClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelGenericLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXDependentScopeMemberExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CapturedRegionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstructorAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPDoacrossClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelForSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXDeleteExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(gap::generator>) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CastKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPGrainsizeClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstInitAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CommonAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPParallelForDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPLastprivateModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXDefaultInitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ConstAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CharacterLiteralKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPLinearClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ClangABI) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ColdAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CommonAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPMapClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPMapModifierKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPMasterTaskLoopSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ColdAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXDefaultArgExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CommentKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CodeSegAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPMotionModifierKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPMasterTaskLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXTemporaryObjectExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CodeSegAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ComparisonCategoryResult) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPNumTasksClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; template MX_EXPORT SharedPyObject *to_python(mx::CodeModelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPMaskedTaskLoopSimdDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPOrderClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXBoolLiteralExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ComparisonCategoryType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPOrderClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CompilingModuleKind) noexcept; template MX_EXPORT SharedPyObject *to_python(mx::CmseNSEntryAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPReductionClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CleanupAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPMaskedTaskLoopDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXBindTemporaryExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ComplexRangeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPScheduleClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CleanupAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CapturedRecordAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPInteropDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BlockExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPScheduleClauseModifier) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstantResultStorageKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OpenMPSeverityClauseKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CapabilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CapturedRecordAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPFlushDirective) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OverloadedOperatorKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConstexprSpecKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BlockDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallbackAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoreFoundationABI) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::OverloadsShown) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CapabilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OMPCanonicalLoop) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BinaryOperator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Reference) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CallableWhenAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParameterABI) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DataPositionTy) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ParenLocsOffsets) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CXX11NoReturnAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallbackAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclRefExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaFPKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CompoundAssignOperator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeductionCandidate) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDASharedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaFloatControlKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CallableWhenAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDALaunchBoundsAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DefaultArgKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaMSCommentKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; + +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; + +template MX_EXPORT SharedPyObject *to_python(mx::NullStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AtomicExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaMSPointersToMembersKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAInvalidTargetAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DefaultCallingConvention) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXX11NoReturnAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaMSStructKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSDependentExistsStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAHostAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PragmaSectionFlag) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AsTypeExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DefaultVisiblityExportMapping) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAGlobalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDASharedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::PredefinedIdentKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IndirectGotoStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArrayTypeTraitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Qualified) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DesignatorKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinTextureTypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDALaunchBoundsAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LabelDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RangeExprOffset) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArraySubscriptExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinSurfaceTypeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DiagnosticLevelMask) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RangeLocOffset) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ElaboratedTypeKeyword) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAInvalidTargetAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LabelStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RecordArgPassingKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArrayInitLoopExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::RefQualifierKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::EscapeChar) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAHostAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CUDAConstantAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXTryStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArrayInitIndexExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReservedIdentifierStatus) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExceptionHandlingKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CPUSpecificAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ReservedLiteralSuffixIdStatus) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAGlobalAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IfStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AbstractConditionalOperator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CPUDispatchAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExceptionSpecificationType) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SFINAEResponse) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExcessPrecisionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinTextureTypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DeclStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConditionalOperator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SYCLMajorVersion) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExplicitSpecKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFUnknownTransferAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceBuiltinSurfaceTypeAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GotoStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SanitizerOrdinal) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BinaryConditionalOperator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsRetainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprDependence) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SelectorLocationsKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDADeviceAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ForStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprObjectKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::VAArgExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsNotRetainedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprOffsets) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ShaderStage) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CUDAConstantAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DoStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SignReturnAddressKeyKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFICanonicalJumpTableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnaryOperator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SignReturnAddressScopeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExprValueKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFGuardAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SignedOverflowBehaviorTy) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CPUSpecificAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroutineBodyStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CFAuditedTransferAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnaryExprOrTypeTraitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SourceLocIdentKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExpressionTrait) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SpecialMemberFlags) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CPUDispatchAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::CDeclAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoreturnStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExtKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypoExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SpecifierKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ExtendArgsKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::C11NoReturnAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFUnknownTransferAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ContinueStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::TypeTraitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StackProtectorMode) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BuiltinAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FPEvalMethodKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StorageClass) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsRetainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXCatchStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SubstNonTypeTemplateParmPackExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StorageDuration) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FPExceptionModeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BlocksAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFReturnsNotRetainedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StoredNameKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::FPModeKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BTFDeclTagAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CXXForRangeStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::NonTypeTemplateParmDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StoredSpecifierKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Flags) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveStaticOffsetAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFICanonicalJumpTableAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BreakStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StrictFlexArraysLevelKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SubstNonTypeTemplateParmExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::StringLiteralKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GC) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveAccessIndexAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFGuardAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SubExpr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AsmStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StmtExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AvailableOnlyInDefaultEvalMethodAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AVRInterruptAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GCMode) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SubStmt) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CFAuditedTransferAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::MSAsmStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AvailabilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GPUDefaultStreamKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::SyncScope) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SourceLocExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Syntax) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GVALinkage) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssumptionAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CDeclAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GCCAsmStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SizeOfPackExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TQ) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::GetBuiltinTypeError) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::C11NoReturnAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssumeAlignedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::StringLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TagTypeKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ShuffleVectorExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::HLSLLangStd) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AVRInterruptAttrSpelling) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BuiltinAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssertSharedLockAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AddrLabelExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TailPaddingUseRules) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::SYCLUniqueStableNameExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ID) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IdentifierInfoFlag) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateArgumentDependence) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BlocksAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssertExclusiveLockAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::WhileStmt) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RequiresExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateNameDependence) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AssertCapabilityAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::IfStatementKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TemplateSpecializationKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BTFDeclTagAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DesignatedInitUpdateExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AsmLabelAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RequiresExprBodyDecl) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TextDiagnosticFormat) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ThreadModelKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArtificialAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ImplicitParamKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ThreadStorageClassSpecifier) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveStaticOffsetAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InitListExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmNewAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InClassInitStyle) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::RecoveryExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TrailingAllocKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InheritedDesignatedInitializersState) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmLocallyStreamingAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::BPFPreserveAccessIndexAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TranslationUnitKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DesignatedInitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TrivialAutoVarInitKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PseudoObjectExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArmBuiltinAliasAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InitStorageKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AvailableOnlyInDefaultEvalMethodAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentScopeDeclRefExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeDependence) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PredefinedExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArgumentWithTypeTagAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InlineVariableDefinitionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AvailabilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeLocClass) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::DependentCoawaitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParenListExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::InterestingIdentifierKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::ArcWeakrefUnavailableAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeOfKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Kinds) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssumptionAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifierSign) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCfCheckAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedLookupExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifierType) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ParenExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LambdaCaptureDefault) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnyX86NoCallerSavedRegistersAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssumeAlignedAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::PackExpansionExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifierWidth) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnyX86InterruptAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OverloadExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LambdaCaptureKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeSpecifiersPipe) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; template MX_EXPORT SharedPyObject *to_python(mx::ARMInterruptAttrSpelling) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssertSharedLockAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::TypeTrait) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AnalyzerNoReturnAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LangAS) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoroutineSuspendExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::UnresolvedMemberExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnaryExprOrTypeTrait) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlwaysDestroyAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LangFeatures) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssertExclusiveLockAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::UnaryOperatorKind) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OpaqueValueExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AllocSizeAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::OffsetOfExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::APValueKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Language) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AssertCapabilityAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VectorKind) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AllocAlignAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoawaitExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCSubscriptRefExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>>(std::optional>) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::Visibility) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LanguageLinkage) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlignedAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Compilation) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VisibilityForcedKinds) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::AsmLabelAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlignNaturalAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::CoyieldExpr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ObjCStringLiteral) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::LaxVectorConversionKind) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::VisibilityFromDLLStorageClassKinds) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AttributeSyntax) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::Level) noexcept; -template MX_EXPORT SharedPyObject *to_python(mx::AlignMac68kAttr) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ArtificialAttr) noexcept; -template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; -template MX_EXPORT SharedPyObject *to_python>(std::optional) noexcept; +template MX_EXPORT SharedPyObject *to_python(mx::ConvertVectorExpr) noexcept; + +template MX_EXPORT SharedPyObject *to_python(mx::ObjCSelectorExpr) noexcept; + +template MX_EXPORT SharedPyObject *to_python>(gap::generator) noexcept; } // namespace mx diff --git a/bindings/Python/Generated/Fragment.cpp b/bindings/Python/Generated/Fragment.cpp index 5b3240056..f0d8f09ab 100644 --- a/bindings/Python/Generated/Fragment.cpp +++ b/bindings/Python/Generated/Fragment.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[830]) || tp >= &(gTypes[831])) { + if (tp < &(gTypes[834]) || tp >= &(gTypes[835])) { return std::nullopt; } @@ -316,7 +316,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::containing(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -337,7 +337,7 @@ static PyMethodDef gMethods[] = { +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { (void) args; while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -419,7 +419,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[830]); + PyTypeObject * const tp = &(gTypes[834]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp index 9745ec762..2c0e5bc9e 100644 --- a/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp +++ b/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[864]) || tp >= &(gTypes[865])) { + if (tp < &(gTypes[868]) || tp >= &(gTypes[869])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ChoiceTokenTreeNode::static_kind(): - tp = &(gTypes[864]); + tp = &(gTypes[868]); break; } @@ -183,7 +183,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[864]); + PyTypeObject * const tp = &(gTypes[868]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -198,12 +198,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[861].tp_hash; - tp->tp_richcompare = gTypes[861].tp_richcompare; + tp->tp_hash = gTypes[865].tp_hash; + tp->tp_richcompare = gTypes[865].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[861]); + tp->tp_base = &(gTypes[865]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/Compilation.cpp b/bindings/Python/Generated/Frontend/Compilation.cpp index d0237948d..b5a4d4c18 100644 --- a/bindings/Python/Generated/Frontend/Compilation.cpp +++ b/bindings/Python/Generated/Frontend/Compilation.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[823]) || tp >= &(gTypes[824])) { + if (tp < &(gTypes[827]) || tp >= &(gTypes[828])) { return std::nullopt; } @@ -428,7 +428,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::containing(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -471,7 +471,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[823]); + PyTypeObject * const tp = &(gTypes[827]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp b/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp index c417caa5e..661696b5f 100644 --- a/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[846]) || tp >= &(gTypes[855])) { + if (tp < &(gTypes[850]) || tp >= &(gTypes[859])) { return std::nullopt; } @@ -88,35 +88,35 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EndIfMacroDirective::static_kind(): - tp = &(gTypes[847]); + tp = &(gTypes[851]); break; case mx::ElseMacroDirective::static_kind(): - tp = &(gTypes[848]); + tp = &(gTypes[852]); break; case mx::ElseIfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[849]); + tp = &(gTypes[853]); break; case mx::ElseIfDefinedMacroDirective::static_kind(): - tp = &(gTypes[850]); + tp = &(gTypes[854]); break; case mx::ElseIfMacroDirective::static_kind(): - tp = &(gTypes[851]); + tp = &(gTypes[855]); break; case mx::IfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[852]); + tp = &(gTypes[856]); break; case mx::IfDefinedMacroDirective::static_kind(): - tp = &(gTypes[853]); + tp = &(gTypes[857]); break; case mx::IfMacroDirective::static_kind(): - tp = &(gTypes[854]); + tp = &(gTypes[858]); break; } @@ -298,7 +298,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -328,7 +328,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[846]); + PyTypeObject * const tp = &(gTypes[850]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -343,12 +343,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[841].tp_hash; - tp->tp_richcompare = gTypes[841].tp_richcompare; + tp->tp_hash = gTypes[845].tp_hash; + tp->tp_richcompare = gTypes[845].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[841]); + tp->tp_base = &(gTypes[845]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp b/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp index c6a5d6665..66e38502c 100644 --- a/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[842]) || tp >= &(gTypes[843])) { + if (tp < &(gTypes[846]) || tp >= &(gTypes[847])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DefineMacroDirective::static_kind(): - tp = &(gTypes[842]); + tp = &(gTypes[846]); break; } @@ -357,7 +357,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -387,7 +387,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[842]); + PyTypeObject * const tp = &(gTypes[846]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -402,12 +402,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[841].tp_hash; - tp->tp_richcompare = gTypes[841].tp_richcompare; + tp->tp_hash = gTypes[845].tp_hash; + tp->tp_richcompare = gTypes[845].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[841]); + tp->tp_base = &(gTypes[845]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp index 87292d4f2..cd8d1e32a 100644 --- a/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[850]) || tp >= &(gTypes[851])) { + if (tp < &(gTypes[854]) || tp >= &(gTypes[855])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ElseIfDefinedMacroDirective::static_kind(): - tp = &(gTypes[850]); + tp = &(gTypes[854]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[850]); + PyTypeObject * const tp = &(gTypes[854]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp index 29e8e408d..0cc3c98a8 100644 --- a/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[851]) || tp >= &(gTypes[852])) { + if (tp < &(gTypes[855]) || tp >= &(gTypes[856])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ElseIfMacroDirective::static_kind(): - tp = &(gTypes[851]); + tp = &(gTypes[855]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[851]); + PyTypeObject * const tp = &(gTypes[855]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp index 37da5a1e6..d93073a8f 100644 --- a/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[849]) || tp >= &(gTypes[850])) { + if (tp < &(gTypes[853]) || tp >= &(gTypes[854])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ElseIfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[849]); + tp = &(gTypes[853]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[849]); + PyTypeObject * const tp = &(gTypes[853]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp index 9f0b264e8..63348be94 100644 --- a/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[848]) || tp >= &(gTypes[849])) { + if (tp < &(gTypes[852]) || tp >= &(gTypes[853])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ElseMacroDirective::static_kind(): - tp = &(gTypes[848]); + tp = &(gTypes[852]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[848]); + PyTypeObject * const tp = &(gTypes[852]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp index e0b9887ed..cde6ec119 100644 --- a/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp +++ b/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[862]) || tp >= &(gTypes[863])) { + if (tp < &(gTypes[866]) || tp >= &(gTypes[867])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EmptyTokenTreeNode::static_kind(): - tp = &(gTypes[862]); + tp = &(gTypes[866]); break; } @@ -173,7 +173,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[862]); + PyTypeObject * const tp = &(gTypes[866]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -188,12 +188,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[861].tp_hash; - tp->tp_richcompare = gTypes[861].tp_richcompare; + tp->tp_hash = gTypes[865].tp_hash; + tp->tp_richcompare = gTypes[865].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[861]); + tp->tp_base = &(gTypes[865]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp b/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp index 96e0a98ef..352d1884f 100644 --- a/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[847]) || tp >= &(gTypes[848])) { + if (tp < &(gTypes[851]) || tp >= &(gTypes[852])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EndIfMacroDirective::static_kind(): - tp = &(gTypes[847]); + tp = &(gTypes[851]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[847]); + PyTypeObject * const tp = &(gTypes[851]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/File.cpp b/bindings/Python/Generated/Frontend/File.cpp index ec26f8698..69c93cf6b 100644 --- a/bindings/Python/Generated/Frontend/File.cpp +++ b/bindings/Python/Generated/Frontend/File.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[829]) || tp >= &(gTypes[830])) { + if (tp < &(gTypes[833]) || tp >= &(gTypes[834])) { return std::nullopt; } @@ -302,7 +302,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::containing(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -323,7 +323,7 @@ static PyMethodDef gMethods[] = { +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { (void) args; while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -383,7 +383,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[829]); + PyTypeObject * const tp = &(gTypes[833]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp index 6716f07a5..e5fae4276 100644 --- a/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[853]) || tp >= &(gTypes[854])) { + if (tp < &(gTypes[857]) || tp >= &(gTypes[858])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IfDefinedMacroDirective::static_kind(): - tp = &(gTypes[853]); + tp = &(gTypes[857]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[853]); + PyTypeObject * const tp = &(gTypes[857]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/IfMacroDirective.cpp b/bindings/Python/Generated/Frontend/IfMacroDirective.cpp index 7cf648e19..ec576f9f5 100644 --- a/bindings/Python/Generated/Frontend/IfMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/IfMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[854]) || tp >= &(gTypes[855])) { + if (tp < &(gTypes[858]) || tp >= &(gTypes[859])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IfMacroDirective::static_kind(): - tp = &(gTypes[854]); + tp = &(gTypes[858]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[854]); + PyTypeObject * const tp = &(gTypes[858]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp index 86ee7c719..6d2ea36f2 100644 --- a/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[852]) || tp >= &(gTypes[853])) { + if (tp < &(gTypes[856]) || tp >= &(gTypes[857])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[852]); + tp = &(gTypes[856]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[852]); + PyTypeObject * const tp = &(gTypes[856]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[846].tp_hash; - tp->tp_richcompare = gTypes[846].tp_richcompare; + tp->tp_hash = gTypes[850].tp_hash; + tp->tp_richcompare = gTypes[850].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[846]); + tp->tp_base = &(gTypes[850]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp b/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp index 9489a12a9..ecab1dece 100644 --- a/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[856]) || tp >= &(gTypes[857])) { + if (tp < &(gTypes[860]) || tp >= &(gTypes[861])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImportMacroDirective::static_kind(): - tp = &(gTypes[856]); + tp = &(gTypes[860]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[856]); + PyTypeObject * const tp = &(gTypes[860]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[855].tp_hash; - tp->tp_richcompare = gTypes[855].tp_richcompare; + tp->tp_hash = gTypes[859].tp_hash; + tp->tp_richcompare = gTypes[859].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[855]); + tp->tp_base = &(gTypes[859]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp index 7141f9d26..30bc529a2 100644 --- a/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[855]) || tp >= &(gTypes[860])) { + if (tp < &(gTypes[859]) || tp >= &(gTypes[864])) { return std::nullopt; } @@ -88,19 +88,19 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::ImportMacroDirective::static_kind(): - tp = &(gTypes[856]); + tp = &(gTypes[860]); break; case mx::IncludeMacrosMacroDirective::static_kind(): - tp = &(gTypes[857]); + tp = &(gTypes[861]); break; case mx::IncludeNextMacroDirective::static_kind(): - tp = &(gTypes[858]); + tp = &(gTypes[862]); break; case mx::IncludeMacroDirective::static_kind(): - tp = &(gTypes[859]); + tp = &(gTypes[863]); break; } @@ -292,7 +292,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -322,7 +322,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[855]); + PyTypeObject * const tp = &(gTypes[859]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -337,12 +337,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[841].tp_hash; - tp->tp_richcompare = gTypes[841].tp_richcompare; + tp->tp_hash = gTypes[845].tp_hash; + tp->tp_richcompare = gTypes[845].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[841]); + tp->tp_base = &(gTypes[845]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp index e58ffc7f8..b70561682 100644 --- a/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[859]) || tp >= &(gTypes[860])) { + if (tp < &(gTypes[863]) || tp >= &(gTypes[864])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IncludeMacroDirective::static_kind(): - tp = &(gTypes[859]); + tp = &(gTypes[863]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[859]); + PyTypeObject * const tp = &(gTypes[863]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[855].tp_hash; - tp->tp_richcompare = gTypes[855].tp_richcompare; + tp->tp_hash = gTypes[859].tp_hash; + tp->tp_richcompare = gTypes[859].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[855]); + tp->tp_base = &(gTypes[859]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp index 7a26deb67..1df4b2d34 100644 --- a/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[857]) || tp >= &(gTypes[858])) { + if (tp < &(gTypes[861]) || tp >= &(gTypes[862])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IncludeMacrosMacroDirective::static_kind(): - tp = &(gTypes[857]); + tp = &(gTypes[861]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[857]); + PyTypeObject * const tp = &(gTypes[861]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[855].tp_hash; - tp->tp_richcompare = gTypes[855].tp_richcompare; + tp->tp_hash = gTypes[859].tp_hash; + tp->tp_richcompare = gTypes[859].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[855]); + tp->tp_base = &(gTypes[859]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp index 6bcd17fc5..c42afa069 100644 --- a/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[858]) || tp >= &(gTypes[859])) { + if (tp < &(gTypes[862]) || tp >= &(gTypes[863])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::IncludeNextMacroDirective::static_kind(): - tp = &(gTypes[858]); + tp = &(gTypes[862]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[858]); + PyTypeObject * const tp = &(gTypes[862]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[855].tp_hash; - tp->tp_richcompare = gTypes[855].tp_richcompare; + tp->tp_hash = gTypes[859].tp_hash; + tp->tp_richcompare = gTypes[859].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[855]); + tp->tp_base = &(gTypes[859]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/Macro.cpp b/bindings/Python/Generated/Frontend/Macro.cpp index 92a2f23fb..aaf2f979e 100644 --- a/bindings/Python/Generated/Frontend/Macro.cpp +++ b/bindings/Python/Generated/Frontend/Macro.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[831]) || tp >= &(gTypes[860])) { + if (tp < &(gTypes[835]) || tp >= &(gTypes[864])) { return std::nullopt; } @@ -88,103 +88,103 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroSubstitution::static_kind(): - tp = &(gTypes[832]); + tp = &(gTypes[836]); break; case mx::MacroConcatenate::static_kind(): - tp = &(gTypes[833]); + tp = &(gTypes[837]); break; case mx::MacroStringify::static_kind(): - tp = &(gTypes[834]); + tp = &(gTypes[838]); break; case mx::MacroExpansion::static_kind(): - tp = &(gTypes[835]); + tp = &(gTypes[839]); break; case mx::MacroParameterSubstitution::static_kind(): - tp = &(gTypes[836]); + tp = &(gTypes[840]); break; case mx::MacroVAOpt::static_kind(): - tp = &(gTypes[837]); + tp = &(gTypes[841]); break; case mx::MacroVAOptArgument::static_kind(): - tp = &(gTypes[838]); + tp = &(gTypes[842]); break; case mx::MacroArgument::static_kind(): - tp = &(gTypes[839]); + tp = &(gTypes[843]); break; case mx::MacroParameter::static_kind(): - tp = &(gTypes[840]); + tp = &(gTypes[844]); break; case mx::DefineMacroDirective::static_kind(): - tp = &(gTypes[842]); + tp = &(gTypes[846]); break; case mx::PragmaMacroDirective::static_kind(): - tp = &(gTypes[843]); + tp = &(gTypes[847]); break; case mx::UndefineMacroDirective::static_kind(): - tp = &(gTypes[844]); + tp = &(gTypes[848]); break; case mx::OtherMacroDirective::static_kind(): - tp = &(gTypes[845]); + tp = &(gTypes[849]); break; case mx::EndIfMacroDirective::static_kind(): - tp = &(gTypes[847]); + tp = &(gTypes[851]); break; case mx::ElseMacroDirective::static_kind(): - tp = &(gTypes[848]); + tp = &(gTypes[852]); break; case mx::ElseIfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[849]); + tp = &(gTypes[853]); break; case mx::ElseIfDefinedMacroDirective::static_kind(): - tp = &(gTypes[850]); + tp = &(gTypes[854]); break; case mx::ElseIfMacroDirective::static_kind(): - tp = &(gTypes[851]); + tp = &(gTypes[855]); break; case mx::IfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[852]); + tp = &(gTypes[856]); break; case mx::IfDefinedMacroDirective::static_kind(): - tp = &(gTypes[853]); + tp = &(gTypes[857]); break; case mx::IfMacroDirective::static_kind(): - tp = &(gTypes[854]); + tp = &(gTypes[858]); break; case mx::ImportMacroDirective::static_kind(): - tp = &(gTypes[856]); + tp = &(gTypes[860]); break; case mx::IncludeMacrosMacroDirective::static_kind(): - tp = &(gTypes[857]); + tp = &(gTypes[861]); break; case mx::IncludeNextMacroDirective::static_kind(): - tp = &(gTypes[858]); + tp = &(gTypes[862]); break; case mx::IncludeMacroDirective::static_kind(): - tp = &(gTypes[859]); + tp = &(gTypes[863]); break; } @@ -488,7 +488,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -518,7 +518,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[831]); + PyTypeObject * const tp = &(gTypes[835]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/MacroArgument.cpp b/bindings/Python/Generated/Frontend/MacroArgument.cpp index 8a942eea6..e69a54ba6 100644 --- a/bindings/Python/Generated/Frontend/MacroArgument.cpp +++ b/bindings/Python/Generated/Frontend/MacroArgument.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[839]) || tp >= &(gTypes[840])) { + if (tp < &(gTypes[843]) || tp >= &(gTypes[844])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroArgument::static_kind(): - tp = &(gTypes[839]); + tp = &(gTypes[843]); break; } @@ -307,7 +307,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -337,7 +337,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[839]); + PyTypeObject * const tp = &(gTypes[843]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -352,12 +352,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[831].tp_hash; - tp->tp_richcompare = gTypes[831].tp_richcompare; + tp->tp_hash = gTypes[835].tp_hash; + tp->tp_richcompare = gTypes[835].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[831]); + tp->tp_base = &(gTypes[835]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroConcatenate.cpp b/bindings/Python/Generated/Frontend/MacroConcatenate.cpp index c5df1e553..251285f89 100644 --- a/bindings/Python/Generated/Frontend/MacroConcatenate.cpp +++ b/bindings/Python/Generated/Frontend/MacroConcatenate.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[833]) || tp >= &(gTypes[834])) { + if (tp < &(gTypes[837]) || tp >= &(gTypes[838])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroConcatenate::static_kind(): - tp = &(gTypes[833]); + tp = &(gTypes[837]); break; } @@ -297,7 +297,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -327,7 +327,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[833]); + PyTypeObject * const tp = &(gTypes[837]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -342,12 +342,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[832].tp_hash; - tp->tp_richcompare = gTypes[832].tp_richcompare; + tp->tp_hash = gTypes[836].tp_hash; + tp->tp_richcompare = gTypes[836].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[832]); + tp->tp_base = &(gTypes[836]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroDirective.cpp b/bindings/Python/Generated/Frontend/MacroDirective.cpp index b093446e8..66fbc1d4c 100644 --- a/bindings/Python/Generated/Frontend/MacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/MacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[841]) || tp >= &(gTypes[860])) { + if (tp < &(gTypes[845]) || tp >= &(gTypes[864])) { return std::nullopt; } @@ -88,67 +88,67 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::DefineMacroDirective::static_kind(): - tp = &(gTypes[842]); + tp = &(gTypes[846]); break; case mx::PragmaMacroDirective::static_kind(): - tp = &(gTypes[843]); + tp = &(gTypes[847]); break; case mx::UndefineMacroDirective::static_kind(): - tp = &(gTypes[844]); + tp = &(gTypes[848]); break; case mx::OtherMacroDirective::static_kind(): - tp = &(gTypes[845]); + tp = &(gTypes[849]); break; case mx::EndIfMacroDirective::static_kind(): - tp = &(gTypes[847]); + tp = &(gTypes[851]); break; case mx::ElseMacroDirective::static_kind(): - tp = &(gTypes[848]); + tp = &(gTypes[852]); break; case mx::ElseIfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[849]); + tp = &(gTypes[853]); break; case mx::ElseIfDefinedMacroDirective::static_kind(): - tp = &(gTypes[850]); + tp = &(gTypes[854]); break; case mx::ElseIfMacroDirective::static_kind(): - tp = &(gTypes[851]); + tp = &(gTypes[855]); break; case mx::IfNotDefinedMacroDirective::static_kind(): - tp = &(gTypes[852]); + tp = &(gTypes[856]); break; case mx::IfDefinedMacroDirective::static_kind(): - tp = &(gTypes[853]); + tp = &(gTypes[857]); break; case mx::IfMacroDirective::static_kind(): - tp = &(gTypes[854]); + tp = &(gTypes[858]); break; case mx::ImportMacroDirective::static_kind(): - tp = &(gTypes[856]); + tp = &(gTypes[860]); break; case mx::IncludeMacrosMacroDirective::static_kind(): - tp = &(gTypes[857]); + tp = &(gTypes[861]); break; case mx::IncludeNextMacroDirective::static_kind(): - tp = &(gTypes[858]); + tp = &(gTypes[862]); break; case mx::IncludeMacroDirective::static_kind(): - tp = &(gTypes[859]); + tp = &(gTypes[863]); break; } @@ -350,7 +350,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -380,7 +380,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[841]); + PyTypeObject * const tp = &(gTypes[845]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -395,12 +395,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[831].tp_hash; - tp->tp_richcompare = gTypes[831].tp_richcompare; + tp->tp_hash = gTypes[835].tp_hash; + tp->tp_richcompare = gTypes[835].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[831]); + tp->tp_base = &(gTypes[835]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroExpansion.cpp b/bindings/Python/Generated/Frontend/MacroExpansion.cpp index 6d677fb8f..4405712ce 100644 --- a/bindings/Python/Generated/Frontend/MacroExpansion.cpp +++ b/bindings/Python/Generated/Frontend/MacroExpansion.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[835]) || tp >= &(gTypes[836])) { + if (tp < &(gTypes[839]) || tp >= &(gTypes[840])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroExpansion::static_kind(): - tp = &(gTypes[835]); + tp = &(gTypes[839]); break; } @@ -327,7 +327,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -379,7 +379,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[835]); + PyTypeObject * const tp = &(gTypes[839]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -394,12 +394,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[832].tp_hash; - tp->tp_richcompare = gTypes[832].tp_richcompare; + tp->tp_hash = gTypes[836].tp_hash; + tp->tp_richcompare = gTypes[836].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[832]); + tp->tp_base = &(gTypes[836]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroParameter.cpp b/bindings/Python/Generated/Frontend/MacroParameter.cpp index 9a6ce867e..ee64c4ca1 100644 --- a/bindings/Python/Generated/Frontend/MacroParameter.cpp +++ b/bindings/Python/Generated/Frontend/MacroParameter.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[840]) || tp >= &(gTypes[841])) { + if (tp < &(gTypes[844]) || tp >= &(gTypes[845])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroParameter::static_kind(): - tp = &(gTypes[840]); + tp = &(gTypes[844]); break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -347,7 +347,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[840]); + PyTypeObject * const tp = &(gTypes[844]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -362,12 +362,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[831].tp_hash; - tp->tp_richcompare = gTypes[831].tp_richcompare; + tp->tp_hash = gTypes[835].tp_hash; + tp->tp_richcompare = gTypes[835].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[831]); + tp->tp_base = &(gTypes[835]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp b/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp index 36acb7397..37e6ab97c 100644 --- a/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp +++ b/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[836]) || tp >= &(gTypes[837])) { + if (tp < &(gTypes[840]) || tp >= &(gTypes[841])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroParameterSubstitution::static_kind(): - tp = &(gTypes[836]); + tp = &(gTypes[840]); break; } @@ -307,7 +307,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -337,7 +337,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[836]); + PyTypeObject * const tp = &(gTypes[840]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -352,12 +352,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[832].tp_hash; - tp->tp_richcompare = gTypes[832].tp_richcompare; + tp->tp_hash = gTypes[836].tp_hash; + tp->tp_richcompare = gTypes[836].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[832]); + tp->tp_base = &(gTypes[836]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroStringify.cpp b/bindings/Python/Generated/Frontend/MacroStringify.cpp index 799d9989d..b908f1884 100644 --- a/bindings/Python/Generated/Frontend/MacroStringify.cpp +++ b/bindings/Python/Generated/Frontend/MacroStringify.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[834]) || tp >= &(gTypes[835])) { + if (tp < &(gTypes[838]) || tp >= &(gTypes[839])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroStringify::static_kind(): - tp = &(gTypes[834]); + tp = &(gTypes[838]); break; } @@ -297,7 +297,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -327,7 +327,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[834]); + PyTypeObject * const tp = &(gTypes[838]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -342,12 +342,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[832].tp_hash; - tp->tp_richcompare = gTypes[832].tp_richcompare; + tp->tp_hash = gTypes[836].tp_hash; + tp->tp_richcompare = gTypes[836].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[832]); + tp->tp_base = &(gTypes[836]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroSubstitution.cpp b/bindings/Python/Generated/Frontend/MacroSubstitution.cpp index 227bcc50a..629fd2326 100644 --- a/bindings/Python/Generated/Frontend/MacroSubstitution.cpp +++ b/bindings/Python/Generated/Frontend/MacroSubstitution.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[832]) || tp >= &(gTypes[837])) { + if (tp < &(gTypes[836]) || tp >= &(gTypes[841])) { return std::nullopt; } @@ -88,23 +88,23 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroSubstitution::static_kind(): - tp = &(gTypes[832]); + tp = &(gTypes[836]); break; case mx::MacroConcatenate::static_kind(): - tp = &(gTypes[833]); + tp = &(gTypes[837]); break; case mx::MacroStringify::static_kind(): - tp = &(gTypes[834]); + tp = &(gTypes[838]); break; case mx::MacroExpansion::static_kind(): - tp = &(gTypes[835]); + tp = &(gTypes[839]); break; case mx::MacroParameterSubstitution::static_kind(): - tp = &(gTypes[836]); + tp = &(gTypes[840]); break; } @@ -353,7 +353,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -383,7 +383,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[832]); + PyTypeObject * const tp = &(gTypes[836]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -398,12 +398,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[831].tp_hash; - tp->tp_richcompare = gTypes[831].tp_richcompare; + tp->tp_hash = gTypes[835].tp_hash; + tp->tp_richcompare = gTypes[835].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[831]); + tp->tp_base = &(gTypes[835]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroVAOpt.cpp b/bindings/Python/Generated/Frontend/MacroVAOpt.cpp index 64a3e0e2b..af25369fa 100644 --- a/bindings/Python/Generated/Frontend/MacroVAOpt.cpp +++ b/bindings/Python/Generated/Frontend/MacroVAOpt.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[837]) || tp >= &(gTypes[838])) { + if (tp < &(gTypes[841]) || tp >= &(gTypes[842])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroVAOpt::static_kind(): - tp = &(gTypes[837]); + tp = &(gTypes[841]); break; } @@ -297,7 +297,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -327,7 +327,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[837]); + PyTypeObject * const tp = &(gTypes[841]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -342,12 +342,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[831].tp_hash; - tp->tp_richcompare = gTypes[831].tp_richcompare; + tp->tp_hash = gTypes[835].tp_hash; + tp->tp_richcompare = gTypes[835].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[831]); + tp->tp_base = &(gTypes[835]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp b/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp index 1e6d7b2aa..ce20d7d78 100644 --- a/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp +++ b/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[838]) || tp >= &(gTypes[839])) { + if (tp < &(gTypes[842]) || tp >= &(gTypes[843])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::MacroVAOptArgument::static_kind(): - tp = &(gTypes[838]); + tp = &(gTypes[842]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[838]); + PyTypeObject * const tp = &(gTypes[842]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[831].tp_hash; - tp->tp_richcompare = gTypes[831].tp_richcompare; + tp->tp_hash = gTypes[835].tp_hash; + tp->tp_richcompare = gTypes[835].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[831]); + tp->tp_base = &(gTypes[835]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp b/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp index bd5c5819d..6054a6b4b 100644 --- a/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[845]) || tp >= &(gTypes[846])) { + if (tp < &(gTypes[849]) || tp >= &(gTypes[850])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::OtherMacroDirective::static_kind(): - tp = &(gTypes[845]); + tp = &(gTypes[849]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[845]); + PyTypeObject * const tp = &(gTypes[849]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[841].tp_hash; - tp->tp_richcompare = gTypes[841].tp_richcompare; + tp->tp_hash = gTypes[845].tp_hash; + tp->tp_richcompare = gTypes[845].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[841]); + tp->tp_base = &(gTypes[845]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp b/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp index 2b501e256..845df6f79 100644 --- a/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[843]) || tp >= &(gTypes[844])) { + if (tp < &(gTypes[847]) || tp >= &(gTypes[848])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::PragmaMacroDirective::static_kind(): - tp = &(gTypes[843]); + tp = &(gTypes[847]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[843]); + PyTypeObject * const tp = &(gTypes[847]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[841].tp_hash; - tp->tp_richcompare = gTypes[841].tp_richcompare; + tp->tp_hash = gTypes[845].tp_hash; + tp->tp_richcompare = gTypes[845].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[841]); + tp->tp_base = &(gTypes[845]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp b/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp index cd69a50af..0ec18311a 100644 --- a/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp +++ b/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[828]) || tp >= &(gTypes[829])) { + if (tp < &(gTypes[832]) || tp >= &(gTypes[833])) { return std::nullopt; } @@ -235,7 +235,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[828]); + PyTypeObject * const tp = &(gTypes[832]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -250,12 +250,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[827].tp_hash; - tp->tp_richcompare = gTypes[827].tp_richcompare; + tp->tp_hash = gTypes[831].tp_hash; + tp->tp_richcompare = gTypes[831].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[827]); + tp->tp_base = &(gTypes[831]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp index 5814eb398..5928e1faa 100644 --- a/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp +++ b/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[866]) || tp >= &(gTypes[867])) { + if (tp < &(gTypes[870]) || tp >= &(gTypes[871])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SequenceTokenTreeNode::static_kind(): - tp = &(gTypes[866]); + tp = &(gTypes[870]); break; } @@ -183,7 +183,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[866]); + PyTypeObject * const tp = &(gTypes[870]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -198,12 +198,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[861].tp_hash; - tp->tp_richcompare = gTypes[861].tp_richcompare; + tp->tp_hash = gTypes[865].tp_hash; + tp->tp_richcompare = gTypes[865].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[861]); + tp->tp_base = &(gTypes[865]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp index 16b5aba55..4bc70886c 100644 --- a/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp +++ b/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[865]) || tp >= &(gTypes[866])) { + if (tp < &(gTypes[869]) || tp >= &(gTypes[870])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::SubstitutionTokenTreeNode::static_kind(): - tp = &(gTypes[865]); + tp = &(gTypes[869]); break; } @@ -203,7 +203,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[865]); + PyTypeObject * const tp = &(gTypes[869]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -218,12 +218,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[861].tp_hash; - tp->tp_richcompare = gTypes[861].tp_richcompare; + tp->tp_hash = gTypes[865].tp_hash; + tp->tp_richcompare = gTypes[865].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[861]); + tp->tp_base = &(gTypes[865]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/Token.cpp b/bindings/Python/Generated/Frontend/Token.cpp index 7827f8efe..9e1f5cb4e 100644 --- a/bindings/Python/Generated/Frontend/Token.cpp +++ b/bindings/Python/Generated/Frontend/Token.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[826]) || tp >= &(gTypes[827])) { + if (tp < &(gTypes[830]) || tp >= &(gTypes[831])) { return std::nullopt; } @@ -242,7 +242,7 @@ static PyMethodDef gMethods[] = { +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { (void) args; while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -280,7 +280,7 @@ static PyMethodDef gMethods[] = { +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { (void) args; while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -378,7 +378,7 @@ static PyNumberMethods gNumberMethods = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[826]); + PyTypeObject * const tp = &(gTypes[830]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/TokenContext.cpp b/bindings/Python/Generated/Frontend/TokenContext.cpp index 7a6a72b2f..37d629bdd 100644 --- a/bindings/Python/Generated/Frontend/TokenContext.cpp +++ b/bindings/Python/Generated/Frontend/TokenContext.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[0]) || tp >= &(gTypes[1])) { + if (tp < &(gTypes[4]) || tp >= &(gTypes[5])) { return std::nullopt; } @@ -273,7 +273,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[0]); + PyTypeObject * const tp = &(gTypes[4]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/TokenRange.cpp b/bindings/Python/Generated/Frontend/TokenRange.cpp index 0d723a281..658ff9470 100644 --- a/bindings/Python/Generated/Frontend/TokenRange.cpp +++ b/bindings/Python/Generated/Frontend/TokenRange.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[827]) || tp >= &(gTypes[829])) { + if (tp < &(gTypes[831]) || tp >= &(gTypes[833])) { return std::nullopt; } @@ -343,7 +343,7 @@ static PySequenceMethods gSequenceMethods = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[827]); + PyTypeObject * const tp = &(gTypes[831]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp index bcf2f4aef..d8f98bb11 100644 --- a/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp +++ b/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[863]) || tp >= &(gTypes[864])) { + if (tp < &(gTypes[867]) || tp >= &(gTypes[868])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::TokenTokenTreeNode::static_kind(): - tp = &(gTypes[863]); + tp = &(gTypes[867]); break; } @@ -183,7 +183,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[863]); + PyTypeObject * const tp = &(gTypes[867]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -198,12 +198,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[861].tp_hash; - tp->tp_richcompare = gTypes[861].tp_richcompare; + tp->tp_hash = gTypes[865].tp_hash; + tp->tp_richcompare = gTypes[865].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[861]); + tp->tp_base = &(gTypes[865]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/Frontend/TokenTree.cpp b/bindings/Python/Generated/Frontend/TokenTree.cpp index f843cc667..28cb3b3f7 100644 --- a/bindings/Python/Generated/Frontend/TokenTree.cpp +++ b/bindings/Python/Generated/Frontend/TokenTree.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[860]) || tp >= &(gTypes[861])) { + if (tp < &(gTypes[864]) || tp >= &(gTypes[865])) { return std::nullopt; } @@ -210,7 +210,7 @@ static PyNumberMethods gNumberMethods = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[860]); + PyTypeObject * const tp = &(gTypes[864]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/TokenTreeNode.cpp b/bindings/Python/Generated/Frontend/TokenTreeNode.cpp index 82372d06d..b0b4191ae 100644 --- a/bindings/Python/Generated/Frontend/TokenTreeNode.cpp +++ b/bindings/Python/Generated/Frontend/TokenTreeNode.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[861]) || tp >= &(gTypes[867])) { + if (tp < &(gTypes[865]) || tp >= &(gTypes[871])) { return std::nullopt; } @@ -88,23 +88,23 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::EmptyTokenTreeNode::static_kind(): - tp = &(gTypes[862]); + tp = &(gTypes[866]); break; case mx::TokenTokenTreeNode::static_kind(): - tp = &(gTypes[863]); + tp = &(gTypes[867]); break; case mx::ChoiceTokenTreeNode::static_kind(): - tp = &(gTypes[864]); + tp = &(gTypes[868]); break; case mx::SubstitutionTokenTreeNode::static_kind(): - tp = &(gTypes[865]); + tp = &(gTypes[869]); break; case mx::SequenceTokenTreeNode::static_kind(): - tp = &(gTypes[866]); + tp = &(gTypes[870]); break; } @@ -161,7 +161,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[861]); + PyTypeObject * const tp = &(gTypes[865]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp b/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp index 09e1bd5c3..cab8ef869 100644 --- a/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp +++ b/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[844]) || tp >= &(gTypes[845])) { + if (tp < &(gTypes[848]) || tp >= &(gTypes[849])) { return std::nullopt; } @@ -88,7 +88,7 @@ SharedPyObject *PythonBinding::to_python(T val) noexcept { break; case mx::UndefineMacroDirective::static_kind(): - tp = &(gTypes[844]); + tp = &(gTypes[848]); break; } @@ -287,7 +287,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::from(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -317,7 +317,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[844]); + PyTypeObject * const tp = &(gTypes[848]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { @@ -332,12 +332,12 @@ PyTypeObject *InitType(void) noexcept { tp->tp_as_number = nullptr; tp->tp_as_sequence = nullptr; tp->tp_as_mapping = nullptr; - tp->tp_hash = gTypes[841].tp_hash; - tp->tp_richcompare = gTypes[841].tp_richcompare; + tp->tp_hash = gTypes[845].tp_hash; + tp->tp_richcompare = gTypes[845].tp_richcompare; tp->tp_iter = nullptr; tp->tp_methods = gMethods; tp->tp_getset = gProperties; - tp->tp_base = &(gTypes[841]); + tp->tp_base = &(gTypes[845]); tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { PyErrorStreamer(PyExc_TypeError) diff --git a/bindings/Python/Generated/IR/BlockKind.cpp b/bindings/Python/Generated/IR/BlockKind.cpp new file mode 100644 index 000000000..f6a610856 --- /dev/null +++ b/bindings/Python/Generated/IR/BlockKind.cpp @@ -0,0 +1,140 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + +namespace mx { +namespace { +using T = mx::ir::BlockKind; +} // namespace + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + return PyObject_GetAttrString(reinterpret_cast(gType), + EnumeratorName(val)); +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + if (Py_TYPE(obj) != gType) { + return std::nullopt; + } + + SharedPyPtr long_val(PyObject_GetAttrString(obj, "value")); + if (!long_val) { + PyErr_Clear(); + return std::nullopt; + } + + if (!PyLong_Check(long_val.Get())) { + return std::nullopt; + } + + int did_overflow = 0; + const auto ret = static_cast( + PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow)); + if (did_overflow) { + return std::nullopt; + } + + return ret; +} + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + const char * const enum_name = EnumerationName(T{}); + bool created = false; + + if (!gType) { + SharedPyPtr enum_module(PyImport_ImportModule("enum")); + if (!enum_module) { + return false; + } + + SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum")); + if (!int_enum) { + return false; + } + + SharedPyPtr enum_meta(PyObject_Type(int_enum.Get())); + SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__")); + if (!prepare) { + return false; + } + + // Get the `enum._EnumDict` for what we're making. + SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get())); + if (!ns_dict) { + return false; + } + + // Assign each enumerator. + for (T val : EnumerationRange()) { + auto ival = PyLong_FromUnsignedLongLong(static_cast(val)); + if (ival) { + auto iname = PyUnicode_FromString(EnumeratorName(val)); + if (!PyObject_SetItem(ns_dict, iname, ival)) { + continue; + } + + Py_DECREF(iname); + Py_DECREF(ival); + } + return false; + } + + // Create the type. + auto enum_class = PyObject_CallFunction( + enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get()); + if (!enum_class) { + return false; + } + + if (!PyType_Check(enum_class)) { + Py_DECREF(enum_class); + + PyErrorStreamer(PyExc_ImportError) + << "Created enum class for enumerator '" << enum_name + << "' is not a python type"; + return false; + } + + gType = reinterpret_cast(enum_class); + created = true; + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) { + return false; + } + + if (created) { + Py_DECREF(tp_obj); + } + + return true; +} + +} // namespace mx diff --git a/bindings/Python/Generated/IR/IRBlock.cpp b/bindings/Python/Generated/IR/IRBlock.cpp new file mode 100644 index 000000000..1b180cd6b --- /dev/null +++ b/bindings/Python/Generated/IR/IRBlock.cpp @@ -0,0 +1,198 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc99-extensions" +#pragma GCC diagnostic ignored "-Wunused-function" +namespace { +using T = mx::IRBlock; + +struct O final : public ::PyObject { + + // When initialized, points to `backing_storage`. + T *data{nullptr}; + + // Aligned storage for `T`. Pointed to by `data`. + alignas(alignof(T)) char backing_storage[sizeof(T)]; +}; + +inline static O *O_cast(void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static const O *O_cast(const void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static T *T_cast(void *obj) noexcept { + return O_cast(obj)->data; +} + +inline static const T *T_cast(const void *obj) noexcept { + return O_cast(obj)->data; +} + +} // namespace +namespace mx { + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + PyTypeObject * const tp = Py_TYPE(obj); + if (tp < &(gTypes[1]) || tp >= &(gTypes[2])) { + return std::nullopt; + } + + return *T_cast(obj); +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + auto ret = gType->tp_alloc(gType, 0); + if (auto obj = O_cast(ret)) { + obj->data = new (obj->backing_storage) T(std::move(val)); + } + return ret; +} + +namespace { +static PyTypeObject *InitType(void) noexcept; +} // namespace + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + if (!gType) { + gType = InitType(); + if (!gType) { + return false; + } + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, "IRBlock", tp_obj)) { + return false; + } + + return true; +} + +namespace { +static PyGetSetDef gProperties[] = { + { + "id", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->id()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::IRBlock::id"), + nullptr, + }, + {} // Sentinel. +}; +} // namespace + +namespace { +static PyMethodDef gMethods[] = { + {} // Sentinel. +}; +} // namespace + +namespace { + +PyTypeObject *InitType(void) noexcept { + PyTypeObject * const tp = &(gTypes[1]); + tp->tp_basicsize = sizeof(O); + tp->tp_itemsize = 0; + tp->tp_dealloc = [] (::PyObject *obj) { + if (auto *data = T_cast(obj)) { + data->~T(); + } + PyObject_Free(obj); + }; + tp->tp_name = "multiplier.ir.IRBlock"; + tp->tp_flags = Py_TPFLAGS_DEFAULT; + tp->tp_doc = PyDoc_STR("Wrapper for mx::::IRBlock"); + tp->tp_as_number = nullptr; + tp->tp_as_sequence = nullptr; + tp->tp_as_mapping = nullptr; + tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t { + return static_cast(EntityId(T_cast(obj)->id()).Pack()); + }; + tp->tp_richcompare = nullptr; + tp->tp_iter = nullptr; + tp->tp_methods = gMethods; + tp->tp_getset = gProperties; + tp->tp_base = PythonBinding::type(); + tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { + if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { + PyErrorStreamer(PyExc_TypeError) + << "'IRBlock.__init__' does not take any keyword arguments"; + return -1; + } + + if (!args || !PySequence_Check(args)) { + PyErrorStreamer(PyExc_TypeError) + << "Invalid positional arguments passed to 'IRBlock.__init__'"; + return -1; + } + + auto obj = O_cast(self); + auto num_args = PySequence_Size(args); + + while (num_args == 0) { + obj->data = new (obj->backing_storage) IRBlock(); + return 0; + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments to 'IRBlock.__init__'"; + return -1; + + }; + tp->tp_alloc = PyType_GenericAlloc; + tp->tp_new = PyType_GenericNew; + + if (0 != PyType_Ready(tp)) { + return nullptr; + } + + return tp; +} + +} // namespace + +#pragma GCC diagnostic pop +} // namespace mx diff --git a/bindings/Python/Generated/IR/IRFunction.cpp b/bindings/Python/Generated/IR/IRFunction.cpp new file mode 100644 index 000000000..0b5b7eb19 --- /dev/null +++ b/bindings/Python/Generated/IR/IRFunction.cpp @@ -0,0 +1,198 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc99-extensions" +#pragma GCC diagnostic ignored "-Wunused-function" +namespace { +using T = mx::IRFunction; + +struct O final : public ::PyObject { + + // When initialized, points to `backing_storage`. + T *data{nullptr}; + + // Aligned storage for `T`. Pointed to by `data`. + alignas(alignof(T)) char backing_storage[sizeof(T)]; +}; + +inline static O *O_cast(void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static const O *O_cast(const void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static T *T_cast(void *obj) noexcept { + return O_cast(obj)->data; +} + +inline static const T *T_cast(const void *obj) noexcept { + return O_cast(obj)->data; +} + +} // namespace +namespace mx { + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + PyTypeObject * const tp = Py_TYPE(obj); + if (tp < &(gTypes[0]) || tp >= &(gTypes[1])) { + return std::nullopt; + } + + return *T_cast(obj); +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + auto ret = gType->tp_alloc(gType, 0); + if (auto obj = O_cast(ret)) { + obj->data = new (obj->backing_storage) T(std::move(val)); + } + return ret; +} + +namespace { +static PyTypeObject *InitType(void) noexcept; +} // namespace + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + if (!gType) { + gType = InitType(); + if (!gType) { + return false; + } + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, "IRFunction", tp_obj)) { + return false; + } + + return true; +} + +namespace { +static PyGetSetDef gProperties[] = { + { + "id", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->id()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::IRFunction::id"), + nullptr, + }, + {} // Sentinel. +}; +} // namespace + +namespace { +static PyMethodDef gMethods[] = { + {} // Sentinel. +}; +} // namespace + +namespace { + +PyTypeObject *InitType(void) noexcept { + PyTypeObject * const tp = &(gTypes[0]); + tp->tp_basicsize = sizeof(O); + tp->tp_itemsize = 0; + tp->tp_dealloc = [] (::PyObject *obj) { + if (auto *data = T_cast(obj)) { + data->~T(); + } + PyObject_Free(obj); + }; + tp->tp_name = "multiplier.ir.IRFunction"; + tp->tp_flags = Py_TPFLAGS_DEFAULT; + tp->tp_doc = PyDoc_STR("Wrapper for mx::::IRFunction"); + tp->tp_as_number = nullptr; + tp->tp_as_sequence = nullptr; + tp->tp_as_mapping = nullptr; + tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t { + return static_cast(EntityId(T_cast(obj)->id()).Pack()); + }; + tp->tp_richcompare = nullptr; + tp->tp_iter = nullptr; + tp->tp_methods = gMethods; + tp->tp_getset = gProperties; + tp->tp_base = PythonBinding::type(); + tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { + if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { + PyErrorStreamer(PyExc_TypeError) + << "'IRFunction.__init__' does not take any keyword arguments"; + return -1; + } + + if (!args || !PySequence_Check(args)) { + PyErrorStreamer(PyExc_TypeError) + << "Invalid positional arguments passed to 'IRFunction.__init__'"; + return -1; + } + + auto obj = O_cast(self); + auto num_args = PySequence_Size(args); + + while (num_args == 0) { + obj->data = new (obj->backing_storage) IRFunction(); + return 0; + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments to 'IRFunction.__init__'"; + return -1; + + }; + tp->tp_alloc = PyType_GenericAlloc; + tp->tp_new = PyType_GenericNew; + + if (0 != PyType_Ready(tp)) { + return nullptr; + } + + return tp; +} + +} // namespace + +#pragma GCC diagnostic pop +} // namespace mx diff --git a/bindings/Python/Generated/IR/IRInstruction.cpp b/bindings/Python/Generated/IR/IRInstruction.cpp new file mode 100644 index 000000000..22c39308f --- /dev/null +++ b/bindings/Python/Generated/IR/IRInstruction.cpp @@ -0,0 +1,198 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc99-extensions" +#pragma GCC diagnostic ignored "-Wunused-function" +namespace { +using T = mx::IRInstruction; + +struct O final : public ::PyObject { + + // When initialized, points to `backing_storage`. + T *data{nullptr}; + + // Aligned storage for `T`. Pointed to by `data`. + alignas(alignof(T)) char backing_storage[sizeof(T)]; +}; + +inline static O *O_cast(void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static const O *O_cast(const void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static T *T_cast(void *obj) noexcept { + return O_cast(obj)->data; +} + +inline static const T *T_cast(const void *obj) noexcept { + return O_cast(obj)->data; +} + +} // namespace +namespace mx { + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + PyTypeObject * const tp = Py_TYPE(obj); + if (tp < &(gTypes[2]) || tp >= &(gTypes[3])) { + return std::nullopt; + } + + return *T_cast(obj); +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + auto ret = gType->tp_alloc(gType, 0); + if (auto obj = O_cast(ret)) { + obj->data = new (obj->backing_storage) T(std::move(val)); + } + return ret; +} + +namespace { +static PyTypeObject *InitType(void) noexcept; +} // namespace + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + if (!gType) { + gType = InitType(); + if (!gType) { + return false; + } + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, "IRInstruction", tp_obj)) { + return false; + } + + return true; +} + +namespace { +static PyGetSetDef gProperties[] = { + { + "id", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->id()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::IRInstruction::id"), + nullptr, + }, + {} // Sentinel. +}; +} // namespace + +namespace { +static PyMethodDef gMethods[] = { + {} // Sentinel. +}; +} // namespace + +namespace { + +PyTypeObject *InitType(void) noexcept { + PyTypeObject * const tp = &(gTypes[2]); + tp->tp_basicsize = sizeof(O); + tp->tp_itemsize = 0; + tp->tp_dealloc = [] (::PyObject *obj) { + if (auto *data = T_cast(obj)) { + data->~T(); + } + PyObject_Free(obj); + }; + tp->tp_name = "multiplier.ir.IRInstruction"; + tp->tp_flags = Py_TPFLAGS_DEFAULT; + tp->tp_doc = PyDoc_STR("Wrapper for mx::::IRInstruction"); + tp->tp_as_number = nullptr; + tp->tp_as_sequence = nullptr; + tp->tp_as_mapping = nullptr; + tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t { + return static_cast(EntityId(T_cast(obj)->id()).Pack()); + }; + tp->tp_richcompare = nullptr; + tp->tp_iter = nullptr; + tp->tp_methods = gMethods; + tp->tp_getset = gProperties; + tp->tp_base = PythonBinding::type(); + tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { + if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { + PyErrorStreamer(PyExc_TypeError) + << "'IRInstruction.__init__' does not take any keyword arguments"; + return -1; + } + + if (!args || !PySequence_Check(args)) { + PyErrorStreamer(PyExc_TypeError) + << "Invalid positional arguments passed to 'IRInstruction.__init__'"; + return -1; + } + + auto obj = O_cast(self); + auto num_args = PySequence_Size(args); + + while (num_args == 0) { + obj->data = new (obj->backing_storage) IRInstruction(); + return 0; + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments to 'IRInstruction.__init__'"; + return -1; + + }; + tp->tp_alloc = PyType_GenericAlloc; + tp->tp_new = PyType_GenericNew; + + if (0 != PyType_Ready(tp)) { + return nullptr; + } + + return tp; +} + +} // namespace + +#pragma GCC diagnostic pop +} // namespace mx diff --git a/bindings/Python/Generated/IR/IRObject.cpp b/bindings/Python/Generated/IR/IRObject.cpp new file mode 100644 index 000000000..2c6b4cddc --- /dev/null +++ b/bindings/Python/Generated/IR/IRObject.cpp @@ -0,0 +1,198 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc99-extensions" +#pragma GCC diagnostic ignored "-Wunused-function" +namespace { +using T = mx::IRObject; + +struct O final : public ::PyObject { + + // When initialized, points to `backing_storage`. + T *data{nullptr}; + + // Aligned storage for `T`. Pointed to by `data`. + alignas(alignof(T)) char backing_storage[sizeof(T)]; +}; + +inline static O *O_cast(void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static const O *O_cast(const void *obj) noexcept { + return reinterpret_cast(obj); +} + +inline static T *T_cast(void *obj) noexcept { + return O_cast(obj)->data; +} + +inline static const T *T_cast(const void *obj) noexcept { + return O_cast(obj)->data; +} + +} // namespace +namespace mx { + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + PyTypeObject * const tp = Py_TYPE(obj); + if (tp < &(gTypes[3]) || tp >= &(gTypes[4])) { + return std::nullopt; + } + + return *T_cast(obj); +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + auto ret = gType->tp_alloc(gType, 0); + if (auto obj = O_cast(ret)) { + obj->data = new (obj->backing_storage) T(std::move(val)); + } + return ret; +} + +namespace { +static PyTypeObject *InitType(void) noexcept; +} // namespace + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + if (!gType) { + gType = InitType(); + if (!gType) { + return false; + } + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, "IRObject", tp_obj)) { + return false; + } + + return true; +} + +namespace { +static PyGetSetDef gProperties[] = { + { + "id", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->id()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::IRObject::id"), + nullptr, + }, + {} // Sentinel. +}; +} // namespace + +namespace { +static PyMethodDef gMethods[] = { + {} // Sentinel. +}; +} // namespace + +namespace { + +PyTypeObject *InitType(void) noexcept { + PyTypeObject * const tp = &(gTypes[3]); + tp->tp_basicsize = sizeof(O); + tp->tp_itemsize = 0; + tp->tp_dealloc = [] (::PyObject *obj) { + if (auto *data = T_cast(obj)) { + data->~T(); + } + PyObject_Free(obj); + }; + tp->tp_name = "multiplier.ir.IRObject"; + tp->tp_flags = Py_TPFLAGS_DEFAULT; + tp->tp_doc = PyDoc_STR("Wrapper for mx::::IRObject"); + tp->tp_as_number = nullptr; + tp->tp_as_sequence = nullptr; + tp->tp_as_mapping = nullptr; + tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t { + return static_cast(EntityId(T_cast(obj)->id()).Pack()); + }; + tp->tp_richcompare = nullptr; + tp->tp_iter = nullptr; + tp->tp_methods = gMethods; + tp->tp_getset = gProperties; + tp->tp_base = PythonBinding::type(); + tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int { + if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) { + PyErrorStreamer(PyExc_TypeError) + << "'IRObject.__init__' does not take any keyword arguments"; + return -1; + } + + if (!args || !PySequence_Check(args)) { + PyErrorStreamer(PyExc_TypeError) + << "Invalid positional arguments passed to 'IRObject.__init__'"; + return -1; + } + + auto obj = O_cast(self); + auto num_args = PySequence_Size(args); + + while (num_args == 0) { + obj->data = new (obj->backing_storage) IRObject(); + return 0; + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments to 'IRObject.__init__'"; + return -1; + + }; + tp->tp_alloc = PyType_GenericAlloc; + tp->tp_new = PyType_GenericNew; + + if (0 != PyType_Ready(tp)) { + return nullptr; + } + + return tp; +} + +} // namespace + +#pragma GCC diagnostic pop +} // namespace mx diff --git a/bindings/Python/Generated/IR/IRStructure.cpp b/bindings/Python/Generated/IR/IRStructure.cpp new file mode 100644 index 000000000..38b07dd0d --- /dev/null +++ b/bindings/Python/Generated/IR/IRStructure.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Stub binding for IRStructure — will be replaced by bootstrap regeneration. + +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + +namespace mx { + +namespace { +using T = mx::IRStructure; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + // TODO: assign proper gTypes slot after bootstrap regeneration. + return PythonBinding::type(); +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *) noexcept { + // IRStructure cannot be created from Python yet. + return std::nullopt; +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + // Convert to VariantEntity and use that binding. + return ::mx::to_python(VariantEntity(std::move(val))); +} + +template <> +bool PythonBinding::load(BorrowedPyObject *) noexcept { + // Will be registered after bootstrap regeneration. + return true; +} + +} // namespace mx diff --git a/bindings/Python/Generated/IR/ObjectKind.cpp b/bindings/Python/Generated/IR/ObjectKind.cpp new file mode 100644 index 000000000..cfea8d074 --- /dev/null +++ b/bindings/Python/Generated/IR/ObjectKind.cpp @@ -0,0 +1,140 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + +namespace mx { +namespace { +using T = mx::ir::ObjectKind; +} // namespace + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + return PyObject_GetAttrString(reinterpret_cast(gType), + EnumeratorName(val)); +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + if (Py_TYPE(obj) != gType) { + return std::nullopt; + } + + SharedPyPtr long_val(PyObject_GetAttrString(obj, "value")); + if (!long_val) { + PyErr_Clear(); + return std::nullopt; + } + + if (!PyLong_Check(long_val.Get())) { + return std::nullopt; + } + + int did_overflow = 0; + const auto ret = static_cast( + PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow)); + if (did_overflow) { + return std::nullopt; + } + + return ret; +} + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + const char * const enum_name = EnumerationName(T{}); + bool created = false; + + if (!gType) { + SharedPyPtr enum_module(PyImport_ImportModule("enum")); + if (!enum_module) { + return false; + } + + SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum")); + if (!int_enum) { + return false; + } + + SharedPyPtr enum_meta(PyObject_Type(int_enum.Get())); + SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__")); + if (!prepare) { + return false; + } + + // Get the `enum._EnumDict` for what we're making. + SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get())); + if (!ns_dict) { + return false; + } + + // Assign each enumerator. + for (T val : EnumerationRange()) { + auto ival = PyLong_FromUnsignedLongLong(static_cast(val)); + if (ival) { + auto iname = PyUnicode_FromString(EnumeratorName(val)); + if (!PyObject_SetItem(ns_dict, iname, ival)) { + continue; + } + + Py_DECREF(iname); + Py_DECREF(ival); + } + return false; + } + + // Create the type. + auto enum_class = PyObject_CallFunction( + enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get()); + if (!enum_class) { + return false; + } + + if (!PyType_Check(enum_class)) { + Py_DECREF(enum_class); + + PyErrorStreamer(PyExc_ImportError) + << "Created enum class for enumerator '" << enum_name + << "' is not a python type"; + return false; + } + + gType = reinterpret_cast(enum_class); + created = true; + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) { + return false; + } + + if (created) { + Py_DECREF(tp_obj); + } + + return true; +} + +} // namespace mx diff --git a/bindings/Python/Generated/IR/OpCode.cpp b/bindings/Python/Generated/IR/OpCode.cpp new file mode 100644 index 000000000..1a55b3d91 --- /dev/null +++ b/bindings/Python/Generated/IR/OpCode.cpp @@ -0,0 +1,140 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + +namespace mx { +namespace { +using T = mx::ir::OpCode; +} // namespace + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + return PyObject_GetAttrString(reinterpret_cast(gType), + EnumeratorName(val)); +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + if (Py_TYPE(obj) != gType) { + return std::nullopt; + } + + SharedPyPtr long_val(PyObject_GetAttrString(obj, "value")); + if (!long_val) { + PyErr_Clear(); + return std::nullopt; + } + + if (!PyLong_Check(long_val.Get())) { + return std::nullopt; + } + + int did_overflow = 0; + const auto ret = static_cast( + PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow)); + if (did_overflow) { + return std::nullopt; + } + + return ret; +} + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + const char * const enum_name = EnumerationName(T{}); + bool created = false; + + if (!gType) { + SharedPyPtr enum_module(PyImport_ImportModule("enum")); + if (!enum_module) { + return false; + } + + SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum")); + if (!int_enum) { + return false; + } + + SharedPyPtr enum_meta(PyObject_Type(int_enum.Get())); + SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__")); + if (!prepare) { + return false; + } + + // Get the `enum._EnumDict` for what we're making. + SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get())); + if (!ns_dict) { + return false; + } + + // Assign each enumerator. + for (T val : EnumerationRange()) { + auto ival = PyLong_FromUnsignedLongLong(static_cast(val)); + if (ival) { + auto iname = PyUnicode_FromString(EnumeratorName(val)); + if (!PyObject_SetItem(ns_dict, iname, ival)) { + continue; + } + + Py_DECREF(iname); + Py_DECREF(ival); + } + return false; + } + + // Create the type. + auto enum_class = PyObject_CallFunction( + enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get()); + if (!enum_class) { + return false; + } + + if (!PyType_Check(enum_class)) { + Py_DECREF(enum_class); + + PyErrorStreamer(PyExc_ImportError) + << "Created enum class for enumerator '" << enum_name + << "' is not a python type"; + return false; + } + + gType = reinterpret_cast(enum_class); + created = true; + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) { + return false; + } + + if (created) { + Py_DECREF(tp_obj); + } + + return true; +} + +} // namespace mx diff --git a/bindings/Python/Generated/IREntityKind.cpp b/bindings/Python/Generated/IREntityKind.cpp new file mode 100644 index 000000000..0c0725345 --- /dev/null +++ b/bindings/Python/Generated/IREntityKind.cpp @@ -0,0 +1,140 @@ +// Copyright (c) 2023-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +// Auto-generated file; do not modify! + +#include +#include + +#include "Binding.h" +#include "Error.h" +#include "Types.h" + +namespace mx { +namespace { +using T = mx::IREntityKind; +} // namespace + +namespace { +static PyTypeObject *gType = nullptr; +} // namespace + +template <> +PyTypeObject *PythonBinding::type(void) noexcept { + return gType; +} + +template <> +SharedPyObject *PythonBinding::to_python(T val) noexcept { + return PyObject_GetAttrString(reinterpret_cast(gType), + EnumeratorName(val)); +} + +template <> +std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { + if (!obj) { + return std::nullopt; + } + + if (Py_TYPE(obj) != gType) { + return std::nullopt; + } + + SharedPyPtr long_val(PyObject_GetAttrString(obj, "value")); + if (!long_val) { + PyErr_Clear(); + return std::nullopt; + } + + if (!PyLong_Check(long_val.Get())) { + return std::nullopt; + } + + int did_overflow = 0; + const auto ret = static_cast( + PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow)); + if (did_overflow) { + return std::nullopt; + } + + return ret; +} + +template <> +bool PythonBinding::load(BorrowedPyObject *module) noexcept { + const char * const enum_name = EnumerationName(T{}); + bool created = false; + + if (!gType) { + SharedPyPtr enum_module(PyImport_ImportModule("enum")); + if (!enum_module) { + return false; + } + + SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum")); + if (!int_enum) { + return false; + } + + SharedPyPtr enum_meta(PyObject_Type(int_enum.Get())); + SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__")); + if (!prepare) { + return false; + } + + // Get the `enum._EnumDict` for what we're making. + SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get())); + if (!ns_dict) { + return false; + } + + // Assign each enumerator. + for (T val : EnumerationRange()) { + auto ival = PyLong_FromUnsignedLongLong(static_cast(val)); + if (ival) { + auto iname = PyUnicode_FromString(EnumeratorName(val)); + if (!PyObject_SetItem(ns_dict, iname, ival)) { + continue; + } + + Py_DECREF(iname); + Py_DECREF(ival); + } + return false; + } + + // Create the type. + auto enum_class = PyObject_CallFunction( + enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get()); + if (!enum_class) { + return false; + } + + if (!PyType_Check(enum_class)) { + Py_DECREF(enum_class); + + PyErrorStreamer(PyExc_ImportError) + << "Created enum class for enumerator '" << enum_name + << "' is not a python type"; + return false; + } + + gType = reinterpret_cast(enum_class); + created = true; + } + + auto tp_obj = reinterpret_cast(gType); + if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) { + return false; + } + + if (created) { + Py_DECREF(tp_obj); + } + + return true; +} + +} // namespace mx diff --git a/bindings/Python/Generated/Index.cpp b/bindings/Python/Generated/Index.cpp index 756944ed5..0f0df4a21 100644 --- a/bindings/Python/Generated/Index.cpp +++ b/bindings/Python/Generated/Index.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[867]) || tp >= &(gTypes[868])) { + if (tp < &(gTypes[871]) || tp >= &(gTypes[872])) { return std::nullopt; } @@ -302,7 +302,7 @@ static PyMethodDef gMethods[] = { return ::mx::to_python(T::containing(arg_0.value())); } while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -751,6 +751,126 @@ static PyMethodDef gMethods[] = { METH_FASTCALL, PyDoc_STR("Wrapper for mx::Index::compilation"), }, + { + "ir_function", + reinterpret_cast( + +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { + T *obj = T_cast(self); + (void) args; + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_function(std::move(arg_0.value()))); + } + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_function(std::move(arg_0.value()))); + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments passed to 'ir_function'"; + return nullptr; + }), + METH_FASTCALL, + PyDoc_STR("Wrapper for mx::Index::ir_function"), + }, + { + "ir_block", + reinterpret_cast( + +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { + T *obj = T_cast(self); + (void) args; + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_block(std::move(arg_0.value()))); + } + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_block(std::move(arg_0.value()))); + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments passed to 'ir_block'"; + return nullptr; + }), + METH_FASTCALL, + PyDoc_STR("Wrapper for mx::Index::ir_block"), + }, + { + "ir_instruction", + reinterpret_cast( + +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { + T *obj = T_cast(self); + (void) args; + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_instruction(std::move(arg_0.value()))); + } + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_instruction(std::move(arg_0.value()))); + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments passed to 'ir_instruction'"; + return nullptr; + }), + METH_FASTCALL, + PyDoc_STR("Wrapper for mx::Index::ir_instruction"), + }, + { + "ir_object", + reinterpret_cast( + +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { + T *obj = T_cast(self); + (void) args; + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_object(std::move(arg_0.value()))); + } + while (num_args == 1) { + auto arg_0 = ::mx::from_python(args[0]); + if (!arg_0.has_value()) { + break; + } + + return ::mx::to_python(obj->ir_object(std::move(arg_0.value()))); + } + + PyErrorStreamer(PyExc_TypeError) + << "Invalid arguments passed to 'ir_object'"; + return nullptr; + }), + METH_FASTCALL, + PyDoc_STR("Wrapper for mx::Index::ir_object"), + }, { "entity", reinterpret_cast( @@ -802,7 +922,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[867]); + PyTypeObject * const tp = &(gTypes[871]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/Reference.cpp b/bindings/Python/Generated/Reference.cpp index 38ee5d9de..ab1d9faef 100644 --- a/bindings/Python/Generated/Reference.cpp +++ b/bindings/Python/Generated/Reference.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[825]) || tp >= &(gTypes[826])) { + if (tp < &(gTypes[829]) || tp >= &(gTypes[830])) { return std::nullopt; } @@ -310,6 +310,46 @@ static PyGetSetDef gProperties[] = { PyDoc_STR("Wrapper for mx::Reference::as_compilation"), nullptr, }, + { + "as_ir_function", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->as_ir_function()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::Reference::as_ir_function"), + nullptr, + }, + { + "as_ir_block", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->as_ir_block()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::Reference::as_ir_block"), + nullptr, + }, + { + "as_ir_instruction", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->as_ir_instruction()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::Reference::as_ir_instruction"), + nullptr, + }, + { + "as_ir_object", + reinterpret_cast( + +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * { + return ::mx::to_python(T_cast(self)->as_ir_object()); + }), + nullptr, + PyDoc_STR("Wrapper for mx::Reference::as_ir_object"), + nullptr, + }, {} // Sentinel. }; } // namespace @@ -326,11 +366,11 @@ static PyMethodDef gMethods[] = { if (!arg_0.has_value()) { break; } - auto arg_1 = ::mx::from_python>(args[1]); + auto arg_1 = ::mx::from_python>(args[1]); if (!arg_1.has_value()) { break; } - auto arg_2 = ::mx::from_python>(args[2]); + auto arg_2 = ::mx::from_python>(args[2]); if (!arg_2.has_value()) { break; } @@ -342,15 +382,15 @@ static PyMethodDef gMethods[] = { if (!arg_0.has_value()) { break; } - auto arg_1 = ::mx::from_python>(args[1]); + auto arg_1 = ::mx::from_python>(args[1]); if (!arg_1.has_value()) { break; } - auto arg_2 = ::mx::from_python>(args[2]); + auto arg_2 = ::mx::from_python>(args[2]); if (!arg_2.has_value()) { break; } - auto arg_3 = ::mx::from_python>(args[3]); + auto arg_3 = ::mx::from_python>(args[3]); if (!arg_3.has_value()) { break; } @@ -371,7 +411,7 @@ static PyMethodDef gMethods[] = { +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { (void) args; while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -392,7 +432,7 @@ static PyMethodDef gMethods[] = { +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * { (void) args; while (num_args == 1) { - auto arg_0 = ::mx::from_python>(args[0]); + auto arg_0 = ::mx::from_python>(args[0]); if (!arg_0.has_value()) { break; } @@ -414,7 +454,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[825]); + PyTypeObject * const tp = &(gTypes[829]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/ReferenceKind.cpp b/bindings/Python/Generated/ReferenceKind.cpp index b46f29eeb..bb56e2667 100644 --- a/bindings/Python/Generated/ReferenceKind.cpp +++ b/bindings/Python/Generated/ReferenceKind.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[824]) || tp >= &(gTypes[825])) { + if (tp < &(gTypes[828]) || tp >= &(gTypes[829])) { return std::nullopt; } @@ -180,7 +180,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[824]); + PyTypeObject * const tp = &(gTypes[828]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Generated/RegexQuery.cpp b/bindings/Python/Generated/RegexQuery.cpp index 9476d7a32..ba8a2fe65 100644 --- a/bindings/Python/Generated/RegexQuery.cpp +++ b/bindings/Python/Generated/RegexQuery.cpp @@ -71,7 +71,7 @@ std::optional PythonBinding::from_python(BorrowedPyObject *obj) noexcept { } PyTypeObject * const tp = Py_TYPE(obj); - if (tp < &(gTypes[868]) || tp >= &(gTypes[869])) { + if (tp < &(gTypes[872]) || tp >= &(gTypes[873])) { return std::nullopt; } @@ -194,7 +194,7 @@ static PyMethodDef gMethods[] = { namespace { PyTypeObject *InitType(void) noexcept { - PyTypeObject * const tp = &(gTypes[868]); + PyTypeObject * const tp = &(gTypes[872]); tp->tp_basicsize = sizeof(O); tp->tp_itemsize = 0; tp->tp_dealloc = [] (::PyObject *obj) { diff --git a/bindings/Python/Module.cpp b/bindings/Python/Module.cpp index 2a4918417..98fc84916 100644 --- a/bindings/Python/Module.cpp +++ b/bindings/Python/Module.cpp @@ -39,6 +39,7 @@ static PyModuleDef gModule = { static LoaderFunc * const gLoaders[] = { PythonBinding::load, + PythonBinding::load, PythonBinding::load, PythonBinding::load, PythonBinding::load, @@ -48,6 +49,28 @@ static LoaderFunc * const gLoaders[] = { PythonBinding::load, }; +// multiplier.ir +static PyModuleDef gIRModule = { + .m_name = "ir", + .m_doc = PyDoc_STR("Wrapper of IR"), + .m_size = 0, + .m_methods = gEmptyMethods, + .m_slots = {}, + .m_traverse = {}, + .m_clear = {}, + .m_free = {}, +}; + +static LoaderFunc * const gIRLoaders[] = { + PythonBinding::load, + PythonBinding::load, + PythonBinding::load, + PythonBinding::load, + PythonBinding::load, + PythonBinding::load, + PythonBinding::load, +}; + // multiplier.ast static PyModuleDef gASTModule = { .m_name = "ast", @@ -1550,6 +1573,26 @@ PyMODINIT_FUNC PyInit_multiplier(void) { } } + auto irm = PyModule_Create(&mx::gIRModule); + if (!irm) { + return nullptr; + } + + for (auto loader : mx::gIRLoaders) { + if (!loader(irm)) { + Py_DECREF(m); + return nullptr; + } + } + + if (m) { + if (0 != PyModule_AddObjectRef(m, "ir", irm)) { + Py_DECREF(irm); + Py_DECREF(m); + return nullptr; + } + } + auto astm = PyModule_Create(&mx::gASTModule); if (!astm) { return nullptr; diff --git a/bindings/Python/Types.cpp b/bindings/Python/Types.cpp index d6e235fce..d7a6c05df 100644 --- a/bindings/Python/Types.cpp +++ b/bindings/Python/Types.cpp @@ -10,6 +10,6 @@ namespace mx { // Size is defined in the auto-generated `Types.cpp` file. -PyTypeObject gTypes[869] = {}; +PyTypeObject gTypes[873] = {}; } // namespace mx diff --git a/bindings/Python/multiplier-stubs/__init__.py b/bindings/Python/multiplier-stubs/__init__.py index 130375055..97821e922 100644 --- a/bindings/Python/multiplier-stubs/__init__.py +++ b/bindings/Python/multiplier-stubs/__init__.py @@ -31,6 +31,7 @@ class Entity(object, ABC): id: int import multiplier +import multiplier.ir import multiplier.ast import multiplier.frontend @@ -50,6 +51,16 @@ class EntityCategory(IntEnum): DESIGNATOR = 12 CXX_CTOR_INITIALIZER = 13 COMPILATION = 14 + IR_FUNCTION = 15 + IR_BLOCK = 16 + IR_INSTRUCTION = 17 + IR_OBJECT = 18 + +class IREntityKind(IntEnum): + IR_FUNCTION = 0 + IR_BLOCK = 1 + IR_INSTRUCTION = 2 + IR_OBJECT = 3 class BuiltinReferenceKind(IntEnum): USES_VALUE = 0 @@ -110,23 +121,27 @@ class Reference(object): as_designator: Optional[multiplier.ast.Designator] as_cxx_ctor_initializer: Optional[multiplier.ast.CXXCtorInitializer] as_compilation: Optional[multiplier.frontend.Compilation] + as_ir_function: Optional[multiplier.ir.IRFunction] + as_ir_block: Optional[multiplier.ir.IRBlock] + as_ir_instruction: Optional[multiplier.ir.IRInstruction] + as_ir_object: Optional[multiplier.ir.IRObject] @overload @staticmethod - def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> bool: + def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> bool: ... @overload @staticmethod - def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation], context: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> bool: + def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject], context: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> bool: ... @staticmethod - def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Iterable[multiplier.Reference]: + def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Iterable[multiplier.Reference]: ... @staticmethod - def to(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Iterable[multiplier.Reference]: + def to(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Iterable[multiplier.Reference]: ... class Fragment(multiplier.Entity): @@ -206,11 +221,11 @@ def containing(arg_0: multiplier.frontend.Macro) -> multiplier.Fragment: @overload @staticmethod - def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.Fragment]: + def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.Fragment]: ... @staticmethod - def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.Fragment]: + def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.Fragment]: ... @staticmethod @@ -305,7 +320,7 @@ def containing(entity: multiplier.frontend.Token) -> Optional[multiplier.Index]: @overload @staticmethod - def containing(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.Index]: + def containing(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.Index]: ... def status(self, block: bool) -> multiplier.IndexStatus: @@ -418,6 +433,38 @@ def compilation(self, id: int) -> Optional[multiplier.frontend.Compilation]: def compilation(self, id: multiplier.CompilationId) -> Optional[multiplier.frontend.Compilation]: ... + @overload + def ir_function(self, id: int) -> Optional[multiplier.ir.IRFunction]: + ... + + @overload + def ir_function(self, id: multiplier.IRFunctionId) -> Optional[multiplier.ir.IRFunction]: + ... + + @overload + def ir_block(self, id: int) -> Optional[multiplier.ir.IRBlock]: + ... + + @overload + def ir_block(self, id: multiplier.IRBlockId) -> Optional[multiplier.ir.IRBlock]: + ... + + @overload + def ir_instruction(self, id: int) -> Optional[multiplier.ir.IRInstruction]: + ... + + @overload + def ir_instruction(self, id: multiplier.IRInstructionId) -> Optional[multiplier.ir.IRInstruction]: + ... + + @overload + def ir_object(self, id: int) -> Optional[multiplier.ir.IRObject]: + ... + + @overload + def ir_object(self, id: multiplier.IRObjectId) -> Optional[multiplier.ir.IRObject]: + ... + def entity(self, eid: int) -> multiplier.Entity: ... diff --git a/bindings/Python/multiplier-stubs/ast/__init__.py b/bindings/Python/multiplier-stubs/ast/__init__.py index d95cc0860..af4773610 100644 --- a/bindings/Python/multiplier-stubs/ast/__init__.py +++ b/bindings/Python/multiplier-stubs/ast/__init__.py @@ -12,6 +12,7 @@ from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple import pathlib import multiplier +import multiplier.ir import multiplier.ast import multiplier.frontend @@ -5550,7 +5551,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXCtorInitializer] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXCtorInitializer]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXCtorInitializer]: ... @overload @@ -5619,7 +5620,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Designator]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Designator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Designator]: ... @overload @@ -5689,7 +5690,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBaseSpecifier]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXBaseSpecifier]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXBaseSpecifier]: ... @overload @@ -5757,7 +5758,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateParameterLi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateParameterList]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateParameterList]: ... @overload @@ -5832,7 +5833,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateArgument]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateArgument]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateArgument]: ... @overload @@ -5916,7 +5917,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Attr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Attr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Attr]: ... @overload @@ -5978,7 +5979,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignValueAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignValueAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AlignValueAttr]: ... @overload @@ -6041,7 +6042,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AliasAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AliasAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AliasAttr]: ... @overload @@ -6102,7 +6103,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AbiTagAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AbiTagAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AbiTagAttr]: ... @overload @@ -6159,7 +6160,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeAttr]: ... @overload @@ -6220,7 +6221,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SPtrAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SPtrAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SPtrAttr]: ... @overload @@ -6281,7 +6282,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Ptr64Attr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Ptr64Attr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Ptr64Attr]: ... @overload @@ -6342,7 +6343,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Ptr32Attr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Ptr32Attr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Ptr32Attr]: ... @overload @@ -6404,7 +6405,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLPrivateAddres @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLPrivateAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLPrivateAddressSpaceAttr]: ... @overload @@ -6466,7 +6467,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLLocalAddressS @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLLocalAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLLocalAddressSpaceAttr]: ... @overload @@ -6527,7 +6528,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGlobalHostAdd @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGlobalHostAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLGlobalHostAddressSpaceAttr]: ... @overload @@ -6588,7 +6589,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGlobalDeviceA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGlobalDeviceAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLGlobalDeviceAddressSpaceAttr]: ... @overload @@ -6650,7 +6651,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGlobalAddress @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGlobalAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLGlobalAddressSpaceAttr]: ... @overload @@ -6712,7 +6713,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGenericAddres @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGenericAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLGenericAddressSpaceAttr]: ... @overload @@ -6774,7 +6775,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLConstantAddre @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLConstantAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLConstantAddressSpaceAttr]: ... @overload @@ -6835,7 +6836,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCKindOfAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCKindOfAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCKindOfAttr]: ... @overload @@ -6896,7 +6897,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCInertUnsafeUnre @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCInertUnsafeUnretainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCInertUnsafeUnretainedAttr]: ... @overload @@ -6957,7 +6958,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCGCAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCGCAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCGCAttr]: ... @overload @@ -7018,7 +7019,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDerefAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDerefAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoDerefAttr]: ... @overload @@ -7086,7 +7087,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLParamModifierAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLParamModifierAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLParamModifierAttr]: ... @overload @@ -7147,7 +7148,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLGroupSharedAddr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLGroupSharedAddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLGroupSharedAddressSpaceAttr]: ... @overload @@ -7208,7 +7209,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CmseNSCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CmseNSCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CmseNSCallAttr]: ... @overload @@ -7271,7 +7272,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BTFTypeTagAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BTFTypeTagAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BTFTypeTagAttr]: ... @overload @@ -7332,7 +7333,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmStreamingCompati @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmStreamingCompatibleAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmStreamingCompatibleAttr]: ... @overload @@ -7393,7 +7394,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmStreamingAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmStreamingAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmStreamingAttr]: ... @overload @@ -7454,7 +7455,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmPreservesAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmPreservesAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmPreservesAttr]: ... @overload @@ -7515,7 +7516,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmOutAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmOutAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmOutAttr]: ... @overload @@ -7576,7 +7577,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmMveStrictPolymor @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmMveStrictPolymorphismAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmMveStrictPolymorphismAttr]: ... @overload @@ -7637,7 +7638,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmInOutAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmInOutAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmInOutAttr]: ... @overload @@ -7698,7 +7699,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmInAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmInAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmInAttr]: ... @overload @@ -7761,7 +7762,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnnotateTypeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnnotateTypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AnnotateTypeAttr]: ... @overload @@ -7822,7 +7823,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AddressSpaceAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AddressSpaceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AddressSpaceAttr]: ... @overload @@ -7883,7 +7884,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyFuncrefA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyFuncrefAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WebAssemblyFuncrefAttr]: ... @overload @@ -7944,7 +7945,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UPtrAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UPtrAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UPtrAttr]: ... @overload @@ -8005,7 +8006,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNullableResultA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNullableResultAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeNullableResultAttr]: ... @overload @@ -8066,7 +8067,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNullableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNullableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeNullableAttr]: ... @overload @@ -8127,7 +8128,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNullUnspecified @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNullUnspecifiedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeNullUnspecifiedAttr]: ... @overload @@ -8188,7 +8189,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNonNullAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNonNullAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeNonNullAttr]: ... @overload @@ -8249,7 +8250,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ThreadAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ThreadAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ThreadAttr]: ... @overload @@ -8313,7 +8314,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftVersionedRemov @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftVersionedRemovalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftVersionedRemovalAttr]: ... @overload @@ -8376,7 +8377,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftVersionedAddit @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftVersionedAdditionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftVersionedAdditionAttr]: ... @overload @@ -8437,7 +8438,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftObjCMembersAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftObjCMembersAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftObjCMembersAttr]: ... @overload @@ -8494,7 +8495,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StmtAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StmtAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StmtAttr]: ... @overload @@ -8556,7 +8557,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLUnrollHintAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLUnrollHintAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLUnrollHintAttr]: ... @overload @@ -8617,7 +8618,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MustTailAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MustTailAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MustTailAttr]: ... @overload @@ -8678,7 +8679,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LikelyAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LikelyAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LikelyAttr]: ... @overload @@ -8739,7 +8740,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FallThroughAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FallThroughAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FallThroughAttr]: ... @overload @@ -8801,7 +8802,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CodeAlignAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CodeAlignAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CodeAlignAttr]: ... @overload @@ -8862,7 +8863,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnlikelyAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnlikelyAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnlikelyAttr]: ... @overload @@ -8923,7 +8924,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RenderScriptKernelA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RenderScriptKernelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RenderScriptKernelAttr]: ... @overload @@ -8984,7 +8985,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OverloadableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OverloadableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OverloadableAttr]: ... @overload @@ -9049,7 +9050,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLAccessAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLAccessAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLAccessAttr]: ... @overload @@ -9110,7 +9111,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRuntimeVisibleA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRuntimeVisibleAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCRuntimeVisibleAttr]: ... @overload @@ -9173,7 +9174,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRuntimeNameAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRuntimeNameAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCRuntimeNameAttr]: ... @overload @@ -9234,7 +9235,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCNonRuntimeProto @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCNonRuntimeProtocolAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCNonRuntimeProtocolAttr]: ... @overload @@ -9295,7 +9296,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCNonLazyClassAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCNonLazyClassAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCNonLazyClassAttr]: ... @overload @@ -9356,7 +9357,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDirectMembersAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDirectMembersAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCDirectMembersAttr]: ... @overload @@ -9417,7 +9418,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDirectAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDirectAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCDirectAttr]: ... @overload @@ -9478,7 +9479,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDesignatedIniti @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDesignatedInitializerAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCDesignatedInitializerAttr]: ... @overload @@ -9539,7 +9540,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCClassStubAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCClassStubAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCClassStubAttr]: ... @overload @@ -9600,7 +9601,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoxableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBoxableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCBoxableAttr]: ... @overload @@ -9662,7 +9663,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPReferencedVarAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPReferencedVarAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPReferencedVarAttr]: ... @overload @@ -9725,7 +9726,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareSimdDeclA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareSimdDeclAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDeclareSimdDeclAttr]: ... @overload @@ -9787,7 +9788,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCaptureKindAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCaptureKindAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPCaptureKindAttr]: ... @overload @@ -9848,7 +9849,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoEscapeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoEscapeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoEscapeAttr]: ... @overload @@ -9909,7 +9910,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoBuiltinAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoBuiltinAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoBuiltinAttr]: ... @overload @@ -9970,7 +9971,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ModeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ModeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ModeAttr]: ... @overload @@ -10035,7 +10036,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LoopHintAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LoopHintAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LoopHintAttr]: ... @overload @@ -10096,7 +10097,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LoaderUninitialized @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LoaderUninitializedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LoaderUninitializedAttr]: ... @overload @@ -10159,7 +10160,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InitSegAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InitSegAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.InitSegAttr]: ... @overload @@ -10217,7 +10218,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InheritableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InheritableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.InheritableAttr]: ... @overload @@ -10280,7 +10281,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IBOutletCollectionA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IBOutletCollectionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IBOutletCollectionAttr]: ... @overload @@ -10341,7 +10342,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IBOutletAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IBOutletAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IBOutletAttr]: ... @overload @@ -10402,7 +10403,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IBActionAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IBActionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IBActionAttr]: ... @overload @@ -10463,7 +10464,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HotAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HotAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HotAttr]: ... @overload @@ -10525,7 +10526,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLShaderAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLShaderAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLShaderAttr]: ... @overload @@ -10590,7 +10591,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLResourceBinding @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLResourceBindingAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLResourceBindingAttr]: ... @overload @@ -10652,7 +10653,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLResourceAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLResourceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLResourceAttr]: ... @overload @@ -10713,7 +10714,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLNumThreadsAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLNumThreadsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLNumThreadsAttr]: ... @overload @@ -10770,7 +10771,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLAnnotationAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLAnnotationAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLAnnotationAttr]: ... @overload @@ -10831,7 +10832,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLSV_GroupIndexAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLSV_GroupIndexAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLSV_GroupIndexAttr]: ... @overload @@ -10892,7 +10893,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLSV_DispatchThre @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLSV_DispatchThreadIDAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLSV_DispatchThreadIDAttr]: ... @overload @@ -10953,7 +10954,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HIPManagedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HIPManagedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HIPManagedAttr]: ... @overload @@ -11014,7 +11015,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GuardedVarAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GuardedVarAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.GuardedVarAttr]: ... @overload @@ -11076,7 +11077,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GuardedByAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GuardedByAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.GuardedByAttr]: ... @overload @@ -11137,7 +11138,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GNUInlineAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GNUInlineAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.GNUInlineAttr]: ... @overload @@ -11199,7 +11200,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionReturnThunk @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionReturnThunksAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FunctionReturnThunksAttr]: ... @overload @@ -11260,7 +11261,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FormatAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FormatAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FormatAttr]: ... @overload @@ -11321,7 +11322,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FormatArgAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FormatArgAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FormatArgAttr]: ... @overload @@ -11382,7 +11383,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FlattenAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FlattenAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FlattenAttr]: ... @overload @@ -11443,7 +11444,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FlagEnumAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FlagEnumAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FlagEnumAttr]: ... @overload @@ -11506,7 +11507,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FinalAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FinalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FinalAttr]: ... @overload @@ -11567,7 +11568,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FastCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FastCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FastCallAttr]: ... @overload @@ -11635,7 +11636,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExternalSourceSymbo @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExternalSourceSymbolAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExternalSourceSymbolAttr]: ... @overload @@ -11697,7 +11698,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExclusiveTrylockFun @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExclusiveTrylockFunctionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExclusiveTrylockFunctionAttr]: ... @overload @@ -11758,7 +11759,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExcludeFromExplicit @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExcludeFromExplicitInstantiationAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExcludeFromExplicitInstantiationAttr]: ... @overload @@ -11824,7 +11825,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ErrorAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ErrorAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ErrorAttr]: ... @overload @@ -11886,7 +11887,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumExtensibilityAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumExtensibilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EnumExtensibilityAttr]: ... @overload @@ -11949,7 +11950,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnforceTCBLeafAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnforceTCBLeafAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EnforceTCBLeafAttr]: ... @overload @@ -12012,7 +12013,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnforceTCBAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnforceTCBAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EnforceTCBAttr]: ... @overload @@ -12076,7 +12077,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnableIfAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnableIfAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EnableIfAttr]: ... @overload @@ -12137,7 +12138,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EmptyBasesAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EmptyBasesAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EmptyBasesAttr]: ... @overload @@ -12198,7 +12199,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DisableTailCallsAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DisableTailCallsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DisableTailCallsAttr]: ... @overload @@ -12259,7 +12260,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DisableSanitizerIns @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DisableSanitizerInstrumentationAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DisableSanitizerInstrumentationAttr]: ... @overload @@ -12328,7 +12329,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DiagnoseIfAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DiagnoseIfAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DiagnoseIfAttr]: ... @overload @@ -12390,7 +12391,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DiagnoseAsBuiltinAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DiagnoseAsBuiltinAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DiagnoseAsBuiltinAttr]: ... @overload @@ -12451,7 +12452,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DestructorAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DestructorAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DestructorAttr]: ... @overload @@ -12516,7 +12517,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeprecatedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeprecatedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DeprecatedAttr]: ... @overload @@ -12573,7 +12574,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclOrStmtAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclOrStmtAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DeclOrStmtAttr]: ... @overload @@ -12636,7 +12637,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlwaysInlineAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlwaysInlineAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AlwaysInlineAttr]: ... @overload @@ -12698,7 +12699,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SuppressAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SuppressAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SuppressAttr]: ... @overload @@ -12759,7 +12760,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoMergeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoMergeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoMergeAttr]: ... @overload @@ -12821,7 +12822,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoInlineAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoInlineAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoInlineAttr]: ... @overload @@ -12882,7 +12883,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLImportStaticLoca @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLImportStaticLocalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DLLImportStaticLocalAttr]: ... @overload @@ -12943,7 +12944,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLImportAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLImportAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DLLImportAttr]: ... @overload @@ -13004,7 +13005,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLExportStaticLoca @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLExportStaticLocalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DLLExportStaticLocalAttr]: ... @overload @@ -13065,7 +13066,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLExportAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLExportAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DLLExportAttr]: ... @overload @@ -13127,7 +13128,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CountedByAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CountedByAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CountedByAttr]: ... @overload @@ -13188,7 +13189,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroWrapperAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroWrapperAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoroWrapperAttr]: ... @overload @@ -13249,7 +13250,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroReturnTypeAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroReturnTypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoroReturnTypeAttr]: ... @overload @@ -13310,7 +13311,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroOnlyDestroyWhen @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroOnlyDestroyWhenCompleteAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoroOnlyDestroyWhenCompleteAttr]: ... @overload @@ -13371,7 +13372,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroLifetimeBoundAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroLifetimeBoundAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoroLifetimeBoundAttr]: ... @overload @@ -13432,7 +13433,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroDisableLifetime @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroDisableLifetimeBoundAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoroDisableLifetimeBoundAttr]: ... @overload @@ -13493,7 +13494,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConvergentAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConvergentAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConvergentAttr]: ... @overload @@ -13554,7 +13555,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConsumableSetOnRead @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConsumableSetOnReadAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConsumableSetOnReadAttr]: ... @overload @@ -13615,7 +13616,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConsumableAutoCastA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConsumableAutoCastAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConsumableAutoCastAttr]: ... @overload @@ -13677,7 +13678,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConsumableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConsumableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConsumableAttr]: ... @overload @@ -13738,7 +13739,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstructorAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstructorAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConstructorAttr]: ... @overload @@ -13801,7 +13802,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstInitAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstInitAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConstInitAttr]: ... @overload @@ -13862,7 +13863,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConstAttr]: ... @overload @@ -13923,7 +13924,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CommonAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CommonAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CommonAttr]: ... @overload @@ -13984,7 +13985,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ColdAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ColdAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ColdAttr]: ... @overload @@ -14047,7 +14048,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CodeSegAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CodeSegAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CodeSegAttr]: ... @overload @@ -14108,7 +14109,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CodeModelAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CodeModelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CodeModelAttr]: ... @overload @@ -14169,7 +14170,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CmseNSEntryAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CmseNSEntryAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CmseNSEntryAttr]: ... @overload @@ -14231,7 +14232,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CleanupAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CleanupAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CleanupAttr]: ... @overload @@ -14292,7 +14293,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedRecordAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapturedRecordAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CapturedRecordAttr]: ... @overload @@ -14357,7 +14358,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapabilityAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapabilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CapabilityAttr]: ... @overload @@ -14418,7 +14419,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CallbackAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CallbackAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CallbackAttr]: ... @overload @@ -14479,7 +14480,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CallableWhenAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CallableWhenAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CallableWhenAttr]: ... @overload @@ -14541,7 +14542,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXX11NoReturnAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXX11NoReturnAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXX11NoReturnAttr]: ... @overload @@ -14602,7 +14603,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDASharedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDASharedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDASharedAttr]: ... @overload @@ -14666,7 +14667,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDALaunchBoundsAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDALaunchBoundsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDALaunchBoundsAttr]: ... @overload @@ -14727,7 +14728,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAInvalidTargetAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAInvalidTargetAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDAInvalidTargetAttr]: ... @overload @@ -14788,7 +14789,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAHostAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAHostAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDAHostAttr]: ... @overload @@ -14849,7 +14850,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAGlobalAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAGlobalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDAGlobalAttr]: ... @overload @@ -14910,7 +14911,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDADeviceBuiltinTe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDADeviceBuiltinTextureTypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDADeviceBuiltinTextureTypeAttr]: ... @overload @@ -14971,7 +14972,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDADeviceBuiltinSu @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDADeviceBuiltinSurfaceTypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDADeviceBuiltinSurfaceTypeAttr]: ... @overload @@ -15032,7 +15033,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDADeviceAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDADeviceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDADeviceAttr]: ... @overload @@ -15093,7 +15094,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAConstantAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAConstantAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDAConstantAttr]: ... @overload @@ -15154,7 +15155,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CPUSpecificAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CPUSpecificAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CPUSpecificAttr]: ... @overload @@ -15215,7 +15216,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CPUDispatchAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CPUDispatchAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CPUDispatchAttr]: ... @overload @@ -15276,7 +15277,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFUnknownTransferAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFUnknownTransferAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CFUnknownTransferAttr]: ... @overload @@ -15337,7 +15338,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFReturnsRetainedAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFReturnsRetainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CFReturnsRetainedAttr]: ... @overload @@ -15398,7 +15399,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFReturnsNotRetaine @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFReturnsNotRetainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CFReturnsNotRetainedAttr]: ... @overload @@ -15459,7 +15460,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFICanonicalJumpTab @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFICanonicalJumpTableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CFICanonicalJumpTableAttr]: ... @overload @@ -15521,7 +15522,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFGuardAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFGuardAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CFGuardAttr]: ... @overload @@ -15582,7 +15583,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFAuditedTransferAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFAuditedTransferAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CFAuditedTransferAttr]: ... @overload @@ -15643,7 +15644,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CDeclAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CDeclAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CDeclAttr]: ... @overload @@ -15704,7 +15705,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.C11NoReturnAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.C11NoReturnAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.C11NoReturnAttr]: ... @overload @@ -15765,7 +15766,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BuiltinAttr]: ... @overload @@ -15827,7 +15828,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlocksAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlocksAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BlocksAttr]: ... @overload @@ -15890,7 +15891,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BTFDeclTagAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BTFDeclTagAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BTFDeclTagAttr]: ... @overload @@ -15951,7 +15952,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BPFPreserveStaticOf @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BPFPreserveStaticOffsetAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BPFPreserveStaticOffsetAttr]: ... @overload @@ -16012,7 +16013,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BPFPreserveAccessIn @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BPFPreserveAccessIndexAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BPFPreserveAccessIndexAttr]: ... @overload @@ -16073,7 +16074,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AvailableOnlyInDefa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AvailableOnlyInDefaultEvalMethodAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AvailableOnlyInDefaultEvalMethodAttr]: ... @overload @@ -16140,7 +16141,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AvailabilityAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AvailabilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AvailabilityAttr]: ... @overload @@ -16203,7 +16204,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssumptionAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssumptionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AssumptionAttr]: ... @overload @@ -16266,7 +16267,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssumeAlignedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssumeAlignedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AssumeAlignedAttr]: ... @overload @@ -16327,7 +16328,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssertSharedLockAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssertSharedLockAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AssertSharedLockAttr]: ... @overload @@ -16388,7 +16389,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssertExclusiveLock @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssertExclusiveLockAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AssertExclusiveLockAttr]: ... @overload @@ -16451,7 +16452,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssertCapabilityAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssertCapabilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AssertCapabilityAttr]: ... @overload @@ -16515,7 +16516,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AsmLabelAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AsmLabelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AsmLabelAttr]: ... @overload @@ -16576,7 +16577,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArtificialAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArtificialAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArtificialAttr]: ... @overload @@ -16639,7 +16640,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmNewAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmNewAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmNewAttr]: ... @overload @@ -16700,7 +16701,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmLocallyStreaming @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmLocallyStreamingAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmLocallyStreamingAttr]: ... @overload @@ -16761,7 +16762,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmBuiltinAliasAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmBuiltinAliasAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArmBuiltinAliasAttr]: ... @overload @@ -16824,7 +16825,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArgumentWithTypeTag @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArgumentWithTypeTagAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArgumentWithTypeTagAttr]: ... @overload @@ -16885,7 +16886,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArcWeakrefUnavailab @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArcWeakrefUnavailableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArcWeakrefUnavailableAttr]: ... @overload @@ -16946,7 +16947,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnyX86NoCfCheckAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnyX86NoCfCheckAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AnyX86NoCfCheckAttr]: ... @overload @@ -17007,7 +17008,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnyX86NoCallerSaved @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnyX86NoCallerSavedRegistersAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AnyX86NoCallerSavedRegistersAttr]: ... @overload @@ -17068,7 +17069,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnyX86InterruptAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnyX86InterruptAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AnyX86InterruptAttr]: ... @overload @@ -17129,7 +17130,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnalyzerNoReturnAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnalyzerNoReturnAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AnalyzerNoReturnAttr]: ... @overload @@ -17190,7 +17191,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlwaysDestroyAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlwaysDestroyAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AlwaysDestroyAttr]: ... @overload @@ -17251,7 +17252,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AllocSizeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AllocSizeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AllocSizeAttr]: ... @overload @@ -17312,7 +17313,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AllocAlignAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AllocAlignAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AllocAlignAttr]: ... @overload @@ -17385,7 +17386,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AlignedAttr]: ... @overload @@ -17446,7 +17447,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignNaturalAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignNaturalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AlignNaturalAttr]: ... @overload @@ -17507,7 +17508,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignMac68kAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignMac68kAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AlignMac68kAttr]: ... @overload @@ -17568,7 +17569,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquiredBeforeAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquiredBeforeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AcquiredBeforeAttr]: ... @overload @@ -17629,7 +17630,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquiredAfterAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquiredAfterAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AcquiredAfterAttr]: ... @overload @@ -17692,7 +17693,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquireHandleAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquireHandleAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AcquireHandleAttr]: ... @overload @@ -17755,7 +17756,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquireCapabilityAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquireCapabilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AcquireCapabilityAttr]: ... @overload @@ -17816,7 +17817,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AVRSignalAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AVRSignalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AVRSignalAttr]: ... @overload @@ -17877,7 +17878,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AVRInterruptAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AVRInterruptAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AVRInterruptAttr]: ... @overload @@ -17939,7 +17940,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ARMInterruptAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ARMInterruptAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ARMInterruptAttr]: ... @overload @@ -18002,7 +18003,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUWavesPerEUAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUWavesPerEUAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AMDGPUWavesPerEUAttr]: ... @overload @@ -18064,7 +18065,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUNumVGPRAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUNumVGPRAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AMDGPUNumVGPRAttr]: ... @overload @@ -18126,7 +18127,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUNumSGPRAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUNumSGPRAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AMDGPUNumSGPRAttr]: ... @overload @@ -18187,7 +18188,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUKernelCallAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUKernelCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AMDGPUKernelCallAttr]: ... @overload @@ -18250,7 +18251,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUFlatWorkGroup @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUFlatWorkGroupSizeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AMDGPUFlatWorkGroupSizeAttr]: ... @overload @@ -18311,7 +18312,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AArch64VectorPcsAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AArch64VectorPcsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AArch64VectorPcsAttr]: ... @overload @@ -18372,7 +18373,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AArch64SVEPcsAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AArch64SVEPcsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AArch64SVEPcsAttr]: ... @overload @@ -18434,7 +18435,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ZeroCallUsedRegsAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ZeroCallUsedRegsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ZeroCallUsedRegsAttr]: ... @overload @@ -18496,7 +18497,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.XRayLogArgsAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.XRayLogArgsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.XRayLogArgsAttr]: ... @overload @@ -18560,7 +18561,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.XRayInstrumentAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.XRayInstrumentAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.XRayInstrumentAttr]: ... @overload @@ -18621,7 +18622,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.X86ForceAlignArgPoi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.X86ForceAlignArgPointerAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.X86ForceAlignArgPointerAttr]: ... @overload @@ -18685,7 +18686,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WorkGroupSizeHintAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WorkGroupSizeHintAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WorkGroupSizeHintAttr]: ... @overload @@ -18748,7 +18749,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyImportNa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyImportNameAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WebAssemblyImportNameAttr]: ... @overload @@ -18811,7 +18812,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyImportMo @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyImportModuleAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WebAssemblyImportModuleAttr]: ... @overload @@ -18874,7 +18875,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyExportNa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyExportNameAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WebAssemblyExportNameAttr]: ... @overload @@ -18937,7 +18938,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WeakRefAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WeakRefAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WeakRefAttr]: ... @overload @@ -18998,7 +18999,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WeakImportAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WeakImportAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WeakImportAttr]: ... @overload @@ -19059,7 +19060,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WeakAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WeakAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WeakAttr]: ... @overload @@ -19124,7 +19125,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WarnUnusedResultAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WarnUnusedResultAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WarnUnusedResultAttr]: ... @overload @@ -19185,7 +19186,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WarnUnusedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WarnUnusedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WarnUnusedAttr]: ... @overload @@ -19247,7 +19248,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VisibilityAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VisibilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VisibilityAttr]: ... @overload @@ -19308,7 +19309,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VectorCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VectorCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VectorCallAttr]: ... @overload @@ -19371,7 +19372,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VecTypeHintAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VecTypeHintAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VecTypeHintAttr]: ... @overload @@ -19432,7 +19433,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VecReturnAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VecReturnAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VecReturnAttr]: ... @overload @@ -19496,7 +19497,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UuidAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UuidAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UuidAttr]: ... @overload @@ -19557,7 +19558,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingIfExistsAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingIfExistsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsingIfExistsAttr]: ... @overload @@ -19618,7 +19619,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsedAttr]: ... @overload @@ -19680,7 +19681,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnusedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnusedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnusedAttr]: ... @overload @@ -19741,7 +19742,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnsafeBufferUsageAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnsafeBufferUsageAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnsafeBufferUsageAttr]: ... @overload @@ -19802,7 +19803,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UninitializedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UninitializedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UninitializedAttr]: ... @overload @@ -19866,7 +19867,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnavailableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnavailableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnavailableAttr]: ... @overload @@ -19928,7 +19929,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeVisibilityAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeVisibilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeVisibilityAttr]: ... @overload @@ -19993,7 +19994,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeTagForDatatypeA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeTagForDatatypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeTagForDatatypeAttr]: ... @overload @@ -20057,7 +20058,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TryAcquireCapabilit @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TryAcquireCapabilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TryAcquireCapabilityAttr]: ... @overload @@ -20118,7 +20119,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TrivialABIAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TrivialABIAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TrivialABIAttr]: ... @overload @@ -20179,7 +20180,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TransparentUnionAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TransparentUnionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TransparentUnionAttr]: ... @overload @@ -20240,7 +20241,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ThisCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ThisCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ThisCallAttr]: ... @overload @@ -20302,7 +20303,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TestTypestateAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TestTypestateAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TestTypestateAttr]: ... @overload @@ -20367,7 +20368,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TargetVersionAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TargetVersionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TargetVersionAttr]: ... @overload @@ -20428,7 +20429,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TargetClonesAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TargetClonesAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TargetClonesAttr]: ... @overload @@ -20493,7 +20494,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TargetAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TargetAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TargetAttr]: ... @overload @@ -20556,7 +20557,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TLSModelAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TLSModelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TLSModelAttr]: ... @overload @@ -20617,7 +20618,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SysVABIAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SysVABIAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SysVABIAttr]: ... @overload @@ -20678,7 +20679,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftPrivateAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftPrivateAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftPrivateAttr]: ... @overload @@ -20741,7 +20742,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftNewTypeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftNewTypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftNewTypeAttr]: ... @overload @@ -20804,7 +20805,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftNameAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftNameAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftNameAttr]: ... @overload @@ -20865,7 +20866,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftImportProperty @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftImportPropertyAsAccessorsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftImportPropertyAsAccessorsAttr]: ... @overload @@ -20926,7 +20927,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftImportAsNonGen @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftImportAsNonGenericAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftImportAsNonGenericAttr]: ... @overload @@ -20988,7 +20989,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftErrorAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftErrorAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftErrorAttr]: ... @overload @@ -21049,7 +21050,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftCallAttr]: ... @overload @@ -21110,7 +21111,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftBridgedTypedef @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftBridgedTypedefAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftBridgedTypedefAttr]: ... @overload @@ -21173,7 +21174,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftBridgeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftBridgeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftBridgeAttr]: ... @overload @@ -21236,7 +21237,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAttrAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAttrAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftAttrAttr]: ... @overload @@ -21299,7 +21300,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncNameAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncNameAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftAsyncNameAttr]: ... @overload @@ -21362,7 +21363,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncErrorAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncErrorAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftAsyncErrorAttr]: ... @overload @@ -21423,7 +21424,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncCallAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftAsyncCallAttr]: ... @overload @@ -21485,7 +21486,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftAsyncAttr]: ... @overload @@ -21546,7 +21547,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StrictGuardStackChe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StrictGuardStackCheckAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StrictGuardStackCheckAttr]: ... @overload @@ -21607,7 +21608,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StrictFPAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StrictFPAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StrictFPAttr]: ... @overload @@ -21668,7 +21669,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StdCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StdCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StdCallAttr]: ... @overload @@ -21729,7 +21730,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StandaloneDebugAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StandaloneDebugAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StandaloneDebugAttr]: ... @overload @@ -21790,7 +21791,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SpeculativeLoadHard @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SpeculativeLoadHardeningAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SpeculativeLoadHardeningAttr]: ... @overload @@ -21852,7 +21853,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SharedTrylockFuncti @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SharedTrylockFunctionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SharedTrylockFunctionAttr]: ... @overload @@ -21914,7 +21915,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SetTypestateAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SetTypestateAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SetTypestateAttr]: ... @overload @@ -21975,7 +21976,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SentinelAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SentinelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SentinelAttr]: ... @overload @@ -22036,7 +22037,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SelectAnyAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SelectAnyAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SelectAnyAttr]: ... @overload @@ -22100,7 +22101,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SectionAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SectionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SectionAttr]: ... @overload @@ -22161,7 +22162,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ScopedLockableAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ScopedLockableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ScopedLockableAttr]: ... @overload @@ -22222,7 +22223,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SYCLSpecialClassAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SYCLSpecialClassAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SYCLSpecialClassAttr]: ... @overload @@ -22283,7 +22284,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SYCLKernelAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SYCLKernelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SYCLKernelAttr]: ... @overload @@ -22344,7 +22345,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnsTwiceAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnsTwiceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReturnsTwiceAttr]: ... @overload @@ -22405,7 +22406,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnsNonNullAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnsNonNullAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReturnsNonNullAttr]: ... @overload @@ -22467,7 +22468,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnTypestateAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnTypestateAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReturnTypestateAttr]: ... @overload @@ -22528,7 +22529,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RetainAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RetainAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RetainAttr]: ... @overload @@ -22590,7 +22591,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RestrictAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RestrictAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RestrictAttr]: ... @overload @@ -22653,7 +22654,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresCapabilityA @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RequiresCapabilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RequiresCapabilityAttr]: ... @overload @@ -22717,7 +22718,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReqdWorkGroupSizeAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReqdWorkGroupSizeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReqdWorkGroupSizeAttr]: ... @overload @@ -22781,7 +22782,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReleaseCapabilityAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReleaseCapabilityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReleaseCapabilityAttr]: ... @overload @@ -22842,7 +22843,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReinitializesAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReinitializesAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReinitializesAttr]: ... @overload @@ -22903,7 +22904,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RegCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RegCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RegCallAttr]: ... @overload @@ -22964,7 +22965,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReadOnlyPlacementAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReadOnlyPlacementAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReadOnlyPlacementAttr]: ... @overload @@ -23025,7 +23026,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RandomizeLayoutAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RandomizeLayoutAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RandomizeLayoutAttr]: ... @overload @@ -23087,7 +23088,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RISCVInterruptAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RISCVInterruptAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RISCVInterruptAttr]: ... @overload @@ -23148,7 +23149,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PureAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PureAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PureAttr]: ... @overload @@ -23209,7 +23210,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PtGuardedVarAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PtGuardedVarAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PtGuardedVarAttr]: ... @overload @@ -23271,7 +23272,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PtGuardedByAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PtGuardedByAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PtGuardedByAttr]: ... @overload @@ -23332,7 +23333,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreserveMostAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreserveMostAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PreserveMostAttr]: ... @overload @@ -23393,7 +23394,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreserveAllAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreserveAllAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PreserveAllAttr]: ... @overload @@ -23456,7 +23457,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreferredTypeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreferredTypeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PreferredTypeAttr]: ... @overload @@ -23519,7 +23520,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreferredNameAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreferredNameAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PreferredNameAttr]: ... @overload @@ -23582,7 +23583,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangTextSect @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangTextSectionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PragmaClangTextSectionAttr]: ... @overload @@ -23645,7 +23646,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangRodataSe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangRodataSectionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PragmaClangRodataSectionAttr]: ... @overload @@ -23708,7 +23709,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangRelroSec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangRelroSectionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PragmaClangRelroSectionAttr]: ... @overload @@ -23771,7 +23772,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangDataSect @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangDataSectionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PragmaClangDataSectionAttr]: ... @overload @@ -23834,7 +23835,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangBSSSecti @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangBSSSectionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PragmaClangBSSSectionAttr]: ... @overload @@ -23897,7 +23898,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PointerAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PointerAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PointerAttr]: ... @overload @@ -23959,7 +23960,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PcsAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PcsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PcsAttr]: ... @overload @@ -24021,7 +24022,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PatchableFunctionEn @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PatchableFunctionEntryAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PatchableFunctionEntryAttr]: ... @overload @@ -24082,7 +24083,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PascalAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PascalAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PascalAttr]: ... @overload @@ -24144,7 +24145,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParamTypestateAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParamTypestateAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ParamTypestateAttr]: ... @overload @@ -24205,7 +24206,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PackedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PackedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PackedAttr]: ... @overload @@ -24271,7 +24272,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OwnershipAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OwnershipAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OwnershipAttr]: ... @overload @@ -24334,7 +24335,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OwnerAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OwnerAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OwnerAttr]: ... @overload @@ -24395,7 +24396,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OverrideAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OverrideAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OverrideAttr]: ... @overload @@ -24456,7 +24457,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OptimizeNoneAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OptimizeNoneAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OptimizeNoneAttr]: ... @overload @@ -24517,7 +24518,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLKernelAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLKernelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLKernelAttr]: ... @overload @@ -24579,7 +24580,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLIntelReqdSubG @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLIntelReqdSubGroupSizeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpenCLIntelReqdSubGroupSizeAttr]: ... @overload @@ -24640,7 +24641,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSubclassingRest @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCSubclassingRestrictedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCSubclassingRestrictedAttr]: ... @overload @@ -24701,7 +24702,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRootClassAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRootClassAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCRootClassAttr]: ... @overload @@ -24762,7 +24763,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCReturnsInnerPoi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCReturnsInnerPointerAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCReturnsInnerPointerAttr]: ... @overload @@ -24823,7 +24824,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRequiresSuperAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRequiresSuperAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCRequiresSuperAttr]: ... @overload @@ -24884,7 +24885,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRequiresPropert @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRequiresPropertyDefsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCRequiresPropertyDefsAttr]: ... @overload @@ -24945,7 +24946,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPreciseLifetime @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPreciseLifetimeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCPreciseLifetimeAttr]: ... @overload @@ -25006,7 +25007,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCOwnershipAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCOwnershipAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCOwnershipAttr]: ... @overload @@ -25067,7 +25068,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCNSObjectAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCNSObjectAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCNSObjectAttr]: ... @overload @@ -25129,7 +25130,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMethodFamilyAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCMethodFamilyAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCMethodFamilyAttr]: ... @overload @@ -25190,7 +25191,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIndependentClas @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIndependentClassAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCIndependentClassAttr]: ... @overload @@ -25251,7 +25252,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCExternallyRetai @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCExternallyRetainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCExternallyRetainedAttr]: ... @overload @@ -25312,7 +25313,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCExplicitProtoco @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCExplicitProtocolImplAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCExplicitProtocolImplAttr]: ... @overload @@ -25373,7 +25374,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCExceptionAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCExceptionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCExceptionAttr]: ... @overload @@ -25434,7 +25435,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgeRelatedAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgeRelatedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCBridgeRelatedAttr]: ... @overload @@ -25495,7 +25496,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgeMutableAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgeMutableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCBridgeMutableAttr]: ... @overload @@ -25556,7 +25557,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCBridgeAttr]: ... @overload @@ -25617,7 +25618,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsRetainedOn @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsRetainedOnZeroAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OSReturnsRetainedOnZeroAttr]: ... @overload @@ -25678,7 +25679,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsRetainedOn @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsRetainedOnNonZeroAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OSReturnsRetainedOnNonZeroAttr]: ... @overload @@ -25739,7 +25740,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsRetainedAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsRetainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OSReturnsRetainedAttr]: ... @overload @@ -25800,7 +25801,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsNotRetaine @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsNotRetainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OSReturnsNotRetainedAttr]: ... @overload @@ -25861,7 +25862,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSConsumesThisAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSConsumesThisAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OSConsumesThisAttr]: ... @overload @@ -25922,7 +25923,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPThreadPrivateDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPThreadPrivateDeclAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPThreadPrivateDeclAttr]: ... @overload @@ -25984,7 +25985,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareVariantAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareVariantAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDeclareVariantAttr]: ... @overload @@ -26050,7 +26051,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareTargetDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareTargetDeclAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDeclareTargetDeclAttr]: ... @overload @@ -26111,7 +26112,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCaptureNoInitAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCaptureNoInitAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPCaptureNoInitAttr]: ... @overload @@ -26175,7 +26176,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAllocateDeclAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPAllocateDeclAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPAllocateDeclAttr]: ... @overload @@ -26236,7 +26237,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NotTailCalledAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NotTailCalledAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NotTailCalledAttr]: ... @overload @@ -26297,7 +26298,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoUwtableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoUwtableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoUwtableAttr]: ... @overload @@ -26358,7 +26359,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoUniqueAddressAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoUniqueAddressAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoUniqueAddressAttr]: ... @overload @@ -26419,7 +26420,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoThrowAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoThrowAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoThrowAttr]: ... @overload @@ -26480,7 +26481,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoThreadSafetyAnaly @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoThreadSafetyAnalysisAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoThreadSafetyAnalysisAttr]: ... @overload @@ -26542,7 +26543,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoStackProtectorAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoStackProtectorAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoStackProtectorAttr]: ... @overload @@ -26603,7 +26604,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoSplitStackAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoSplitStackAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoSplitStackAttr]: ... @overload @@ -26664,7 +26665,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoSpeculativeLoadHa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoSpeculativeLoadHardeningAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoSpeculativeLoadHardeningAttr]: ... @overload @@ -26726,7 +26727,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoSanitizeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoSanitizeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoSanitizeAttr]: ... @overload @@ -26787,7 +26788,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoReturnAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoReturnAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoReturnAttr]: ... @overload @@ -26848,7 +26849,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoRandomizeLayoutAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoRandomizeLayoutAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoRandomizeLayoutAttr]: ... @overload @@ -26909,7 +26910,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoProfileFunctionAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoProfileFunctionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoProfileFunctionAttr]: ... @overload @@ -26970,7 +26971,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoMips16Attr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoMips16Attr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoMips16Attr]: ... @overload @@ -27031,7 +27032,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoMicroMipsAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoMicroMipsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoMicroMipsAttr]: ... @overload @@ -27092,7 +27093,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoInstrumentFunctio @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoInstrumentFunctionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoInstrumentFunctionAttr]: ... @overload @@ -27153,7 +27154,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDuplicateAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDuplicateAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoDuplicateAttr]: ... @overload @@ -27214,7 +27215,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDestroyAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDestroyAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoDestroyAttr]: ... @overload @@ -27275,7 +27276,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDebugAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDebugAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoDebugAttr]: ... @overload @@ -27336,7 +27337,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoCommonAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoCommonAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoCommonAttr]: ... @overload @@ -27397,7 +27398,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoAliasAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoAliasAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoAliasAttr]: ... @overload @@ -27458,7 +27459,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NakedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NakedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NakedAttr]: ... @overload @@ -27519,7 +27520,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NVPTXKernelAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NVPTXKernelAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NVPTXKernelAttr]: ... @overload @@ -27580,7 +27581,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSReturnsRetainedAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSReturnsRetainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NSReturnsRetainedAttr]: ... @overload @@ -27641,7 +27642,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSReturnsNotRetaine @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSReturnsNotRetainedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NSReturnsNotRetainedAttr]: ... @overload @@ -27702,7 +27703,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSReturnsAutoreleas @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSReturnsAutoreleasedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NSReturnsAutoreleasedAttr]: ... @overload @@ -27763,7 +27764,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSErrorDomainAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSErrorDomainAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NSErrorDomainAttr]: ... @overload @@ -27824,7 +27825,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSConsumesSelfAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSConsumesSelfAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NSConsumesSelfAttr]: ... @overload @@ -27886,7 +27887,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MipsShortCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MipsShortCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MipsShortCallAttr]: ... @overload @@ -27948,7 +27949,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MipsLongCallAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MipsLongCallAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MipsLongCallAttr]: ... @overload @@ -28010,7 +28011,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MipsInterruptAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MipsInterruptAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MipsInterruptAttr]: ... @overload @@ -28071,7 +28072,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Mips16Attr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Mips16Attr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Mips16Attr]: ... @overload @@ -28133,7 +28134,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MinVectorWidthAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MinVectorWidthAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MinVectorWidthAttr]: ... @overload @@ -28194,7 +28195,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MinSizeAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MinSizeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MinSizeAttr]: ... @overload @@ -28255,7 +28256,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MicroMipsAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MicroMipsAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MicroMipsAttr]: ... @overload @@ -28316,7 +28317,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MaybeUndefAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MaybeUndefAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MaybeUndefAttr]: ... @overload @@ -28377,7 +28378,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MayAliasAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MayAliasAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MayAliasAttr]: ... @overload @@ -28439,7 +28440,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MaxFieldAlignmentAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MaxFieldAlignmentAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MaxFieldAlignmentAttr]: ... @overload @@ -28502,7 +28503,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSVtorDispAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSVtorDispAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSVtorDispAttr]: ... @overload @@ -28563,7 +28564,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSStructAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSStructAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSStructAttr]: ... @overload @@ -28625,7 +28626,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSP430InterruptAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSP430InterruptAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSP430InterruptAttr]: ... @overload @@ -28686,7 +28687,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSNoVTableAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSNoVTableAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSNoVTableAttr]: ... @overload @@ -28750,7 +28751,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSInheritanceAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSInheritanceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSInheritanceAttr]: ... @overload @@ -28811,7 +28812,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSConstexprAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSConstexprAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSConstexprAttr]: ... @overload @@ -28872,7 +28873,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSAllocatorAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSAllocatorAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSAllocatorAttr]: ... @overload @@ -28933,7 +28934,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSABIAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSABIAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSABIAttr]: ... @overload @@ -28994,7 +28995,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MIGServerRoutineAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MIGServerRoutineAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MIGServerRoutineAttr]: ... @overload @@ -29055,7 +29056,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.M68kRTDAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.M68kRTDAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.M68kRTDAttr]: ... @overload @@ -29117,7 +29118,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.M68kInterruptAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.M68kInterruptAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.M68kInterruptAttr]: ... @overload @@ -29178,7 +29179,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LocksExcludedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LocksExcludedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LocksExcludedAttr]: ... @overload @@ -29240,7 +29241,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LockReturnedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LockReturnedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LockReturnedAttr]: ... @overload @@ -29301,7 +29302,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LifetimeBoundAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LifetimeBoundAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LifetimeBoundAttr]: ... @overload @@ -29362,7 +29363,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LeafAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LeafAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LeafAttr]: ... @overload @@ -29424,7 +29425,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LayoutVersionAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LayoutVersionAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LayoutVersionAttr]: ... @overload @@ -29485,7 +29486,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LTOVisibilityPublic @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LTOVisibilityPublicAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LTOVisibilityPublicAttr]: ... @overload @@ -29546,7 +29547,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InternalLinkageAttr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InternalLinkageAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.InternalLinkageAttr]: ... @overload @@ -29607,7 +29608,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IntelOclBiccAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IntelOclBiccAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IntelOclBiccAttr]: ... @overload @@ -29669,7 +29670,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InitPriorityAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InitPriorityAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.InitPriorityAttr]: ... @overload @@ -29726,7 +29727,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InheritableParamAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InheritableParamAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.InheritableParamAttr]: ... @overload @@ -29787,7 +29788,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CarriesDependencyAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CarriesDependencyAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CarriesDependencyAttr]: ... @overload @@ -29848,7 +29849,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFConsumedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFConsumedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CFConsumedAttr]: ... @overload @@ -29911,7 +29912,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnnotateAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnnotateAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AnnotateAttr]: ... @overload @@ -29974,7 +29975,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UseHandleAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UseHandleAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UseHandleAttr]: ... @overload @@ -30037,7 +30038,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReleaseHandleAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReleaseHandleAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReleaseHandleAttr]: ... @overload @@ -30100,7 +30101,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PassObjectSizeAttr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PassObjectSizeAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PassObjectSizeAttr]: ... @overload @@ -30158,7 +30159,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParameterABIAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParameterABIAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ParameterABIAttr]: ... @overload @@ -30219,7 +30220,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftIndirectResult @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftIndirectResultAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftIndirectResultAttr]: ... @overload @@ -30280,7 +30281,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftErrorResultAtt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftErrorResultAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftErrorResultAttr]: ... @overload @@ -30341,7 +30342,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftContextAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftContextAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftContextAttr]: ... @overload @@ -30402,7 +30403,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncContextAt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncContextAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwiftAsyncContextAttr]: ... @overload @@ -30463,7 +30464,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSConsumedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSConsumedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OSConsumedAttr]: ... @overload @@ -30524,7 +30525,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NonNullAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NonNullAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NonNullAttr]: ... @overload @@ -30585,7 +30586,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSConsumedAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSConsumedAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NSConsumedAttr]: ... @overload @@ -30648,7 +30649,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IFuncAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IFuncAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IFuncAttr]: ... @overload @@ -30709,7 +30710,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CalledOnceAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CalledOnceAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CalledOnceAttr]: ... @overload @@ -30771,7 +30772,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinAliasAttr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinAliasAttr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BuiltinAliasAttr]: ... @overload @@ -30842,7 +30843,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Type]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Type]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Type]: ... @overload @@ -30897,7 +30898,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTypeParmTyp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateTypeParmType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateTypeParmType]: ... @overload @@ -30953,7 +30954,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateSpecializat @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateSpecializationType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateSpecializationType]: ... @overload @@ -31004,7 +31005,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TagType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TagType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TagType]: ... @overload @@ -31056,7 +31057,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecordType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RecordType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RecordType]: ... @overload @@ -31107,7 +31108,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EnumType]: ... @overload @@ -31163,7 +31164,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstTemplateTypePa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstTemplateTypeParmType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SubstTemplateTypeParmType]: ... @overload @@ -31218,7 +31219,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstTemplateTypePa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstTemplateTypeParmPackType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SubstTemplateTypeParmPackType]: ... @overload @@ -31268,7 +31269,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReferenceType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReferenceType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReferenceType]: ... @overload @@ -31319,7 +31320,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RValueReferenceType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RValueReferenceType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RValueReferenceType]: ... @overload @@ -31370,7 +31371,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LValueReferenceType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LValueReferenceType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LValueReferenceType]: ... @overload @@ -31456,7 +31457,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.QualifiedType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.QualifiedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.QualifiedType]: ... @overload @@ -31508,7 +31509,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PointerType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PointerType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PointerType]: ... @overload @@ -31561,7 +31562,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PipeType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PipeType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PipeType]: ... @overload @@ -31613,7 +31614,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParenType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ParenType]: ... @overload @@ -31665,7 +31666,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PackExpansionType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PackExpansionType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PackExpansionType]: ... @overload @@ -31717,7 +31718,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCTypeParamType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCTypeParamType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCTypeParamType]: ... @overload @@ -31788,7 +31789,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCObjectType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCObjectType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCObjectType]: ... @overload @@ -31842,7 +31843,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCInterfaceType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCInterfaceType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCInterfaceType]: ... @overload @@ -31912,7 +31913,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCObjectPointerTy @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCObjectPointerType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCObjectPointerType]: ... @overload @@ -31976,7 +31977,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MemberPointerType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MemberPointerType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MemberPointerType]: ... @overload @@ -32024,7 +32025,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MatrixType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MatrixType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MatrixType]: ... @overload @@ -32077,7 +32078,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentSizedMatri @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentSizedMatrixType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentSizedMatrixType]: ... @overload @@ -32128,7 +32129,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstantMatrixType] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstantMatrixType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConstantMatrixType]: ... @overload @@ -32181,7 +32182,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MacroQualifiedType] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MacroQualifiedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MacroQualifiedType]: ... @overload @@ -32235,7 +32236,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InjectedClassNameTy @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InjectedClassNameType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.InjectedClassNameType]: ... @overload @@ -32291,7 +32292,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FunctionType]: ... @overload @@ -32364,7 +32365,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionProtoType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionProtoType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FunctionProtoType]: ... @overload @@ -32421,7 +32422,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionNoProtoType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionNoProtoType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FunctionNoProtoType]: ... @overload @@ -32476,7 +32477,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentVectorType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentVectorType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentVectorType]: ... @overload @@ -32530,7 +32531,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentSizedExtVe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentSizedExtVectorType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentSizedExtVectorType]: ... @overload @@ -32584,7 +32585,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentBitIntType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentBitIntType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentBitIntType]: ... @overload @@ -32638,7 +32639,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentAddressSpa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentAddressSpaceType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentAddressSpaceType]: ... @overload @@ -32687,7 +32688,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeducedType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeducedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DeducedType]: ... @overload @@ -32737,7 +32738,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeducedTemplateSpec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeducedTemplateSpecializationType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DeducedTemplateSpecializationType]: ... @overload @@ -32794,7 +32795,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AutoType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AutoType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AutoType]: ... @overload @@ -32850,7 +32851,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DecltypeType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DecltypeType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DecltypeType]: ... @overload @@ -32902,7 +32903,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ComplexType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ComplexType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ComplexType]: ... @overload @@ -32960,7 +32961,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BuiltinType]: ... @overload @@ -33012,7 +33013,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockPointerType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlockPointerType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BlockPointerType]: ... @overload @@ -33065,7 +33066,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BitIntType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BitIntType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BitIntType]: ... @overload @@ -33118,7 +33119,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BTFTagAttributedTyp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BTFTagAttributedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BTFTagAttributedType]: ... @overload @@ -33179,7 +33180,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AttributedType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AttributedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AttributedType]: ... @overload @@ -33231,7 +33232,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AtomicType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AtomicType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AtomicType]: ... @overload @@ -33280,7 +33281,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArrayType]: ... @overload @@ -33335,7 +33336,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VariableArrayType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VariableArrayType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VariableArrayType]: ... @overload @@ -33386,7 +33387,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IncompleteArrayType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IncompleteArrayType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IncompleteArrayType]: ... @overload @@ -33441,7 +33442,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentSizedArray @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentSizedArrayType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentSizedArrayType]: ... @overload @@ -33493,7 +33494,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstantArrayType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstantArrayType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConstantArrayType]: ... @overload @@ -33546,7 +33547,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AdjustedType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AdjustedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AdjustedType]: ... @overload @@ -33597,7 +33598,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DecayedType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DecayedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DecayedType]: ... @overload @@ -33644,7 +33645,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeWithKeyword]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeWithKeyword]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeWithKeyword]: ... @overload @@ -33697,7 +33698,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ElaboratedType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ElaboratedType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ElaboratedType]: ... @overload @@ -33750,7 +33751,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentTemplateSp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentTemplateSpecializationType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentTemplateSpecializationType]: ... @overload @@ -33804,7 +33805,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentNameType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentNameType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentNameType]: ... @overload @@ -33857,7 +33858,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VectorType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VectorType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VectorType]: ... @overload @@ -33907,7 +33908,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExtVectorType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExtVectorType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExtVectorType]: ... @overload @@ -33961,7 +33962,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsingType]: ... @overload @@ -34013,7 +34014,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnresolvedUsingType]: ... @overload @@ -34067,7 +34068,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryTransformType] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnaryTransformType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnaryTransformType]: ... @overload @@ -34120,7 +34121,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypedefType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypedefType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypedefType]: ... @overload @@ -34173,7 +34174,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeOfType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeOfType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeOfType]: ... @overload @@ -34226,7 +34227,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeOfExprType]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeOfExprType]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeOfExprType]: ... @overload @@ -34338,7 +34339,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Stmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Stmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Stmt]: ... @overload @@ -34428,7 +34429,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHTryStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHTryStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SEHTryStmt]: ... @overload @@ -34513,7 +34514,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHLeaveStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHLeaveStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SEHLeaveStmt]: ... @overload @@ -34599,7 +34600,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHFinallyStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHFinallyStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SEHFinallyStmt]: ... @overload @@ -34686,7 +34687,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHExceptStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHExceptStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SEHExceptStmt]: ... @overload @@ -34773,7 +34774,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ReturnStmt]: ... @overload @@ -34862,7 +34863,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCForCollectionSt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCForCollectionStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCForCollectionStmt]: ... @overload @@ -34948,7 +34949,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAutoreleasePool @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]: ... @overload @@ -35037,7 +35038,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtTryStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtTryStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAtTryStmt]: ... @overload @@ -35126,7 +35127,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtThrowStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtThrowStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAtThrowStmt]: ... @overload @@ -35213,7 +35214,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtSynchronizedS @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]: ... @overload @@ -35299,7 +35300,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtFinallyStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtFinallyStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAtFinallyStmt]: ... @overload @@ -35388,7 +35389,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtCatchStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtCatchStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAtCatchStmt]: ... @overload @@ -35474,7 +35475,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPExecutableDirect @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPExecutableDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPExecutableDirective]: ... @overload @@ -35558,7 +35559,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPErrorDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPErrorDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPErrorDirective]: ... @overload @@ -35643,7 +35644,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDispatchDirectiv @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDispatchDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDispatchDirective]: ... @overload @@ -35727,7 +35728,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDepobjDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDepobjDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDepobjDirective]: ... @overload @@ -35811,7 +35812,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCriticalDirectiv @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCriticalDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPCriticalDirective]: ... @overload @@ -35895,7 +35896,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCancellationPoin @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCancellationPointDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPCancellationPointDirective]: ... @overload @@ -35979,7 +35980,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCancelDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCancelDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPCancelDirective]: ... @overload @@ -36063,7 +36064,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPBarrierDirective @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPBarrierDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPBarrierDirective]: ... @overload @@ -36157,7 +36158,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAtomicDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPAtomicDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPAtomicDirective]: ... @overload @@ -36241,7 +36242,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTeamsDirective]: ... @overload @@ -36325,7 +36326,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskyieldDirecti @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskyieldDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTaskyieldDirective]: ... @overload @@ -36409,7 +36410,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskwaitDirectiv @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskwaitDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTaskwaitDirective]: ... @overload @@ -36494,7 +36495,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskgroupDirecti @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskgroupDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTaskgroupDirective]: ... @overload @@ -36579,7 +36580,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTaskDirective]: ... @overload @@ -36663,7 +36664,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetUpdateDire @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetUpdateDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetUpdateDirective]: ... @overload @@ -36747,7 +36748,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDirec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetTeamsDirective]: ... @overload @@ -36833,7 +36834,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetParallelDirective]: ... @overload @@ -36917,7 +36918,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetExitDataDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetExitDataDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetExitDataDirective]: ... @overload @@ -37001,7 +37002,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetEnterDataD @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]: ... @overload @@ -37085,7 +37086,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetDirective]: ... @overload @@ -37169,7 +37170,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetDataDirect @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetDataDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetDataDirective]: ... @overload @@ -37253,7 +37254,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSingleDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSingleDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPSingleDirective]: ... @overload @@ -37339,7 +37340,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSectionsDirectiv @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSectionsDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPSectionsDirective]: ... @overload @@ -37424,7 +37425,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSectionDirective @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSectionDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPSectionDirective]: ... @overload @@ -37508,7 +37509,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPScopeDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPScopeDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPScopeDirective]: ... @overload @@ -37592,7 +37593,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPScanDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPScanDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPScanDirective]: ... @overload @@ -37678,7 +37679,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelSections @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelSectionsDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelSectionsDirective]: ... @overload @@ -37763,7 +37764,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMasterDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelMasterDirective]: ... @overload @@ -37848,7 +37849,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMaskedDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelMaskedDirective]: ... @overload @@ -37934,7 +37935,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelDirectiv @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelDirective]: ... @overload @@ -38018,7 +38019,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPOrderedDirective @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPOrderedDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPOrderedDirective]: ... @overload @@ -38103,7 +38104,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMetaDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMetaDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPMetaDirective]: ... @overload @@ -38187,7 +38188,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMasterDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPMasterDirective]: ... @overload @@ -38271,7 +38272,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMaskedDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPMaskedDirective]: ... @overload @@ -38352,7 +38353,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPLoopBasedDirecti @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPLoopBasedDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPLoopBasedDirective]: ... @overload @@ -38434,7 +38435,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPLoopTransformati @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPLoopTransformationDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPLoopTransformationDirective]: ... @overload @@ -38518,7 +38519,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPUnrollDirective] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPUnrollDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPUnrollDirective]: ... @overload @@ -38602,7 +38603,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTileDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTileDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTileDirective]: ... @overload @@ -38727,7 +38728,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPLoopDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPLoopDirective]: ... @overload @@ -38835,7 +38836,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPGenericLoopDirec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPGenericLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPGenericLoopDirective]: ... @overload @@ -38919,7 +38920,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPForSimdDirective @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPForSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPForSimdDirective]: ... @overload @@ -39005,7 +39006,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPForDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPForDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPForDirective]: ... @overload @@ -39089,7 +39090,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeSimdDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDistributeSimdDirective]: ... @overload @@ -39173,7 +39174,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeParall @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]: ... @overload @@ -39259,7 +39260,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeParall @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]: ... @overload @@ -39343,7 +39344,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeDirect @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDistributeDirective]: ... @overload @@ -39427,7 +39428,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsGenericLoop @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]: ... @overload @@ -39511,7 +39512,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeS @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]: ... @overload @@ -39595,7 +39596,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeP @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]: ... @overload @@ -39681,7 +39682,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeP @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]: ... @overload @@ -39765,7 +39766,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeD @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]: ... @overload @@ -39849,7 +39850,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskLoopSimdDire @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]: ... @overload @@ -39934,7 +39935,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskLoopDirectiv @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTaskLoopDirective]: ... @overload @@ -40018,7 +40019,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsGener @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]: ... @overload @@ -40102,7 +40103,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]: ... @overload @@ -40186,7 +40187,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]: ... @overload @@ -40272,7 +40273,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]: ... @overload @@ -40356,7 +40357,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]: ... @overload @@ -40440,7 +40441,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetSimdDirect @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetSimdDirective]: ... @overload @@ -40524,7 +40525,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelGe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]: ... @overload @@ -40608,7 +40609,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelFo @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]: ... @overload @@ -40694,7 +40695,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelFo @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelForDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPTargetParallelForDirective]: ... @overload @@ -40778,7 +40779,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSimdDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPSimdDirective]: ... @overload @@ -40862,7 +40863,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterTa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]: ... @overload @@ -40947,7 +40948,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterTa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]: ... @overload @@ -41031,7 +41032,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedTa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]: ... @overload @@ -41116,7 +41117,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedTa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]: ... @overload @@ -41200,7 +41201,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelGenericL @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]: ... @overload @@ -41284,7 +41285,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelForSimdD @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelForSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelForSimdDirective]: ... @overload @@ -41370,7 +41371,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelForDirec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelForDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPParallelForDirective]: ... @overload @@ -41454,7 +41455,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterTaskLoopSi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]: ... @overload @@ -41539,7 +41540,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterTaskLoopDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]: ... @overload @@ -41623,7 +41624,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedTaskLoopSi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]: ... @overload @@ -41708,7 +41709,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedTaskLoopDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]: ... @overload @@ -41792,7 +41793,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPInteropDirective @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPInteropDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPInteropDirective]: ... @overload @@ -41876,7 +41877,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPFlushDirective]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPFlushDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPFlushDirective]: ... @overload @@ -41964,7 +41965,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCanonicalLoop]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCanonicalLoop]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPCanonicalLoop]: ... @overload @@ -42050,7 +42051,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NullStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NullStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NullStmt]: ... @overload @@ -42138,7 +42139,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSDependentExistsSt @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSDependentExistsStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSDependentExistsStmt]: ... @overload @@ -42226,7 +42227,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IndirectGotoStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IndirectGotoStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IndirectGotoStmt]: ... @overload @@ -42330,7 +42331,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IfStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IfStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IfStmt]: ... @overload @@ -42417,7 +42418,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GotoStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GotoStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.GotoStmt]: ... @overload @@ -42510,7 +42511,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ForStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ForStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ForStmt]: ... @overload @@ -42599,7 +42600,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DoStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DoStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DoStmt]: ... @overload @@ -42687,7 +42688,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DeclStmt]: ... @overload @@ -42792,7 +42793,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroutineBodyStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroutineBodyStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoroutineBodyStmt]: ... @overload @@ -42883,7 +42884,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoreturnStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoreturnStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoreturnStmt]: ... @overload @@ -42968,7 +42969,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ContinueStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ContinueStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ContinueStmt]: ... @overload @@ -43057,7 +43058,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CompoundStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CompoundStmt]: ... @overload @@ -43145,7 +43146,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapturedStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CapturedStmt]: ... @overload @@ -43233,7 +43234,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTryStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXTryStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXTryStmt]: ... @overload @@ -43334,7 +43335,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXForRangeStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXForRangeStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXForRangeStmt]: ... @overload @@ -43422,7 +43423,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXCatchStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXCatchStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXCatchStmt]: ... @overload @@ -43507,7 +43508,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BreakStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BreakStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BreakStmt]: ... @overload @@ -43602,7 +43603,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AsmStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AsmStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AsmStmt]: ... @overload @@ -43704,7 +43705,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSAsmStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSAsmStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSAsmStmt]: ... @overload @@ -43807,7 +43808,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GCCAsmStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GCCAsmStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.GCCAsmStmt]: ... @overload @@ -43914,7 +43915,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WhileStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WhileStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.WhileStmt]: ... @overload @@ -43995,7 +43996,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ValueStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ValueStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ValueStmt]: ... @overload @@ -44084,7 +44085,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LabelStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LabelStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LabelStmt]: ... @overload @@ -44203,7 +44204,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Expr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Expr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Expr]: ... @overload @@ -44289,7 +44290,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DesignatedInitUpdat @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]: ... @overload @@ -44383,7 +44384,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DesignatedInitExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DesignatedInitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DesignatedInitExpr]: ... @overload @@ -44478,7 +44479,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentScopeDeclR @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]: ... @overload @@ -44565,7 +44566,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentCoawaitExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentCoawaitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DependentCoawaitExpr]: ... @overload @@ -44660,7 +44661,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclRefExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclRefExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DeclRefExpr]: ... @overload @@ -44747,7 +44748,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroutineSuspendExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroutineSuspendExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoroutineSuspendExpr]: ... @overload @@ -44832,7 +44833,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoawaitExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoawaitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoawaitExpr]: ... @overload @@ -44916,7 +44917,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoyieldExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoyieldExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CoyieldExpr]: ... @overload @@ -45003,7 +45004,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConvertVectorExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConvertVectorExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConvertVectorExpr]: ... @overload @@ -45095,7 +45096,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConceptSpecializati @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConceptSpecializationExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConceptSpecializationExpr]: ... @overload @@ -45185,7 +45186,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundLiteralExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CompoundLiteralExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CompoundLiteralExpr]: ... @overload @@ -45277,7 +45278,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ChooseExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ChooseExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ChooseExpr]: ... @overload @@ -45364,7 +45365,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CharacterLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CharacterLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CharacterLiteral]: ... @overload @@ -45452,7 +45453,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CastExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CastExpr]: ... @overload @@ -45537,7 +45538,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitCastExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ImplicitCastExpr]: ... @overload @@ -45618,7 +45619,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExplicitCastExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExplicitCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExplicitCastExpr]: ... @overload @@ -45702,7 +45703,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNamedCastExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNamedCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXNamedCastExpr]: ... @overload @@ -45787,7 +45788,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDynamicCastExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDynamicCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXDynamicCastExpr]: ... @overload @@ -45871,7 +45872,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstCastExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConstCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXConstCastExpr]: ... @overload @@ -45955,7 +45956,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXAddrspaceCastExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]: ... @overload @@ -46039,7 +46040,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXStaticCastExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXStaticCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXStaticCastExpr]: ... @overload @@ -46123,7 +46124,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXReinterpretCastE @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXReinterpretCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXReinterpretCastExpr]: ... @overload @@ -46210,7 +46211,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXFunctionalCastEx @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXFunctionalCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXFunctionalCastExpr]: ... @overload @@ -46296,7 +46297,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CStyleCastExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CStyleCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CStyleCastExpr]: ... @overload @@ -46380,7 +46381,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinBitCastExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinBitCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BuiltinBitCastExpr]: ... @overload @@ -46468,7 +46469,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgedCastExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgedCastExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCBridgedCastExpr]: ... @overload @@ -46569,7 +46570,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CallExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CallExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CallExpr]: ... @overload @@ -46661,7 +46662,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXOperatorCallExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXOperatorCallExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXOperatorCallExpr]: ... @overload @@ -46749,7 +46750,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXMemberCallExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXMemberCallExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXMemberCallExpr]: ... @overload @@ -46834,7 +46835,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAKernelCallExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAKernelCallExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CUDAKernelCallExpr]: ... @overload @@ -46921,7 +46922,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UserDefinedLiteral] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UserDefinedLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UserDefinedLiteral]: ... @overload @@ -47010,7 +47011,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXUuidofExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXUuidofExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXUuidofExpr]: ... @overload @@ -47100,7 +47101,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXUnresolvedConstr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]: ... @overload @@ -47193,7 +47194,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTypeidExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXTypeidExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXTypeidExpr]: ... @overload @@ -47280,7 +47281,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXThrowExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXThrowExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXThrowExpr]: ... @overload @@ -47366,7 +47367,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXThisExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXThisExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXThisExpr]: ... @overload @@ -47451,7 +47452,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXStdInitializerLi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXStdInitializerListExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXStdInitializerListExpr]: ... @overload @@ -47536,7 +47537,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXScalarValueInitE @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXScalarValueInitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXScalarValueInitExpr]: ... @overload @@ -47630,7 +47631,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXRewrittenBinaryO @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]: ... @overload @@ -47722,7 +47723,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXPseudoDestructor @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]: ... @overload @@ -47809,7 +47810,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXParenListInitExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXParenListInitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXParenListInitExpr]: ... @overload @@ -47894,7 +47895,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNullPtrLiteralEx @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]: ... @overload @@ -47980,7 +47981,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNoexceptExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNoexceptExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXNoexceptExpr]: ... @overload @@ -48081,7 +48082,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNewExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNewExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXNewExpr]: ... @overload @@ -48173,7 +48174,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXInheritedCtorIni @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]: ... @overload @@ -48268,7 +48269,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXFoldExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXFoldExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXFoldExpr]: ... @overload @@ -48364,7 +48365,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDependentScopeMe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]: ... @overload @@ -48455,7 +48456,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDeleteExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDeleteExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXDeleteExpr]: ... @overload @@ -48544,7 +48545,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDefaultInitExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDefaultInitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXDefaultInitExpr]: ... @overload @@ -48633,7 +48634,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDefaultArgExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDefaultArgExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXDefaultArgExpr]: ... @overload @@ -48729,7 +48730,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstructExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConstructExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXConstructExpr]: ... @overload @@ -48816,7 +48817,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTemporaryObjectE @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]: ... @overload @@ -48902,7 +48903,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBoolLiteralExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXBoolLiteralExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXBoolLiteralExpr]: ... @overload @@ -48987,7 +48988,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBindTemporaryExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXBindTemporaryExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXBindTemporaryExpr]: ... @overload @@ -49075,7 +49076,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlockExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BlockExpr]: ... @overload @@ -49178,7 +49179,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BinaryOperator]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BinaryOperator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BinaryOperator]: ... @overload @@ -49264,7 +49265,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundAssignOpera @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CompoundAssignOperator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CompoundAssignOperator]: ... @overload @@ -49365,7 +49366,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AtomicExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AtomicExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AtomicExpr]: ... @overload @@ -49455,7 +49456,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AsTypeExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AsTypeExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AsTypeExpr]: ... @overload @@ -49543,7 +49544,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayTypeTraitExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayTypeTraitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArrayTypeTraitExpr]: ... @overload @@ -49632,7 +49633,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArraySubscriptExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArraySubscriptExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArraySubscriptExpr]: ... @overload @@ -49718,7 +49719,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayInitLoopExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayInitLoopExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArrayInitLoopExpr]: ... @overload @@ -49802,7 +49803,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayInitIndexExpr] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayInitIndexExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ArrayInitIndexExpr]: ... @overload @@ -49889,7 +49890,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AddrLabelExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AddrLabelExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AddrLabelExpr]: ... @overload @@ -49974,7 +49975,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AbstractConditional @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AbstractConditionalOperator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AbstractConditionalOperator]: ... @overload @@ -50060,7 +50061,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConditionalOperator @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConditionalOperator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConditionalOperator]: ... @overload @@ -50146,7 +50147,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BinaryConditionalOp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BinaryConditionalOperator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BinaryConditionalOperator]: ... @overload @@ -50234,7 +50235,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VAArgExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VAArgExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VAArgExpr]: ... @overload @@ -50329,7 +50330,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryOperator]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnaryOperator]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnaryOperator]: ... @overload @@ -50420,7 +50421,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryExprOrTypeTrai @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]: ... @overload @@ -50504,7 +50505,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypoExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypoExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypoExpr]: ... @overload @@ -50592,7 +50593,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeTraitExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeTraitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeTraitExpr]: ... @overload @@ -50683,7 +50684,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstNonTypeTemplat @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]: ... @overload @@ -50775,7 +50776,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstNonTypeTemplat @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]: ... @overload @@ -50875,7 +50876,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StringLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StringLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StringLiteral]: ... @overload @@ -50963,7 +50964,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StmtExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StmtExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StmtExpr]: ... @overload @@ -51051,7 +51052,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SourceLocExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SourceLocExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SourceLocExpr]: ... @overload @@ -51142,7 +51143,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SizeOfPackExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SizeOfPackExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SizeOfPackExpr]: ... @overload @@ -51228,7 +51229,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ShuffleVectorExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ShuffleVectorExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ShuffleVectorExpr]: ... @overload @@ -51316,7 +51317,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SYCLUniqueStableNam @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]: ... @overload @@ -51407,7 +51408,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RequiresExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RequiresExpr]: ... @overload @@ -51496,7 +51497,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecoveryExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RecoveryExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RecoveryExpr]: ... @overload @@ -51590,7 +51591,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PseudoObjectExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PseudoObjectExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PseudoObjectExpr]: ... @overload @@ -51685,7 +51686,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PredefinedExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PredefinedExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PredefinedExpr]: ... @overload @@ -51773,7 +51774,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenListExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParenListExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ParenListExpr]: ... @overload @@ -51863,7 +51864,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParenExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ParenExpr]: ... @overload @@ -51949,7 +51950,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PackExpansionExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PackExpansionExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PackExpansionExpr]: ... @overload @@ -52038,7 +52039,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OverloadExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OverloadExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OverloadExpr]: ... @overload @@ -52131,7 +52132,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedMemberExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedMemberExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnresolvedMemberExpr]: ... @overload @@ -52217,7 +52218,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedLookupExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedLookupExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnresolvedLookupExpr]: ... @overload @@ -52304,7 +52305,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpaqueValueExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpaqueValueExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OpaqueValueExpr]: ... @overload @@ -52390,7 +52391,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OffsetOfExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OffsetOfExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OffsetOfExpr]: ... @overload @@ -52479,7 +52480,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSubscriptRefExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]: ... @overload @@ -52565,7 +52566,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCStringLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCStringLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCStringLiteral]: ... @overload @@ -52651,7 +52652,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSelectorExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCSelectorExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCSelectorExpr]: ... @overload @@ -52739,7 +52740,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCProtocolExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCProtocolExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCProtocolExpr]: ... @overload @@ -52839,7 +52840,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyRefExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPropertyRefExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCPropertyRefExpr]: ... @overload @@ -52945,7 +52946,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMessageExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCMessageExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCMessageExpr]: ... @overload @@ -53041,7 +53042,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIvarRefExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIvarRefExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCIvarRefExpr]: ... @overload @@ -53130,7 +53131,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIsaExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIsaExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCIsaExpr]: ... @overload @@ -53216,7 +53217,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIndirectCopyRes @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]: ... @overload @@ -53303,7 +53304,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCEncodeExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCEncodeExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCEncodeExpr]: ... @overload @@ -53388,7 +53389,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDictionaryLiter @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDictionaryLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCDictionaryLiteral]: ... @overload @@ -53476,7 +53477,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoxedExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBoxedExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCBoxedExpr]: ... @overload @@ -53562,7 +53563,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoolLiteralExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]: ... @overload @@ -53647,7 +53648,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAvailabilityChe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]: ... @overload @@ -53734,7 +53735,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCArrayLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCArrayLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCArrayLiteral]: ... @overload @@ -53824,7 +53825,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPIteratorExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPIteratorExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPIteratorExpr]: ... @overload @@ -53913,7 +53914,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPArrayShapingExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPArrayShapingExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPArrayShapingExpr]: ... @overload @@ -54007,7 +54008,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPArraySectionExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPArraySectionExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPArraySectionExpr]: ... @overload @@ -54091,7 +54092,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoInitExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoInitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NoInitExpr]: ... @overload @@ -54189,7 +54190,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MemberExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MemberExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MemberExpr]: ... @overload @@ -54278,7 +54279,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MatrixSubscriptExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MatrixSubscriptExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MatrixSubscriptExpr]: ... @overload @@ -54369,7 +54370,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MaterializeTemporar @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MaterializeTemporaryExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MaterializeTemporaryExpr]: ... @overload @@ -54456,7 +54457,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertySubscript @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSPropertySubscriptExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSPropertySubscriptExpr]: ... @overload @@ -54545,7 +54546,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertyRefExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSPropertyRefExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSPropertyRefExpr]: ... @overload @@ -54645,7 +54646,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LambdaExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LambdaExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LambdaExpr]: ... @overload @@ -54733,7 +54734,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IntegerLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IntegerLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IntegerLiteral]: ... @overload @@ -54833,7 +54834,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InitListExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InitListExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.InitListExpr]: ... @overload @@ -54920,7 +54921,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitValueInitEx @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitValueInitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ImplicitValueInitExpr]: ... @overload @@ -55005,7 +55006,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImaginaryLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImaginaryLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ImaginaryLiteral]: ... @overload @@ -55101,7 +55102,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GenericSelectionExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GenericSelectionExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.GenericSelectionExpr]: ... @overload @@ -55189,7 +55190,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GNUNullExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GNUNullExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.GNUNullExpr]: ... @overload @@ -55277,7 +55278,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionParmPackExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionParmPackExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FunctionParmPackExpr]: ... @overload @@ -55361,7 +55362,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FullExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FullExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FullExpr]: ... @overload @@ -55446,7 +55447,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExprWithCleanups]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExprWithCleanups]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExprWithCleanups]: ... @overload @@ -55533,7 +55534,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstantExpr]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstantExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConstantExpr]: ... @overload @@ -55619,7 +55620,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FloatingLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FloatingLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FloatingLiteral]: ... @overload @@ -55705,7 +55706,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FixedPointLiteral]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FixedPointLiteral]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FixedPointLiteral]: ... @overload @@ -55793,7 +55794,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExtVectorElementExp @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExtVectorElementExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExtVectorElementExpr]: ... @overload @@ -55880,7 +55881,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExpressionTraitExpr @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExpressionTraitExpr]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExpressionTraitExpr]: ... @overload @@ -55968,7 +55969,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AttributedStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AttributedStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AttributedStmt]: ... @overload @@ -56067,7 +56068,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwitchStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwitchStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwitchStmt]: ... @overload @@ -56151,7 +56152,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwitchCase]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwitchCase]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.SwitchCase]: ... @overload @@ -56236,7 +56237,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DefaultStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DefaultStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DefaultStmt]: ... @overload @@ -56325,7 +56326,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CaseStmt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CaseStmt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CaseStmt]: ... @overload @@ -56468,7 +56469,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Decl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Decl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.Decl]: ... @overload @@ -56564,7 +56565,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapturedDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CapturedDecl]: ... @overload @@ -56671,7 +56672,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlockDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BlockDecl]: ... @overload @@ -56766,7 +56767,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AccessSpecDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AccessSpecDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.AccessSpecDecl]: ... @overload @@ -56849,7 +56850,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclarativeDirec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]: ... @overload @@ -56938,7 +56939,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPThreadPrivateDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPThreadPrivateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPThreadPrivateDecl]: ... @overload @@ -57028,7 +57029,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPRequiresDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPRequiresDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPRequiresDecl]: ... @overload @@ -57117,7 +57118,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAllocateDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPAllocateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPAllocateDecl]: ... @overload @@ -57208,7 +57209,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TranslationUnitDecl @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TranslationUnitDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TranslationUnitDecl]: ... @overload @@ -57297,7 +57298,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TopLevelStmtDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TopLevelStmtDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TopLevelStmtDecl]: ... @overload @@ -57388,7 +57389,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StaticAssertDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StaticAssertDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.StaticAssertDecl]: ... @overload @@ -57476,7 +57477,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresExprBodyDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RequiresExprBodyDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RequiresExprBodyDecl]: ... @overload @@ -57565,7 +57566,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaDetectMismatc @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]: ... @overload @@ -57654,7 +57655,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaCommentDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaCommentDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.PragmaCommentDecl]: ... @overload @@ -57750,7 +57751,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyImplDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPropertyImplDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCPropertyImplDecl]: ... @overload @@ -57846,7 +57847,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamedDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NamedDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NamedDecl]: ... @overload @@ -57941,7 +57942,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LabelDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LabelDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LabelDecl]: ... @overload @@ -58032,7 +58033,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLBufferDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLBufferDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.HLSLBufferDecl]: ... @overload @@ -58117,7 +58118,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BaseUsingDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BaseUsingDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BaseUsingDecl]: ... @overload @@ -58211,7 +58212,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingEnumDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingEnumDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsingEnumDecl]: ... @overload @@ -58301,7 +58302,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsingDecl]: ... @overload @@ -58388,7 +58389,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ValueDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ValueDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ValueDecl]: ... @overload @@ -58479,7 +58480,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingValu @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]: ... @overload @@ -58566,7 +58567,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnnamedGlobalConsta @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]: ... @overload @@ -58653,7 +58654,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateParamObject @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateParamObjectDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateParamObjectDecl]: ... @overload @@ -58748,7 +58749,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareReduction @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareReductionDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDeclareReductionDecl]: ... @overload @@ -58835,7 +58836,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSGuidDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSGuidDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSGuidDecl]: ... @overload @@ -58926,7 +58927,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IndirectFieldDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IndirectFieldDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.IndirectFieldDecl]: ... @overload @@ -59014,7 +59015,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumConstantDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumConstantDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EnumConstantDecl]: ... @overload @@ -59104,7 +59105,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclaratorDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclaratorDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DeclaratorDecl]: ... @overload @@ -59237,7 +59238,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VarDecl]: ... @overload @@ -59340,7 +59341,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParmVarDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParmVarDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ParmVarDecl]: ... @overload @@ -59427,7 +59428,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCapturedExprDecl @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCapturedExprDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPCapturedExprDecl]: ... @overload @@ -59515,7 +59516,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitParamDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitParamDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ImplicitParamDecl]: ... @overload @@ -59604,7 +59605,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DecompositionDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DecompositionDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.DecompositionDecl]: ... @overload @@ -59703,7 +59704,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplateSpeciali @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]: ... @overload @@ -59795,7 +59796,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplatePartialS @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]: ... @overload @@ -59892,7 +59893,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NonTypeTemplateParm @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]: ... @overload @@ -59984,7 +59985,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertyDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSPropertyDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.MSPropertyDecl]: ... @overload @@ -60156,7 +60157,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FunctionDecl]: ... @overload @@ -60268,7 +60269,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXMethodDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXMethodDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXMethodDecl]: ... @overload @@ -60360,7 +60361,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDestructorDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDestructorDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXDestructorDecl]: ... @overload @@ -60450,7 +60451,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConversionDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConversionDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXConversionDecl]: ... @overload @@ -60545,7 +60546,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstructorDecl] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConstructorDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXConstructorDecl]: ... @overload @@ -60639,7 +60640,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDeductionGuideDe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDeductionGuideDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXDeductionGuideDecl]: ... @overload @@ -60742,7 +60743,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FieldDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FieldDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FieldDecl]: ... @overload @@ -60834,7 +60835,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIvarDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIvarDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCIvarDecl]: ... @overload @@ -60921,7 +60922,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]: ... @overload @@ -61011,7 +61012,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BindingDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BindingDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BindingDecl]: ... @overload @@ -61094,7 +61095,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclarativeDirec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]: ... @overload @@ -61183,7 +61184,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareMapperDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareMapperDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.OMPDeclareMapperDecl]: ... @overload @@ -61273,7 +61274,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingShadowDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingShadowDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsingShadowDecl]: ... @overload @@ -61365,7 +61366,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstructorUsingSha @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]: ... @overload @@ -61454,7 +61455,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingPackDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingPackDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsingPackDecl]: ... @overload @@ -61549,7 +61550,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingDirectiveDecl] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingDirectiveDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UsingDirectiveDecl]: ... @overload @@ -61636,7 +61637,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingIfEx @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]: ... @overload @@ -61720,7 +61721,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeDecl]: ... @overload @@ -61818,7 +61819,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTypeParmDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateTypeParmDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateTypeParmDecl]: ... @overload @@ -61923,7 +61924,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TagDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TagDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TagDecl]: ... @overload @@ -62039,7 +62040,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecordDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RecordDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RecordDecl]: ... @overload @@ -62254,7 +62255,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXRecordDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXRecordDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.CXXRecordDecl]: ... @overload @@ -62353,7 +62354,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplateSpecia @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]: ... @overload @@ -62446,7 +62447,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplatePartia @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]: ... @overload @@ -62545,7 +62546,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EnumDecl]: ... @overload @@ -62639,7 +62640,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingType @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]: ... @overload @@ -62726,7 +62727,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypedefNameDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypedefNameDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypedefNameDecl]: ... @overload @@ -62813,7 +62814,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypedefDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypedefDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypedefDecl]: ... @overload @@ -62901,7 +62902,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAliasDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeAliasDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeAliasDecl]: ... @overload @@ -62993,7 +62994,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCTypeParamDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCTypeParamDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCTypeParamDecl]: ... @overload @@ -63080,7 +63081,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateDecl]: ... @overload @@ -63164,7 +63165,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RedeclarableTemplat @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RedeclarableTemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.RedeclarableTemplateDecl]: ... @overload @@ -63253,7 +63254,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionTemplateDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionTemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FunctionTemplateDecl]: ... @overload @@ -63341,7 +63342,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplateDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ClassTemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ClassTemplateDecl]: ... @overload @@ -63429,7 +63430,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplateDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarTemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.VarTemplateDecl]: ... @overload @@ -63516,7 +63517,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAliasTemplateDe @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeAliasTemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TypeAliasTemplateDecl]: ... @overload @@ -63605,7 +63606,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConceptDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConceptDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ConceptDecl]: ... @overload @@ -63692,7 +63693,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinTemplateDecl @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinTemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.BuiltinTemplateDecl]: ... @overload @@ -63784,7 +63785,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTemplatePar @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateTemplateParmDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.TemplateTemplateParmDecl]: ... @overload @@ -63889,7 +63890,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPropertyDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCPropertyDecl]: ... @overload @@ -64010,7 +64011,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMethodDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCMethodDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCMethodDecl]: ... @overload @@ -64114,7 +64115,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCContainerDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCContainerDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCContainerDecl]: ... @overload @@ -64232,7 +64233,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCategoryDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCCategoryDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCCategoryDecl]: ... @overload @@ -64336,7 +64337,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCProtocolDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCProtocolDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCProtocolDecl]: ... @overload @@ -64459,7 +64460,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCInterfaceDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCInterfaceDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCInterfaceDecl]: ... @overload @@ -64569,7 +64570,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCImplDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCImplDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCImplDecl]: ... @overload @@ -64661,7 +64662,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCategoryImplDec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCCategoryImplDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCCategoryImplDecl]: ... @overload @@ -64759,7 +64760,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCImplementationD @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCImplementationDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCImplementationDecl]: ... @overload @@ -64853,7 +64854,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCompatibleAlias @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]: ... @overload @@ -64945,7 +64946,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamespaceDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NamespaceDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NamespaceDecl]: ... @overload @@ -65037,7 +65038,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamespaceAliasDecl] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NamespaceAliasDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.NamespaceAliasDecl]: ... @overload @@ -65129,7 +65130,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LinkageSpecDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LinkageSpecDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LinkageSpecDecl]: ... @overload @@ -65221,7 +65222,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LifetimeExtendedTem @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]: ... @overload @@ -65310,7 +65311,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImportDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImportDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ImportDecl]: ... @overload @@ -65402,7 +65403,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitConceptSpec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]: ... @overload @@ -65497,7 +65498,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FriendTemplateDecl] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FriendTemplateDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FriendTemplateDecl]: ... @overload @@ -65594,7 +65595,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FriendDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FriendDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FriendDecl]: ... @overload @@ -65687,7 +65688,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FileScopeAsmDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FileScopeAsmDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.FileScopeAsmDecl]: ... @overload @@ -65775,7 +65776,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExternCContextDecl] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExternCContextDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExternCContextDecl]: ... @overload @@ -65866,7 +65867,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExportDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExportDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.ExportDecl]: ... @overload @@ -65953,7 +65954,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EmptyDecl]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EmptyDecl]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.ast.EmptyDecl]: ... @overload diff --git a/bindings/Python/multiplier-stubs/frontend/__init__.py b/bindings/Python/multiplier-stubs/frontend/__init__.py index c419f8ff1..d8265d9c7 100644 --- a/bindings/Python/multiplier-stubs/frontend/__init__.py +++ b/bindings/Python/multiplier-stubs/frontend/__init__.py @@ -12,6 +12,7 @@ from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple import pathlib import multiplier +import multiplier.ir import multiplier.ast import multiplier.frontend @@ -726,7 +727,7 @@ def containing(arg_0: multiplier.frontend.Macro) -> multiplier.frontend.Compilat @overload @staticmethod - def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.Compilation]: + def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.Compilation]: ... @staticmethod @@ -747,7 +748,7 @@ class Token(multiplier.Entity): containing_macro: Optional[multiplier.frontend.Macro] @staticmethod - def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.Token]: + def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.Token]: ... @staticmethod @@ -755,7 +756,7 @@ def entity_category() -> multiplier.EntityCategory: ... @staticmethod - def categorize(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> multiplier.frontend.TokenCategory: + def categorize(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> multiplier.frontend.TokenCategory: ... def location(self, arg_0: multiplier.frontend.FileLocationCache) -> Optional[Tuple[int, int]]: @@ -916,11 +917,11 @@ def containing(tokens: multiplier.frontend.TokenTree) -> Optional[multiplier.fro @overload @staticmethod - def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.File]: + def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.File]: ... @staticmethod - def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.File]: + def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.File]: ... @staticmethod @@ -1006,7 +1007,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.Macro]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.Macro]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.Macro]: ... @overload @@ -1075,7 +1076,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroSubstitut @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroSubstitution]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroSubstitution]: ... @overload @@ -1140,7 +1141,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroConcatena @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroConcatenate]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroConcatenate]: ... @overload @@ -1205,7 +1206,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroStringify @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroStringify]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroStringify]: ... @overload @@ -1273,7 +1274,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroExpansion @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroExpansion]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroExpansion]: ... @overload @@ -1342,7 +1343,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroParameter @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroParameterSubstitution]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroParameterSubstitution]: ... @overload @@ -1407,7 +1408,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroVAOpt]: @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroVAOpt]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroVAOpt]: ... @overload @@ -1471,7 +1472,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroVAOptArgu @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroVAOptArgument]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroVAOptArgument]: ... @overload @@ -1537,7 +1538,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroArgument] @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroArgument]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroArgument]: ... @overload @@ -1604,7 +1605,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroParameter @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroParameter]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroParameter]: ... @overload @@ -1666,7 +1667,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroDirective @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.MacroDirective]: ... @overload @@ -1737,7 +1738,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.DefineMacroDir @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.DefineMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.DefineMacroDirective]: ... @overload @@ -1801,7 +1802,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.PragmaMacroDir @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.PragmaMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.PragmaMacroDirective]: ... @overload @@ -1865,7 +1866,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.UndefineMacroD @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.UndefineMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.UndefineMacroDirective]: ... @overload @@ -1929,7 +1930,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.OtherMacroDire @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.OtherMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.OtherMacroDirective]: ... @overload @@ -1989,7 +1990,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ConditionalMac @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ConditionalMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.ConditionalMacroDirective]: ... @overload @@ -2053,7 +2054,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.EndIfMacroDire @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.EndIfMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.EndIfMacroDirective]: ... @overload @@ -2117,7 +2118,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseMacroDirec @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.ElseMacroDirective]: ... @overload @@ -2181,7 +2182,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseIfNotDefin @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseIfNotDefinedMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.ElseIfNotDefinedMacroDirective]: ... @overload @@ -2245,7 +2246,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseIfDefinedM @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseIfDefinedMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.ElseIfDefinedMacroDirective]: ... @overload @@ -2309,7 +2310,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseIfMacroDir @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseIfMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.ElseIfMacroDirective]: ... @overload @@ -2373,7 +2374,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IfNotDefinedMa @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IfNotDefinedMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.IfNotDefinedMacroDirective]: ... @overload @@ -2437,7 +2438,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IfDefinedMacro @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IfDefinedMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.IfDefinedMacroDirective]: ... @overload @@ -2501,7 +2502,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IfMacroDirecti @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IfMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.IfMacroDirective]: ... @overload @@ -2562,7 +2563,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeLikeMac @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeLikeMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.IncludeLikeMacroDirective]: ... @overload @@ -2626,7 +2627,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ImportMacroDir @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ImportMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.ImportMacroDirective]: ... @overload @@ -2690,7 +2691,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeMacrosM @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeMacrosMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.IncludeMacrosMacroDirective]: ... @overload @@ -2754,7 +2755,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeNextMac @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeNextMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.IncludeNextMacroDirective]: ... @overload @@ -2818,7 +2819,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeMacroDi @overload @staticmethod - def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeMacroDirective]: + def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.IRFunction | multiplier.ir.IRBlock | multiplier.ir.IRInstruction | multiplier.ir.IRObject]) -> Optional[multiplier.frontend.IncludeMacroDirective]: ... @overload diff --git a/bindings/Python/multiplier-stubs/ir/__init__.py b/bindings/Python/multiplier-stubs/ir/__init__.py new file mode 100644 index 000000000..c7af92338 --- /dev/null +++ b/bindings/Python/multiplier-stubs/ir/__init__.py @@ -0,0 +1,131 @@ +# +# Copyright (c) 2023-present, Trail of Bits, Inc. +# +# This source code is licensed in accordance with the terms specified in +# the LICENSE file found in the root directory of this source tree. +# + +# Auto-generated file; do not modify! + +from abc import ABC +from enum import IntEnum +from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple +import pathlib +import multiplier +import multiplier.ir +import multiplier.ast +import multiplier.frontend + +class OpCode(IntEnum): + CONST = 0 + ALLOCA = 1 + MEMORY = 2 + GEP_FIELD = 3 + PTR_ADD = 4 + ADD = 5 + SUB = 6 + MUL = 7 + DIV = 8 + REM = 9 + BIT_AND = 10 + BIT_OR = 11 + BIT_XOR = 12 + SHL = 13 + SHR = 14 + LOGICAL_AND = 15 + LOGICAL_OR = 16 + PTR_DIFF = 17 + CMP_EQ = 18 + CMP_NE = 19 + CMP_LT = 20 + CMP_LE = 21 + CMP_GT = 22 + CMP_GE = 23 + NEG = 24 + BIT_NOT = 25 + LOGICAL_NOT = 26 + CAST = 27 + CALL = 28 + READ_MODIFY_WRITE = 29 + SELECT = 30 + COND_BRANCH = 31 + SWITCH = 32 + RET = 33 + UNREACHABLE = 34 + BREAK = 35 + CONTINUE = 36 + GOTO = 37 + IMPLICIT_GOTO = 38 + FALLTHROUGH = 39 + IMPLICIT_FALLTHROUGH = 40 + IMPLICIT_UNREACHABLE = 41 + VA_PACK = 42 + VA_START = 43 + VA_ARG = 44 + VA_COPY = 45 + VA_END = 46 + ENTER_SCOPE = 47 + EXIT_SCOPE = 48 + PARAM_READ = 49 + GLOBAL_PTR = 50 + THREAD_LOCAL_PTR = 51 + FUNC_PTR = 52 + BITWISE = 53 + FLOAT = 54 + UNDEFINED = 55 + DYNAMIC_ALLOCA = 56 + FRAME_PTR = 57 + RETURN_PTR = 58 + ADD_OVERFLOW = 59 + SUB_OVERFLOW = 60 + MUL_OVERFLOW = 61 + ATOMIC_ADD = 62 + ATOMIC_SUB = 63 + ATOMIC_AND = 64 + ATOMIC_OR = 65 + ATOMIC_XOR = 66 + ATOMIC_NAND = 67 + ATOMIC_EXCHANGE = 68 + LAST_VALUE = 69 + UNKNOWN = 70 + +class ObjectKind(IntEnum): + LOCAL = 0 + LOCAL_VALUE = 1 + PARAMETER = 2 + PARAMETER_VALUE = 3 + GLOBAL = 4 + THREAD_LOCAL = 5 + STRING_LITERAL = 6 + COMPOUND_LITERAL = 7 + RETURN_SLOT = 8 + ALLOCA = 9 + HEAP = 10 + +class BlockKind(IntEnum): + ENTRY = 0 + IF_THEN = 1 + IF_ELSE = 2 + IF_MERGE = 3 + LOOP_CONDITION = 4 + LOOP_BODY = 5 + LOOP_EXIT = 6 + LOOP_INCREMENT = 7 + SWITCH_CASE = 8 + SWITCH_DEFAULT = 9 + SWITCH_EXIT = 10 + LABEL = 11 + UNREACHABLE = 12 + GENERIC = 13 + +class IRFunction(multiplier.Entity): + pass + +class IRBlock(multiplier.Entity): + pass + +class IRInstruction(multiplier.Entity): + pass + +class IRObject(multiplier.Entity): + pass diff --git a/docs/IR.md b/docs/IR.md new file mode 100644 index 000000000..f68dd087b --- /dev/null +++ b/docs/IR.md @@ -0,0 +1,431 @@ +# Multiplier IR + +## Overview + +Multiplier generates a per-function intermediate representation (IR) at index time. The IR is a statement-level control flow graph where expressions are nested instruction trees within basic blocks. Every function with a body gets an IR. Global variables and thread-local variables with initializers get synthetic initializer functions. + +The IR is designed for concrete and symbolic interpretation. Types are explicit in opcodes (no need to query the type system), control flow is well-formed (every block ends with a terminator), and the structural nesting of scopes and control flow is fully represented. + +## Worked Example + +```c +int sum(int n) { + int total = 0; + for (int i = 0; i < n; i++) { + total += i; + } + return total; +} +``` + +``` +FRAME block: + ALLOCA/LOCAL %0 : int // 'n' + ALLOCA/LOCAL %1 : int // 'total' + ALLOCA/LOCAL %2 : int // 'i' + IMPLICIT_GOTO → entry + +ENTRY block: + ENTER_SCOPE (FUNCTION_SCOPE) + PARAM_PTR 0 + MEMORY(STORE_LE_32) %0, ^ // n = param0 + CONST(INT32) 0 + MEMORY(STORE_LE_32) %1, ^ // total = 0 + IMPLICIT_GOTO → scope_entry + +scope_entry block: + ENTER_SCOPE (SCOPE) // implicit scope for 'int i' + IMPLICIT_GOTO → preheader + +LOOP_PREHEADER block: + CONST(INT32) 0 + MEMORY(STORE_LE_32) %2, ^ // i = 0 + IMPLICIT_GOTO → loop_cond + +LOOP_CONDITION block: + MEMORY(LOAD_LE_32) %2 // i + MEMORY(LOAD_LE_32) %0 // n + CMP_LT ^, ^ + COND_BRANCH ^, loop_body, loop_exit + +LOOP_BODY block: + ENTER_SCOPE (SCOPE) + RMW(ADD) %1, MEMORY(LOAD_LE_32 %2) // total += i + EXIT_SCOPE + IMPLICIT_GOTO → loop_inc + +LOOP_INCREMENT block: + RMW(ADD) %2, CONST(INT32) 1 // i++ + IMPLICIT_GOTO → loop_cond + +LOOP_EXIT block: + EXIT_SCOPE // for-init scope + MEMORY(LOAD_LE_32) %1 // total + EXIT_SCOPE (FUNCTION_SCOPE) + RET ^ +``` + +Key points: +- ALLOCAs in the FRAME block are pointers to local storage. No separate "address-of" instruction — `&x` IS the ALLOCA result. Sub-opcode `AllocaKind` distinguishes `LOCAL`, `ARG`, `RETURN`, and `DYNAMIC`. +- MEMORY instructions carry exact size and endianness in their sub-opcode (e.g., `STORE_LE_32` = little-endian 32-bit store). +- `PARAM_PTR` returns a pointer to the Nth function parameter. Storage lives in the caller's EXPRESSION_SCOPE. +- `RMW(ADD)` is a read-modify-write: reads from address, adds the operand, writes back. +- `ENTER_SCOPE` / `EXIT_SCOPE` bracket object lifetimes. The for-init `int i` gets an implicit wrapping scope. +- Direct assignment `a = b` uses `MEMCPY(dest, src, size)` — no load/store pair. Scalar LOAD/STORE only for feeding values into arithmetic. + +## Functions + +**`FunctionKind`**: `NORMAL`, `GLOBAL_INITIALIZER`, `THREAD_LOCAL_INITIALIZER` + +- **`NORMAL`**: Generated from a `FunctionDecl` with a body. +- **`GLOBAL_INITIALIZER`**: Synthetic function for a global or static local variable's initialization. Receives a pointer to the variable as parameter 0. +- **`THREAD_LOCAL_INITIALIZER`**: Same as GLOBAL_INITIALIZER but for `_Thread_local` variables. An interpreter knows the init runs per-thread. + +``` +// Global: int g = 42; +FRAME block: (empty) +ENTRY block: + ENTER_SCOPE (FUNCTION_SCOPE) + PARAM_PTR 0 // pointer to g + MEMORY(MEMSET) ^, CONST(INT8) 0, CONST(INT64) 4 // zero-fill + PARAM_PTR 0 + CONST(INT32) 42 + MEMORY(STORE_LE_32) ^, ^ // *g_ptr = 42 + EXIT_SCOPE + RET +``` + +Key methods: `kind()`, `declaration()`, `source_declaration()`, `entry_block()`, `blocks()` (RPO), `objects()`, `body_scope()`. + +Navigation: `IRFunction::from(FunctionDecl)` (follows redeclarations), `IRFunction::containing(Decl|Stmt|IRBlock|IRInstruction)`. + +## Blocks + +Every block ends with exactly one terminator. + +**`BlockKind`** (17 kinds): + +| Kind | Description | +|------|-------------| +| `FRAME` | All ALLOCAs. Physical entry point. | +| `ENTRY` | Logical entry: ENTER_SCOPE, PARAM_PTRs, body start. | +| `IF_THEN`, `IF_ELSE`, `IF_MERGE` | If-statement parts. | +| `LOOP_PREHEADER` | Single-entry before loop condition. For-init code lives here. | +| `LOOP_CONDITION` | Condition evaluation. | +| `LOOP_BODY` | Loop body. | +| `LOOP_EXIT` | Exit point. | +| `LOOP_INCREMENT` | For-loop increment. | +| `SWITCH_CASE`, `SWITCH_DEFAULT`, `SWITCH_EXIT` | Switch parts. | +| `LABEL` | Goto target. | +| `COMPENSATION` | Scope transitions on goto/switch-case edges. | +| `UNREACHABLE` | Dead code after terminator. | +| `GENERIC` | Unclassified. | + +Key methods: `kind()`, `parent_structure()`, `parent_function()`, `instructions()`, `all_instructions()`, `successors()`, `predecessors()`, `dominates()`. + +## Instructions + +~217 opcodes (uint8_t). Integer, pointer, and atomic opcodes are width-specific (e.g., `ADD_32`, `PTR_ADD_64`, `ATOMIC_ADD_32`). Grouped opcodes (MEMORY, CAST, BITWISE, FLOAT) use a sub-opcode enum in the int pool. + +Instructions are stored in post-order (children before parents). `block.instructions()` yields top-level roots; `block.all_instructions()` yields everything in evaluation order. + +### Pointer Acquisition + +| Opcode | Description | +|--------|-------------| +| `ALLOCA` | Pointer to an allocation. Sub-opcode `AllocaKind` in int_pool[0]: `LOCAL` (regular local), `ARG` (call argument in EXPRESSION_SCOPE), `RETURN` (return value in EXPRESSION_SCOPE), `DYNAMIC` (VLA/alloca()). `allocated_type()`, `object()`, `size_bytes()`, `align_bytes()`. Derived classes: `LocalAllocaInst`, `ArgAllocaInst`, `ReturnAllocaInst`, `DynamicAllocaInst`. | +| `GLOBAL_PTR_32/64` | Pointer to a global/static variable. Width = pointer size. `variable()` → VarDecl. | +| `THREAD_LOCAL_PTR_32/64` | Pointer to a thread-local variable. `variable()` → VarDecl. | +| `FUNC_PTR_32/64` | Pointer to a function. `function()` → FunctionDecl. | +| `STRING_PTR_32/64` | Pointer to a string literal. `source_entity_id` → StringLiteral. | +| `GEP_FIELD_32/64` | Struct field pointer. `base()`, `field()` → FieldDecl, `byte_offset()`. | +| `PTR_ADD_32/64` | Pointer arithmetic. `base()`, `index()`, `element_type()`, `element_size()`. | +| `PTR_DIFF_32/64` | Pointer subtraction. Result is ptrdiff_t. `lhs()`, `rhs()`, `element_size()`. | +| `PARAM_PTR_32/64` | Pointer to Nth function parameter. `parameter_index()`. | +| `FRAME_PTR_32/64` | `__builtin_frame_address`. | +| `RETURN_PTR_32/64` | Callee-side pointer to caller's return storage. | +| `RETURN_ADDRESS_32/64` | `__builtin_return_address`. | + +### Memory Access (MEMORY opcode) + +Single `MEMORY` opcode with `MemOp` sub-opcode encoding direction, endianness, size, atomicity, and bulk/string operations. + +**Size rules**: Only 1/2/4/8 byte scalar LOAD/STORE is allowed. For non-power-of-2 sizes or objects > 8 bytes, `MEMCPY` is used. Direct assignment `a = b` always uses `MEMCPY` when the RHS is an lvalue — no redundant LOAD+STORE pair. + +**Direct loads/stores** (sub-opcodes 0-31): + +| Pattern | Variants | +|---------|----------| +| `LOAD_{LE,BE}_{8,16,32,64}` | Non-atomic loads | +| `STORE_{LE,BE}_{8,16,32,64}` | Non-atomic stores | +| `ATOMIC_LOAD_{LE,BE}_{8,16,32,64}` | Atomic loads | +| `ATOMIC_STORE_{LE,BE}_{8,16,32,64}` | Atomic stores | + +Helpers: `IsLoad()`, `IsStore()`, `IsAtomic()`, `IsBigEndian()`, `AccessSize()`. + +**Bulk memory** (sub-opcodes 32-37): `MEMSET`, `MEMCPY`, `MEMMOVE`, `MEMCMP`, `MEMCHR`, `BZERO` + +**String operations** (sub-opcodes 38-50): `STRLEN`, `STRNLEN`, `STRCMP`, `STRNCMP`, `STRCHR`, `STRRCHR`, `STRSTR`, `STRCPY`, `STRNCPY`, `STRCAT`, `STRNCAT`, `STPCPY`, `STPNCPY` + +**String-to-number** (sub-opcodes 51-56): `STRTOI32`, `STRTOI64`, `STRTOU32`, `STRTOU64`, `STRTOF32`, `STRTOF64` — size-specific to avoid platform ambiguity. + +**Bit-field access** (sub-opcodes 57-60): `BIT_READ_LE`, `BIT_WRITE_LE`, `BIT_READ_BE`, `BIT_WRITE_BE`. Bit offset and width stored in int pool (not as operands). Endianness determines bit numbering: LE bit 0 = LSB of byte 0; BE bit 0 = MSB of byte 0. Used for struct bit-field reads and writes. + +**Atomic compare-and-exchange** (sub-opcodes 61-68): `CMPXCHG_{LE,BE}_{8,16,32,64}`. `op[0]=target`, `op[1]=expected_ptr`, `op[2]=desired`. Returns bool. + +**Variadic argument consumption** (sub-opcode 69): `CONSUME_VA_PARAM`. `op[0]=va_list_ptr`. Reads the current va_list index, copies from the caller's variadic argument alloca, increments the index. `type_entity_id` specifies the consumed type. + +Helpers: `IsLoad()`, `IsStore()`, `IsAtomic()`, `IsBigEndian()`, `AccessSize()`, `IsBitAccess()`, `IsBitRead()`, `IsBitWrite()`, `IsCmpxchg()`. + +Both library calls and `__builtin_` variants are recognized. `_Atomic` types automatically use atomic load/store/RMW variants. + +`MemoryInst` class: `sub_opcode()`, `address()`, `stored_value()`, `result_type()`, `bit_offset()`, `bit_width()`. + +`ConsumeVAParamInst` class: `va_list_operand()`, `result_type()`. + +### Constants (CONST opcode) + +`ConstOp` sub-opcode encodes exact type: `INT8`-`INT64`, `UINT8`-`UINT64`, `FLOAT16`/`FLOAT32`/`FLOAT64`, `NULL_PTR`, `INF32`/`INF64`, `NAN32`/`NAN64`, `WCHAR16`/`WCHAR32`, `BOOL`. + +`ConstInst` class: `sub_opcode()`, `signed_value()`, `unsigned_value()`, `float_value()`, `type()`. + +### Casts (CAST opcode) + +`CastOp` sub-opcode encodes explicit source/destination sizes (~60 variants): + +- Sign-extend: `SEXT_I8_I16`, ..., `SEXT_I32_I64` +- Zero-extend: `ZEXT_I8_I16`, ..., `ZEXT_I32_I64` +- Truncate: `TRUNC_I64_I32`, ..., `TRUNC_I16_I8` +- Int↔Float: `SI32_TO_F64`, `F64_TO_SI32`, `UI32_TO_F32`, ... +- Float↔Float: `F32_TO_F64`, `F64_TO_F32` +- Pointer: `PTR_TO_I64`, `I64_TO_PTR` +- `BITCAST`, `IDENTITY` + +Helpers: `IsSignExtend()`, `IsZeroExtend()`, `IsTruncate()`, `IsIntToFloat()`, `IsFloatToInt()`. + +### Arithmetic and Logic + +All integer/bitwise/comparison opcodes are width-specific (`_8`, `_16`, `_32`, `_64`). The width suffix indicates the operand width in bits. Float opcodes have `_32` (float) and `_64` (double) variants. + +| Opcodes | Class | +|---------|-------| +| `ADD_8/16/32/64`, `SUB_*`, `MUL_*`, `DIV_*`, `REM_*` | `BinaryInst` (signed arithmetic) | +| `UDIV_8/16/32/64`, `UREM_*`, `USHR_*` | `BinaryInst` (unsigned arithmetic) | +| `BIT_AND_8/16/32/64`, `BIT_OR_*`, `BIT_XOR_*`, `SHL_*`, `SHR_*` | `BinaryInst` (bitwise) | +| `FADD_32/64`, `FSUB_*`, `FMUL_*`, `FDIV_*`, `FREM_*` | `BinaryInst` (float arithmetic) | +| `CMP_EQ_8/16/32/64`, `CMP_NE_*`, `CMP_LT_*`, `CMP_LE_*`, `CMP_GT_*`, `CMP_GE_*` | `ComparisonInst` (signed) | +| `UCMP_LT_8/16/32/64`, `UCMP_LE_*`, `UCMP_GT_*`, `UCMP_GE_*` | `ComparisonInst` (unsigned) | +| `FCMP_EQ_32/64`, `FCMP_NE_*`, `FCMP_LT_*`, `FCMP_LE_*`, `FCMP_GT_*`, `FCMP_GE_*` | `ComparisonInst` (float) | +| `NEG_8/16/32/64`, `BIT_NOT_8/16/32/64`, `ABS_8/16/32/64` | `UnaryInst` (sized) | +| `FNEG_32/64` | `UnaryInst` (float) | +| `LOGICAL_AND`, `LOGICAL_OR`, `LOGICAL_NOT` | Unsized (produce 0 or 1) | + +### Bitwise Intrinsics (BITWISE opcode) + +`BITWISE_8/16/32/64` — width-specific bitwise intrinsics. `BitwiseOp` sub-opcode in int_pool[0]: + +| Sub-opcode | Description | +|------------|-------------| +| `BSWAP_16/32/64` | Byte swap (width in sub-opcode name). | +| `POPCOUNT` | Number of set bits. | +| `CLZ` | Count leading zeros. UNDEFINED for 0. | +| `CTZ` | Count trailing zeros. UNDEFINED for 0. | +| `FFS` | Find first set bit (1-indexed). 0 for input 0. | +| `PARITY` | 1 if odd number of set bits. | +| `ROTL` | Rotate left. op[0]=value, op[1]=amount. | +| `ROTR` | Rotate right. op[0]=value, op[1]=amount. | + +Width comes from the parent opcode. CLZ on `BITWISE_8` counts leading zeros in an 8-bit value. + +### Float Intrinsics (FLOAT opcode) + +`FLOAT` — float intrinsic operations. `FloatOp` sub-opcode in int_pool[0]. Every sub-opcode has `_32` (float) and `_64` (double) variants for precision-correct execution. + +Categories: classification (`ISNAN`, `ISINF`, `ISFINITE`, `SIGNBIT`), arithmetic (`FABS`, `COPYSIGN`, `FMIN`, `FMAX`), rounding (`CEIL`, `FLOOR`, `ROUND`, `TRUNC`), roots (`SQRT`), trigonometric (`SIN`, `COS`, `TAN`, `ASIN`, `ACOS`, `ATAN`, `ATAN2`), exponential (`EXP`, `EXP2`, `LOG`, `LOG2`, `LOG10`), power (`POW`, `FMOD`, `REMAINDER`, `FMA`), hyperbolic (`SINH`, `COSH`, `TANH`), other (`HYPOT`, `ERF`, `ERFC`, `TGAMMA`, `LGAMMA`, `FDIM`), constants (`INF`, `NAN`, `HUGE`). + +### Calls + +`CALL` — `CallInst`: `target()` (FunctionDecl for direct), `is_indirect()`, `arguments()`, `result_type()`. + +With the EXPRESSION_SCOPE model, function calls are wrapped in an `EXPRESSION_SCOPE` that holds `ALLOCA/ARG` for each argument and `ALLOCA/RETURN` for the return value. On the callee side, `PARAM_PTR(n)` gives a pointer to the caller's Nth argument alloca. + +### Read-Modify-Write + +`READ_MODIFY_WRITE` — reads from address, applies an operation, writes back. `ReadModifyWriteInst`: `address()`, `underlying_op()`, `element_size()`, `is_big_endian()`, `is_atomic()`, `returns_new_value()`, `rhs_operands()`. + +int_pool layout: `[underlying_opcode, element_size, is_big_endian]`. + +The underlying opcode is always a sized opcode: +- Integer: `ADD_32`, `SUB_64`, `UDIV_32`, `USHR_32`, etc. +- Float: `FADD_32`, `FSUB_64`, `FMUL_32`, `FDIV_64`, `FREM_32` +- Pointer: `PTR_ADD_32`, `PTR_ADD_64` +- Atomic: `ATOMIC_ADD_8/16/32/64`, `ATOMIC_SUB_*`, `ATOMIC_AND_*`, `ATOMIC_OR_*`, `ATOMIC_XOR_*`, `ATOMIC_NAND_*`, `ATOMIC_EXCHANGE_*` +- Overflow: `ADD_OVERFLOW_8/16/32/64`, `SUB_OVERFLOW_*`, `MUL_OVERFLOW_*` (returns bool) + +Used for: `++i` (ADD_32), `i += 5` (ADD_32), `f += 1.0` (FADD_32), `++ptr` (PTR_ADD_64), `ptr += n` (PTR_ADD_64), `_Atomic int a; a += 1` (ATOMIC_ADD_32), `__builtin_add_overflow` (ADD_OVERFLOW_32), `__atomic_fetch_add` (ATOMIC_ADD_32). + +### Misc + +| Opcode | Description | +|--------|-------------| +| `SELECT` | Ternary `a ? b : c`. Both branches marked conditionally executed. | +| `LAST_VALUE` | Comma operator `a, b`. Evaluates all operands, returns last. | +| `PARAM_PTR_32/64` | Pointer to Nth function parameter. `parameter_index()`, `parameter_type()`. | +| `FRAME_PTR_32/64` | `__builtin_frame_address(level)`. | +| `RETURN_ADDRESS_32/64` | `__builtin_return_address(level)`. | +| `UNDEFINED` | Poison value. Any use is UB. | + +### Variadic Argument Handling + +| Opcode | Description | +|--------|-------------| +| `VA_START` | Binds va_list to function's variadic arguments. `va_list_operand()`. | +| `VA_COPY` | Copies va_list. `dest()`, `src()`. | +| `VA_END` | Releases va_list. `va_list_operand()`. | +| `MEMORY/CONSUME_VA_PARAM` | Reads next variadic arg from va_list, copies from caller's EXPRESSION_SCOPE, increments index. `va_list_operand()`, `result_type()`. | + +### Terminators + +| Opcode | Description | +|--------|-------------| +| `COND_BRANCH` | Conditional branch. `condition()`, `true_block()`, `false_block()`. | +| `SWITCH` | Switch statement. `selector()`, `cases()`, `num_cases()`. | +| `RET` | Return. `return_value()` (optional). | +| `UNREACHABLE` | Explicit `__builtin_unreachable()`. | +| `BREAK`, `CONTINUE` | Loop/switch control with source provenance. | +| `GOTO` | Explicit goto. May route through COMPENSATION block. | +| `IMPLICIT_GOTO` | Structural CFG edge. | +| `FALLTHROUGH`, `IMPLICIT_FALLTHROUGH` | Switch case fallthrough (explicit vs missing break). | +| `IMPLICIT_UNREACHABLE` | Patched empty block. | + +### Scope Markers + +| Opcode | Class | Description | +|--------|-------|-------------| +| `ENTER_SCOPE` | `EnterScopeInst` | Scope entry. Objects become allocated but uninitialized. `scope()` → IRStructure. | +| `EXIT_SCOPE` | `ExitScopeInst` | Scope exit. Objects become invalid. `scope()` → IRStructure. | + +### Intrinsics + +**`BITWISE`** — `BitwiseOpInst` with sub-opcodes: `BSWAP16`/`32`/`64`, `POPCOUNT`, `CLZ` (undefined for 0), `CTZ` (undefined for 0), `FFS`, `PARITY`, `ABS`, `EXPECT`, `ASSUME`, `ROTL`, `ROTR`. + +**`FLOAT`** — `FloatOpInst` with 41 sub-opcodes: `SIN`, `COS`, `TAN`, `ASIN`, `ACOS`, `ATAN`, `ATAN2`, `EXP`, `EXP2`, `LOG`, `LOG2`, `LOG10`, `POW`, `FMOD`, `REMAINDER`, `FMA`, `SINH`, `COSH`, `TANH`, `HYPOT`, `ERF`, `ERFC`, `TGAMMA`, `LGAMMA`, `FDIM`, `SIGNBIT`, `ISNAN`, `ISINF`, `ISFINITE`, `FABS`, `COPYSIGN`, `FMIN`, `FMAX`, `CEIL`, `FLOOR`, `ROUND`, `TRUNC`, `SQRT`, `INF`, `NAN_VAL`, `FLOAT_HUGE`. + +### Atomics + +| Opcode | Description | +|--------|-------------| +| Atomic cmpxchg | Use `MEMORY` with `CMPXCHG_LE_*` / `CMPXCHG_BE_*` sub-opcodes. `op[0]=target`, `op[1]=expected_ptr`, `op[2]=desired`. Returns bool. | +| Atomic load/store | Use `MEMORY` with `ATOMIC_LOAD_*` / `ATOMIC_STORE_*` sub-opcodes. | +| Atomic fetch ops | Use `READ_MODIFY_WRITE` with `ATOMIC_ADD`..`ATOMIC_EXCHANGE` underlying. | +| Overflow ops | Use `READ_MODIFY_WRITE` with `ADD_OVERFLOW`/`SUB_OVERFLOW`/`MUL_OVERFLOW`. Returns bool (overflow flag), stores arithmetic result. | + +## Objects + +`IRObject` represents a memory location. + +**`ObjectKind`**: `LOCAL`, `LOCAL_VALUE`, `PARAMETER`, `PARAMETER_VALUE`, `GLOBAL`, `THREAD_LOCAL`, `STRING_LITERAL`, `COMPOUND_LITERAL`, `RETURN_SLOT`, `ALLOCA` (dynamic), `HEAP`. + +Key methods: `kind()`, `source_declaration()`, `type()`, `size_bytes()`, `align_bytes()`, `needs_memory()`. + +### String Literal Objects + +`STRING_LITERAL` objects hold the storage for string literals. The object's `size_bytes()` includes the null terminator (`ByteLength() + CharacterByteWidth()`). The actual string content is available from the AST via the `source_entity_id` → `StringLiteral::Bytes()`, which returns the raw bytes in **target byte order** and does **NOT** include the trailing null terminator. Consumers should zero-fill the object first, then copy `Bytes()` into it. For wide strings (`L"..."`, `u"..."`, `U"..."`), `CharacterByteWidth()` is 2 or 4, and `Bytes()` contains multi-byte characters in target byte order. + +## Structural Hierarchy + +`IRStructure` forms a tree rooted at `FUNCTION_SCOPE`. Every block has a `parent_structure()`. + +**`StructureKind`** (19 kinds): + +| Kind | Derived Class | Key Methods | +|------|--------------|-------------| +| `FUNCTION_SCOPE`, `SCOPE` | `IRScopeStructure` | `objects()` — locals in this scope | +| `EXPRESSION_SCOPE` | `IRExpressionScopeStructure` | `objects()` — arg/return allocas for calls in a full-expression | +| `IF` | `IRIfStructure` | `then_branch()`, `else_branch()` | +| `FOR` | `IRForStructure` | `init()`, `condition()`, `body()`, `increment()` | +| `WHILE` | `IRWhileStructure` | `condition()`, `body()` | +| `DO_WHILE` | `IRDoWhileStructure` | `body()`, `condition()` | +| `SWITCH` | `IRSwitchStructure` | `cases()`, `default_case()` | +| `SWITCH_CASE` | `IRSwitchCaseStructure` | `low()`, `high()`, `is_default()`, `target_block()` | +| Sub-parts | — | `IF_THEN`, `IF_ELSE`, `FOR_INIT`, `FOR_CONDITION`, `FOR_BODY`, `FOR_INCREMENT`, `WHILE_CONDITION`, `WHILE_BODY`, `DO_WHILE_BODY`, `DO_WHILE_CONDITION` | + +### EXPRESSION_SCOPE and Calling Convention + +Function calls are wrapped in an `EXPRESSION_SCOPE` that extends to the full-expression boundary (the `;`). The scope holds: +- One `ALLOCA/ARG` per argument (caller copies values into these) +- One `ALLOCA/RETURN` for the return value (callee writes result here) + +On the callee side: +- `PARAM_PTR(n)` returns a pointer to the caller's Nth argument alloca +- The callee reads parameters by loading from `PARAM_PTR` pointers +- Parameters have no callee-side scope — their lifetime is the caller's EXPRESSION_SCOPE + +For nested calls like `foo(bar(x), baz(y))`, all argument and return allocas for all calls in the expression share one EXPRESSION_SCOPE. + +### Scope Lifetime Model + +- **`ENTER_SCOPE`**: Objects become allocated but **uninitialized**. Reading before a store is undefined. +- **`EXIT_SCOPE`**: Objects become **invalid**. Reading after is use-after-scope. +- Aggregate initialization emits `MEMORY(MEMSET)` to zero-fill, then element-wise stores. +- For-loops with init-declarations get an implicit `SCOPE`. +- Dynamic allocations (`ALLOCA/DYNAMIC`) create scope-tracked objects freed on scope exit. + +### Scope Compensation Blocks + +When control flow crosses scope boundaries — via `goto` or switch-case edges (Duff's device) — a `COMPENSATION` block is inserted with the necessary `EXIT_SCOPE` / `ENTER_SCOPE` transitions. Each goto and each switch→case edge gets its own compensation block. Same-scope jumps need no compensation. + +### Array-to-Pointer Decay + +When an array is passed to a function, it decays to a pointer. The ALLOCA for the array IS the decayed pointer — no load is emitted. On the callee side, Clang adjusts `int arr[10]` parameters to `int *`, so the parameter type and size are correct (pointer-sized). + +### GNU Block Expressions + +`({ int x = 1; x + 1; })` emits a scoped block with `ENTER_SCOPE`/`EXIT_SCOPE`. The last expression's value is the result. + +## Entity IDs + +Entity IDs embed kind in the sub_kind field: `IRBlockId` embeds `BlockKind`, `IRInstructionId` embeds `OpCode`, `IRStructureId` embeds `StructureKind`. + +## Serialization + +``` +Fragment { + irFunctions, irBlocks, irInstructions, irObjects, + irStructures, irEntityPool, irIntPool +} +``` + +**Byte order**: All numeric values in the int pool (constants, sizes, offsets) are stored in host byte order. The index is architecture-specific — type sizes, alignment, and ABI are all target-dependent. Databases indexed on a little-endian host are not portable to big-endian (and vice versa). This is inherent to the design; the entire index is tied to the target triple. + +## Design Rationale + +**Statement-level CFG**: Expressions stay as nested trees. `if ((x+y) && z)` is one block with `LOGICAL_AND(ADD(LOAD(x), LOAD(y)), LOAD(z))`. + +**No SSA**: All locals go through alloca/load/store. `LOCAL_VALUE`/`PARAMETER_VALUE` mark SSA-promotable variables. + +**Explicit widths**: Constants (`INT32`, `FLOAT64`), casts (`SEXT_I32_I64`), and loads/stores (`LOAD_LE_32`) carry exact sizes. No type system queries needed. + +**Grouped opcodes**: `MEMORY` (70 sub-ops), `CONST` (19), `CAST` (~60), `ALLOCA` (4), `BITWISE` (13), `FLOAT` (41) keep the main opcode count at 71. + +**Assignment model**: Direct assignment `a = b` always uses `MEMCPY(dest, src, size)`. Scalar `LOAD`/`STORE` only for feeding values into arithmetic and writing computed results back. This avoids endianness issues for direct copies and naturally handles all sizes. + +**Provenance**: Every instruction has `source_entity_id`. Calls have `target()`. GEP fields have `field()`. Navigate to AST for names and source locations. + +## Known Gaps and TODO + +### Address Assignment for Globals, Strings, and Functions + +`GLOBAL_PTR`, `THREAD_LOCAL_PTR`, `FUNC_PTR`, and `STRING_PTR` produce +pointers to entities that live outside the function's stack frame. The IR does +not prescribe what addresses these get — it is the interpreter's responsibility +to assign concrete addresses. The interpreter should give each entity a +consistent address for the duration of the program (e.g., via a flat virtual +address space with lazy allocation). + +`STRING_PTR`'s `source_entity_id` points to the `StringLiteral` AST node. +The interpreter populates storage from `StringLiteral::bytes()`. + +### `#embed` + +C23 `#embed` is not yet handled. diff --git a/docs/InterpreterLibraryPlan.md b/docs/InterpreterLibraryPlan.md new file mode 100644 index 000000000..e491955e1 --- /dev/null +++ b/docs/InterpreterLibraryPlan.md @@ -0,0 +1,162 @@ +# Interpreter Library Plan + +## Goal + +Move the concrete interpreter from `bin/InterpretIR/` into a reusable library at `lib/IR/Interpret/` with headers at `include/multiplier/IR/Interpret/`. The library exposes policy-based extension points for memory, value computation, call resolution, and checking — enabling concrete interpretation, taint analysis, symbolic execution, and Valgrind-style memcheck as composable layers. + +## Architecture + +### Core Interfaces (already stubbed in headers) + +``` +ValueFactory — pluggable ALU (concrete, symbolic, taint-wrapped) +Memory — pluggable address space (flat bytes, COW, shadow) +Driver — resolves suspensions (branches, calls, loads, stores) +Checker — fires on memory access, pointer arithmetic, calls +``` + +### Interpreter Class + +```cpp +class Interpreter { + ValueFactory &factory_; + Memory &memory_; + Driver &driver_; + std::vector checkers_; + + // Execution state. + struct CallFrame { ... }; + std::vector call_stack_; + std::unordered_map inst_values_; // instruction index → value + + // The interpreter handles: + // - Instruction dispatch (opcode → handler) + // - Endianness mechanics (LOAD_LE_32 → read 4 bytes, reinterpret) + // - Expression tree evaluation (post-order traversal) + // - Scope enter/exit (delegate alloc/free to Memory) + // - Call frame push/pop + // - Terminator dispatch (branch, switch, return) + + // It does NOT handle: + // - What value arithmetic produces (→ ValueFactory) + // - Where bytes live (→ Memory) + // - Whether to inline a call (→ Driver) + // - Whether an access is safe (→ Checkers) +}; +``` + +### Suspension/Resolution Flow + +The interpreter is driven by an external loop: + +```cpp +// Option A: coroutine-based (gap::generator) +gap::generator Interpreter::Run(IRFunction func); + +// Option B: step-based (simpler, no coroutine dependency) +enum class StepResult { CONTINUE, SUSPENDED, COMPLETED, ERROR }; +StepResult Interpreter::Step(); +Suspension Interpreter::GetSuspension(); +void Interpreter::Resume(Resolution resolution); +``` + +Option B is better for the library because: +- No coroutine overhead +- Caller controls the loop +- Easy to serialize/resume state +- Works with async agent decision-making + +### Composable Value Factories + +``` +ConcreteValueFactory — direct int/float/ptr arithmetic +SymbolicValueFactory(inner) — wraps inner, builds sym trees for unknowns +TaintValueFactory(inner, prov) — wraps inner, tracks provenance +``` + +Each factory's `BinaryOp`, `Cast`, etc. can: +1. Unwrap its layer +2. Delegate to inner factory +3. Wrap the result with its metadata + +### Memory Layers + +``` +ConcreteMemory — flat byte arrays, object table +ShadowMemory(inner) — wraps inner, adds per-byte metadata +COWMemory(inner) — wraps inner, O(1) fork +``` + +Shadow metadata per byte: `{ initialized: bool, tainted: bool, freed: bool }` + +### Checker Plugins + +``` +NullDerefChecker — check for null pointer access +BoundsChecker — check offset vs object size +UseAfterFreeChecker — check for access to freed objects +InitializationChecker — check for read-before-write +``` + +Checkers fire via the interpreter, not the driver. They can record findings into a collector. + +## File Layout + +``` +include/multiplier/IR/Interpret/ + Value.h — ScalarValue, Pointer, Undefined, NullPtr, Value variant + ValueFactory.h — ValueFactory ABC + Memory.h — Memory ABC + Suspension.h — Suspension/Resolution types + Driver.h — Driver ABC, Checker ABC + Interpreter.h — Interpreter class (the engine) + +lib/IR/Interpret/ + ConcreteValueFactory.cpp + ConcreteMemory.cpp + Interpreter.cpp — instruction dispatch, endianness, tree eval + Checkers.cpp — built-in checker implementations + +bin/InterpretIR/ + InterpretIR.cpp — thin CLI: parse args, open index, create + ConcreteValueFactory + ConcreteMemory + + ConcreteDriver, run interpreter, print results +``` + +## Migration Steps + +1. **Extract Value types** — move Value, ScalarValue, Pointer from InterpretIR.cpp into Value.h. ✅ Done. + +2. **Extract ValueFactory** — pull arithmetic dispatch out of the interpreter's big switch into ConcreteValueFactory. The switch cases for ADD, SUB, MUL, etc. become factory methods. + +3. **Extract Memory** — pull the byte-array memory model into ConcreteMemory. The interpreter's `Allocate`, `Read`, `Write`, `Memset`, `Memcpy` become Memory methods. Endianness conversion stays in the interpreter (it's the mechanical layer between opcodes and raw bytes). + +4. **Extract Driver** — the current interpreter makes concrete decisions everywhere. Pull those into a ConcreteDriver that always takes true branches, always inlines available functions, aborts on symbolic. + +5. **Wire up Interpreter class** — the main dispatch loop calls factory/memory/driver instead of doing everything inline. The current ~1500-line switch becomes the Interpreter::Step() method. + +6. **Add Checkers** — extract the bounds/null checks that the current interpreter does ad-hoc into Checker subclasses. + +7. **Slim down bin/InterpretIR** — becomes ~100 lines: parse args, create components, run loop, print. + +## Key Design Decisions + +- **Endianness in the interpreter, not the memory**: Memory reads/writes raw bytes. The interpreter knows `LOAD_LE_32` means "read 4 bytes, interpret as little-endian uint32". This keeps the memory model simple and endianness-agnostic. + +- **Step-based, not coroutine-based**: The interpreter exposes `Step()` / `GetSuspension()` / `Resume()`. This is more flexible than coroutines for serialization, agent integration, and multi-path exploration. + +- **Checkers are synchronous**: They fire during the step, not asynchronously. A checker that wants to abort execution returns an error from its hook. Findings are collected into a vector. + +- **No multiplier types in Value**: Values are raw bits + pointers. Type interpretation comes from the opcodes, not the values. This matches the IR's "types are in opcodes" philosophy. + +- **Memory objects are numbered, not addressed**: Pointer = (object_id, offset). No flat address space. This enables bounds checking without spatial memory safety hardware. + +## Timeline Estimate + +This is a mechanical refactoring — the logic already exists in InterpretIR.cpp. The main work is: +- Defining clean interfaces (done in headers) +- Extracting code into the right classes +- Wiring the components together +- Making the bin/ driver thin + +Not blocked on any IR design decisions. Can proceed after the SQLite issue is resolved. diff --git a/include/multiplier/AST/Decl.h b/include/multiplier/AST/Decl.h index f32eded64..69207502b 100644 --- a/include/multiplier/AST/Decl.h +++ b/include/multiplier/AST/Decl.h @@ -45,6 +45,7 @@ class MX_EXPORT Decl { public: std::optional parent_declaration(void) const; std::optional parent_statement(void) const; + std::optional ir(void) const; protected: friend class Attr; friend class File; diff --git a/include/multiplier/AST/Stmt.h b/include/multiplier/AST/Stmt.h index b5b54ae1c..33b7c89e0 100644 --- a/include/multiplier/AST/Stmt.h +++ b/include/multiplier/AST/Stmt.h @@ -39,6 +39,7 @@ class MX_EXPORT Stmt { public: std::optional parent_declaration(void) const; std::optional parent_statement(void) const; + std::optional ir(void) const; protected: friend class Attr; friend class Decl; diff --git a/include/multiplier/Database.h b/include/multiplier/Database.h index 094552338..c636481f7 100644 --- a/include/multiplier/Database.h +++ b/include/multiplier/Database.h @@ -502,6 +502,10 @@ class DatabaseWriter final { next_compilation_index INTEGER NOT NULL ))", + R"(CREATE TABLE IF NOT EXISTS index_id ( + id INTEGER PRIMARY KEY NOT NULL + ))", + R"(CREATE TABLE IF NOT EXISTS version ( action INTEGER NOT NULL ))", diff --git a/include/multiplier/Entity.h b/include/multiplier/Entity.h index b76de6935..9558e34da 100644 --- a/include/multiplier/Entity.h +++ b/include/multiplier/Entity.h @@ -6,6 +6,12 @@ #pragma once #include "Types.h" +#include "IR/Function.h" +#include "IR/Block.h" +#include "IR/Instruction.h" +#include "IR/Object.h" +#include "IR/Structure.h" +#include "IR/StructureKinds.h" namespace mx { @@ -28,6 +34,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_FORWARD_DECLARE, MX_FORWARD_DECLARE, MX_FORWARD_DECLARE, MX_FORWARD_DECLARE, + MX_FORWARD_DECLARE, MX_FORWARD_DECLARE) #undef MX_FORWARD_DECLARE @@ -42,6 +49,7 @@ using VariantEntity = std::variant< MX_DECLARE_ENTITY_VARIANT, MX_DECLARE_ENTITY_VARIANT, MX_DECLARE_ENTITY_VARIANT, + MX_DECLARE_ENTITY_VARIANT, MX_DECLARE_ENTITY_VARIANT)>; #undef MX_DECLARE_ENTITY_VARIANT diff --git a/include/multiplier/Fragment.h b/include/multiplier/Fragment.h index 122311802..d533c7002 100644 --- a/include/multiplier/Fragment.h +++ b/include/multiplier/Fragment.h @@ -34,6 +34,7 @@ class RegexQueryMatch; MX_FORWARD_DECLARE, MX_FORWARD_DECLARE, MX_FORWARD_DECLARE, + MX_FORWARD_DECLARE, MX_FORWARD_DECLARE) #undef MX_FORWARD_DECLARE @@ -65,6 +66,7 @@ class MX_EXPORT Fragment { MX_FRIEND, MX_FRIEND, MX_FRIEND, + MX_FRIEND, MX_FRIEND) #undef MX_FRIEND diff --git a/include/multiplier/Frontend/File.h b/include/multiplier/Frontend/File.h index bec683d50..7b9484ec1 100644 --- a/include/multiplier/Frontend/File.h +++ b/include/multiplier/Frontend/File.h @@ -35,6 +35,7 @@ class TokenTree; MX_FORWARD_DECLARE, MX_FORWARD_DECLARE, MX_FORWARD_DECLARE, + MX_FORWARD_DECLARE, MX_FORWARD_DECLARE) #undef MX_FORWARD_DECLARE @@ -104,6 +105,7 @@ class MX_EXPORT File { MX_FRIEND, MX_FRIEND, MX_FRIEND, + MX_FRIEND, MX_FRIEND) #undef MX_FRIEND @@ -131,6 +133,7 @@ class MX_EXPORT File { MX_DECLARE_CONTAINING, MX_DECLARE_CONTAINING, MX_DECLARE_CONTAINING, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_CONTAINING diff --git a/include/multiplier/Frontend/TokenContext.h b/include/multiplier/Frontend/TokenContext.h index 66b1db28b..166a7814e 100644 --- a/include/multiplier/Frontend/TokenContext.h +++ b/include/multiplier/Frontend/TokenContext.h @@ -92,6 +92,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_FORWARD_DECLARE_GETTER, MX_FORWARD_DECLARE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_FORWARD_DECLARE_GETTER diff --git a/include/multiplier/IR/Block.h b/include/multiplier/IR/Block.h new file mode 100644 index 000000000..e50eb5a0b --- /dev/null +++ b/include/multiplier/IR/Block.h @@ -0,0 +1,64 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "../Compiler.h" +#include "../Types.h" +#include "BlockKind.h" +#include +#include +#include + +namespace mx { + +class IRFunction; +class IRInstruction; +class IRStructure; +class IRBlockImpl; +using IRBlockImplPtr = std::shared_ptr; + +class MX_EXPORT IRBlock { + private: + friend class EntityProvider; + friend class Index; + friend class IRFunction; + friend class IRInstruction; + IRBlockImplPtr impl; + + public: + IRBlock(void) = default; + explicit IRBlock(IRBlockImplPtr impl_) + : impl(std::move(impl_)) {} + + EntityId id(void) const; + ir::BlockKind kind(void) const; + + // Parent structure in the nesting hierarchy. + std::optional parent_structure(void) const; + + // Parent function (walks structure chain to root). + std::optional parent_function(void) const; + + // All instructions in post-order (children before parents). + gap::generator all_instructions(void) const &; + + // Top-level instructions only (parentOffset == 0). + gap::generator instructions(void) const &; + + // CFG. + gap::generator successors(void) const &; + gap::generator predecessors(void) const &; + + // Dominators. + std::optional immediate_dominator(void) const; + std::optional immediate_post_dominator(void) const; + gap::generator dominators(void) const &; + gap::generator post_dominators(void) const &; + bool dominates(const IRBlock &other) const; + +}; + +} // namespace mx diff --git a/include/multiplier/IR/BlockKind.h b/include/multiplier/IR/BlockKind.h new file mode 100644 index 000000000..aecefd371 --- /dev/null +++ b/include/multiplier/IR/BlockKind.h @@ -0,0 +1,55 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include "../Compiler.h" + +namespace mx::ir { + +// Structural role of a basic block in the control flow graph. +enum class BlockKind : uint8_t { + // Function prologue/entry. + FRAME = 0, // Contains all ALLOCAs (parameters + locals). + ENTRY = 1, // Logical entry: ENTER_SCOPE, PARAM_READs, body start. + + // If-statement. + IF_THEN = 2, + IF_ELSE = 3, + IF_MERGE = 4, + + // Loops (while, do-while, for). + LOOP_PREHEADER = 5, // Single-entry block before loop condition. + LOOP_CONDITION = 6, + LOOP_BODY = 7, + LOOP_EXIT = 8, + LOOP_INCREMENT = 9, // For-loop increment. + + // Switch-statement. + SWITCH_CASE = 10, + SWITCH_DEFAULT = 11, + SWITCH_EXIT = 12, + + // Labels and control flow. + LABEL = 13, // User-defined goto target. + COMPENSATION = 14, // Scope transition block on goto edges. + + // Other. + UNREACHABLE = 15, // Dead code after a terminator. + GENERIC = 16, // Unclassified. +}; + +inline static const char *EnumerationName(BlockKind) { + return "BlockKind"; +} + +MX_EXPORT const char *EnumeratorName(BlockKind kind) noexcept; + +inline static constexpr unsigned NumEnumerators(BlockKind) { + return 17u; +} + +} // namespace mx::ir diff --git a/include/multiplier/IR/Function.h b/include/multiplier/IR/Function.h new file mode 100644 index 000000000..370da53cf --- /dev/null +++ b/include/multiplier/IR/Function.h @@ -0,0 +1,72 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "../Compiler.h" +#include "../Types.h" +#include "FunctionKind.h" +#include +#include +#include + +namespace mx { + +class Decl; +class Stmt; +class IRBlock; +class IRInstruction; +class IRObject; +class IRStructure; +class IRFunctionImpl; +class FunctionDecl; +using IRFunctionImplPtr = std::shared_ptr; + +class MX_EXPORT IRFunction { + private: + friend class EntityProvider; + friend class Index; + IRFunctionImplPtr impl; + + public: + IRFunction(void) = default; + explicit IRFunction(IRFunctionImplPtr impl_) + : impl(std::move(impl_)) {} + + EntityId id(void) const; + + // Function kind (NORMAL, GLOBAL_INITIALIZER, etc.) + ir::FunctionKind kind(void) const; + + // The source FunctionDecl (nullopt for non-NORMAL kinds). + std::optional declaration(void) const; + + // The source declaration regardless of kind (FunctionDecl or VarDecl). + std::optional source_declaration(void) const; + + // Entry block. + IRBlock entry_block(void) const; + + // Blocks in RPO order. + gap::generator blocks(void) const &; + + // Memory objects. + gap::generator objects(void) const &; + + // Root of the structure tree (FUNCTION_SCOPE). + std::optional body_scope(void) const; + + // Find the IR for a FunctionDecl (follows redeclarations). + static std::optional from(const FunctionDecl &decl); + + // Find the containing IR function for any Decl, Stmt, Block, or Instruction. + static std::optional containing(const Decl &decl); + static std::optional containing(const Stmt &stmt); + static std::optional containing(const IRBlock &block); + static std::optional containing(const IRInstruction &inst); + +}; + +} // namespace mx diff --git a/include/multiplier/IR/FunctionKind.h b/include/multiplier/IR/FunctionKind.h new file mode 100644 index 000000000..bd8df1f1b --- /dev/null +++ b/include/multiplier/IR/FunctionKind.h @@ -0,0 +1,29 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include "../Compiler.h" + +namespace mx::ir { + +enum class FunctionKind : uint8_t { + NORMAL = 0, + GLOBAL_INITIALIZER = 1, + THREAD_LOCAL_INITIALIZER = 2, +}; + +inline static const char *EnumerationName(FunctionKind) { + return "FunctionKind"; +} + +MX_EXPORT const char *EnumeratorName(FunctionKind kind) noexcept; + +inline static constexpr unsigned NumEnumerators(FunctionKind) { + return 3u; +} + +} // namespace mx::ir diff --git a/include/multiplier/IR/Instruction.h b/include/multiplier/IR/Instruction.h new file mode 100644 index 000000000..ab86abc98 --- /dev/null +++ b/include/multiplier/IR/Instruction.h @@ -0,0 +1,91 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "../Compiler.h" +#include "../Types.h" +#include "OpCode.h" +#include +#include +#include +#include +#include + +namespace mx { + +class IRBlock; +class IRObject; +class IRInstructionImpl; +class Stmt; +class FunctionDecl; +class FieldDecl; +class Type; +using IRInstructionImplPtr = std::shared_ptr; + +class MX_EXPORT IRInstruction { + protected: + friend class EntityProvider; + friend class Index; + friend class IRBlock; + friend class IRFunction; + IRInstructionImplPtr impl; + + public: + // For derived instruction classes. + const IRInstructionImplPtr &impl_ptr(void) const { return impl; } + + public: + IRInstruction(void) = default; + explicit IRInstruction(IRInstructionImplPtr impl_) + : impl(std::move(impl_)) {} + + // Identity. + EntityId id(void) const; + ir::OpCode opcode(void) const; + + // Expression tree (top-down: follow operands into children). + gap::generator operands(void) const &; + unsigned num_operands(void) const; + IRInstruction nth_operand(unsigned n) const; + + // Expression tree (bottom-up: follow parent). + std::optional parent_instruction(void) const; + bool is_root(void) const; + + // Use-def: who uses this instruction's value as an operand. + gap::generator users(void) const &; + unsigned num_users(void) const; + + // AST provenance. + std::optional source_statement(void) const; + RawEntityId source_entity_id(void) const; + + // Block. + IRBlock parent_block(void) const; + + // Terminator queries. + bool is_terminator(void) const; + + // Conditional execution. + bool is_conditionally_executed(void) const; + + // Name: a human-readable label like "total.5" or "arr.3". + // Derived from the source AST (ALLOCA → VarDecl name, GLOBAL_PTR → name, + // FUNC_PTR → name, etc.) plus the instruction offset for uniqueness. + // Returns empty string if no meaningful name can be derived. + std::string_view name(void) const; + + // Format: write a human-readable representation of this instruction + // reference to a stream (e.g., "%total.5" or "%12"). + void format_ref(std::ostream &os) const; + std::string ref_string(void) const; + + // Format: write a full instruction representation to a stream. + void format(std::ostream &os) const; + std::string to_string(void) const; +}; + +} // namespace mx diff --git a/include/multiplier/IR/InstructionKinds.h b/include/multiplier/IR/InstructionKinds.h new file mode 100644 index 000000000..743e2dc22 --- /dev/null +++ b/include/multiplier/IR/InstructionKinds.h @@ -0,0 +1,429 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "Instruction.h" +#include "OpCode.h" +#include "Block.h" +#include "Object.h" +#include "StructureKinds.h" +#include "../AST/Decl.h" +#include "../AST/Type.h" + +namespace mx { + +class FunctionDecl; +class FieldDecl; +class VarDecl; +class IRStructure; + +// Helper macro for derived instruction classes. +#define MX_DECLARE_IR_INSTRUCTION(ClassName) \ + explicit ClassName(IRInstructionImplPtr impl_) \ + : IRInstruction(std::move(impl_)) {} \ + static std::optional from(const IRInstruction &inst); + +// --------------------------------------------------------------------------- +// Constants (unified CONST opcode with ConstOp sub-opcode) +// --------------------------------------------------------------------------- + +class MX_EXPORT ConstInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ConstInst) + ir::ConstOp sub_opcode(void) const; + int64_t signed_value(void) const; + uint64_t unsigned_value(void) const; + double float_value(void) const; + Type type(void) const; +}; + +// --------------------------------------------------------------------------- +// Memory +// --------------------------------------------------------------------------- + +class MX_EXPORT AllocaInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(AllocaInst) + ir::AllocaKind alloca_kind(void) const; + Type allocated_type(void) const; + IRObject object(void) const; + uint32_t size_bytes(void) const; // from the object + uint32_t align_bytes(void) const; // from the object +}; + +// LOCAL alloca: regular local variable. +class MX_EXPORT LocalAllocaInst : public AllocaInst { + public: + explicit LocalAllocaInst(IRInstructionImplPtr impl_) + : AllocaInst(std::move(impl_)) {} + static std::optional from(const IRInstruction &inst); +}; + +// ARG alloca: argument passing storage in EXPRESSION_SCOPE. +class MX_EXPORT ArgAllocaInst : public AllocaInst { + public: + explicit ArgAllocaInst(IRInstructionImplPtr impl_) + : AllocaInst(std::move(impl_)) {} + static std::optional from(const IRInstruction &inst); +}; + +// RETURN alloca: return value storage in EXPRESSION_SCOPE. +class MX_EXPORT ReturnAllocaInst : public AllocaInst { + public: + explicit ReturnAllocaInst(IRInstructionImplPtr impl_) + : AllocaInst(std::move(impl_)) {} + static std::optional from(const IRInstruction &inst); +}; + +// DYNAMIC alloca: runtime-sized (VLA, alloca()). +class MX_EXPORT DynamicAllocaInst : public AllocaInst { + public: + explicit DynamicAllocaInst(IRInstructionImplPtr impl_) + : AllocaInst(std::move(impl_)) {} + static std::optional from(const IRInstruction &inst); + IRInstruction size(void) const; // op[0] = size in bytes (runtime value) +}; + +class MX_EXPORT MemoryInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(MemoryInst) + ir::MemOp sub_opcode(void) const; + IRInstruction address(void) const; // op[0] for all + IRInstruction stored_value(void) const; // op[1] for stores / BIT_WRITE value + Type result_type(void) const; // for loads / BIT_READ + // BIT_READ/BIT_WRITE: bit-level access parameters (from int pool). + uint32_t bit_offset(void) const; // bit offset from address + uint32_t bit_width(void) const; // number of bits +}; + +// --------------------------------------------------------------------------- +// Field / Pointer access +// --------------------------------------------------------------------------- + +class MX_EXPORT GEPFieldInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(GEPFieldInst) + IRInstruction base(void) const; + Type result_type(void) const; + FieldDecl field(void) const; + int64_t byte_offset(void) const; +}; + +class MX_EXPORT PtrAddInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(PtrAddInst) + IRInstruction base(void) const; + IRInstruction index(void) const; + Type result_type(void) const; + Type element_type(void) const; + int64_t element_size(void) const; +}; + +class MX_EXPORT PtrDiffInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(PtrDiffInst) + IRInstruction lhs(void) const; + IRInstruction rhs(void) const; + Type result_type(void) const; + int64_t element_size(void) const; +}; + +// --------------------------------------------------------------------------- +// Binary / Comparison / Unary +// --------------------------------------------------------------------------- + +class MX_EXPORT BinaryInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(BinaryInst) + IRInstruction lhs(void) const; + IRInstruction rhs(void) const; + Type result_type(void) const; +}; + +class MX_EXPORT ComparisonInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ComparisonInst) + IRInstruction lhs(void) const; + IRInstruction rhs(void) const; + Type result_type(void) const; +}; + +class MX_EXPORT UnaryInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(UnaryInst) + IRInstruction operand(void) const; + Type result_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Cast +// --------------------------------------------------------------------------- + +class MX_EXPORT CastInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(CastInst) + ir::CastOp sub_opcode(void) const; + IRInstruction operand(void) const; + Type result_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Sizeof +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// Call +// --------------------------------------------------------------------------- + +class MX_EXPORT CallInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(CallInst) + std::optional result_type(void) const; // nullopt for void calls + std::optional target(void) const; + bool is_indirect(void) const; + bool has_return_value(void) const; + std::optional return_alloca(void) const; // ALLOCA/RETURN in caller's EXPRESSION_SCOPE + gap::generator arguments(void) const &; +}; + +// --------------------------------------------------------------------------- +// Read-modify-write +// --------------------------------------------------------------------------- + +// RMW(address, rhs_operands...) — reads from address, applies underlying +// opcode(loaded_value, rhs_operands...), writes back. +// flags bit 0: 1 = returns new value (pre-increment), 0 = old value (post). +class MX_EXPORT ReadModifyWriteInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ReadModifyWriteInst) + IRInstruction address(void) const; + ir::OpCode underlying_op(void) const; + int64_t element_size(void) const; // for PTR_ADD, 0 otherwise + bool is_big_endian(void) const; // int_pool[2]: target endianness + bool is_atomic(void) const; // true if underlying op is ATOMIC_* + bool returns_new_value(void) const; + Type result_type(void) const; + // RHS operands (everything after address). + gap::generator rhs_operands(void) const &; +}; + +// --------------------------------------------------------------------------- +// Misc +// --------------------------------------------------------------------------- + +// Evaluates all operands in order, returns the last one's value. +// Used for comma operator (a, b) and other sequence-point patterns. +class MX_EXPORT LastValueInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(LastValueInst) + IRInstruction last(void) const; // The last operand (the value returned). + Type result_type(void) const; +}; + +class MX_EXPORT SelectInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(SelectInst) + IRInstruction condition(void) const; + IRInstruction true_value(void) const; + IRInstruction false_value(void) const; + Type result_type(void) const; +}; + +// CopyInst removed: use CastInst with CastOp::IDENTITY instead. + +// --------------------------------------------------------------------------- +// Parameter pointer +// --------------------------------------------------------------------------- + +// Returns a pointer to the Nth function parameter. The storage lives +// in the caller's EXPRESSION_SCOPE. +class MX_EXPORT ParamPtrInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ParamPtrInst) + uint32_t parameter_index(void) const; + Type parameter_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Global/function address +// --------------------------------------------------------------------------- + +class MX_EXPORT GlobalPtrInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(GlobalPtrInst) + std::optional variable(void) const; +}; + +class MX_EXPORT ThreadLocalPtrInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ThreadLocalPtrInst) + std::optional variable(void) const; +}; + +class MX_EXPORT FuncPtrInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(FuncPtrInst) + std::optional function(void) const; +}; + +// --------------------------------------------------------------------------- +// Return value pointer (callee-side) +// --------------------------------------------------------------------------- + +// Pointer to the caller's ALLOCA/RETURN storage. No operands. +// Used inside the callee to write the return value before RET. +class MX_EXPORT ReturnPtrInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ReturnPtrInst) + Type return_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Bitwise/intrinsic operations +// --------------------------------------------------------------------------- + +class MX_EXPORT BitwiseOpInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(BitwiseOpInst) + ir::BitwiseOp sub_opcode(void) const; + Type result_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Floating-point operations (FLOAT) +// --------------------------------------------------------------------------- + +class MX_EXPORT FloatOpInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(FloatOpInst) + ir::FloatOp sub_opcode(void) const; + Type result_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Frame/return address intrinsics +// --------------------------------------------------------------------------- + +class MX_EXPORT FramePtrInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(FramePtrInst) + IRInstruction level(void) const; // op[0] + Type result_type(void) const; +}; + +class MX_EXPORT ReturnAddressInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ReturnAddressInst) + IRInstruction level(void) const; // op[0] + Type result_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Undefined/poison value +// --------------------------------------------------------------------------- + +class MX_EXPORT UndefinedInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(UndefinedInst) + Type result_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Scope entry/exit +// --------------------------------------------------------------------------- + +class MX_EXPORT EnterScopeInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(EnterScopeInst) + IRStructure scope(void) const; +}; + +class MX_EXPORT ExitScopeInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ExitScopeInst) + IRStructure scope(void) const; +}; + +// --------------------------------------------------------------------------- +// Variadic +// --------------------------------------------------------------------------- + +class MX_EXPORT VAStartInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(VAStartInst) + IRInstruction va_list_operand(void) const; +}; + +class MX_EXPORT VAEndInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(VAEndInst) + IRInstruction va_list_operand(void) const; +}; + +class MX_EXPORT VACopyInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(VACopyInst) + IRInstruction dest(void) const; + IRInstruction src(void) const; +}; + +// ConsumeVAParam: reads the next variadic argument from va_list, memcpys +// it from the caller's EXPRESSION_SCOPE, increments the va_list index. +// This is a MemOp sub-opcode (CONSUME_VA_PARAM) but gets a dedicated class +// for ergonomic access. +class MX_EXPORT ConsumeVAParamInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(ConsumeVAParamInst) + IRInstruction va_list_operand(void) const; + Type result_type(void) const; +}; + +// --------------------------------------------------------------------------- +// Terminators +// --------------------------------------------------------------------------- + +class MX_EXPORT RetInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(RetInst) + std::optional return_value(void) const; +}; + +class MX_EXPORT BranchInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(BranchInst) + IRBlock target_block(void) const; +}; + +class MX_EXPORT CondBranchInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(CondBranchInst) + IRInstruction condition(void) const; + IRBlock true_block(void) const; + IRBlock false_block(void) const; +}; + +class MX_EXPORT SwitchInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(SwitchInst) + IRInstruction selector(void) const; + std::optional case_type(void) const; + gap::generator cases(void) const &; + unsigned num_cases(void) const; +}; + +class MX_EXPORT UnreachableInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(UnreachableInst) +}; + +class MX_EXPORT UnknownInst : public IRInstruction { + public: + MX_DECLARE_IR_INSTRUCTION(UnknownInst) +}; + +#undef MX_DECLARE_IR_INSTRUCTION + +} // namespace mx diff --git a/include/multiplier/IR/Interpret/Driver.h b/include/multiplier/IR/Interpret/Driver.h new file mode 100644 index 000000000..9c534d1b6 --- /dev/null +++ b/include/multiplier/IR/Interpret/Driver.h @@ -0,0 +1,61 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "Suspension.h" +#include "Value.h" + +namespace mx::ir::interpret { + +// The Driver resolves suspensions from the interpreter. +// Subclass to implement analysis-specific policies. +// +// ConcreteDriver: resolves everything concretely, aborts on symbolic. +// TaintDriver: tracks provenance, surfaces decisions to an agent. +// GuidedDriver: target-directed exploration with coverage coordination. +class Driver { + public: + virtual ~Driver(void) = default; + + // Resolve a conditional branch with unknown condition. + virtual BranchResolution ResolveBranch(const BranchSuspension &s) = 0; + + // Resolve a function call. + virtual CallResolution ResolveCall(const CallSuspension &s) = 0; + + // Resolve a load from a symbolic/unknown address. + virtual LoadResolution ResolveLoad(const LoadSuspension &s) = 0; + + // Resolve a store to a symbolic/unknown address. + virtual StoreResolution ResolveStore(const StoreSuspension &s) = 0; + + // Concretize a symbolic value. + virtual ConcretizeResolution ResolveConcretize( + const ConcretizeSuspension &s) = 0; +}; + +// Checker interface: plugged into the interpreter for memory safety checks. +// Multiple checkers can be registered; all fire on each relevant event. +class Checker { + public: + virtual ~Checker(void) = default; + + // Called before every memory access. + virtual void OnMemoryAccess(const Pointer &addr, uint32_t size, + bool is_write) {} + + // Called after pointer arithmetic. + virtual void OnPointerArithmetic(const Pointer &base, int64_t offset_bytes, + const Pointer &result) {} + + // Called on function entry. + virtual void OnCallEntry(const CallSuspension &call) {} + + // Called on function return. + virtual void OnCallReturn(const Value &return_value) {} +}; + +} // namespace mx::ir::interpret diff --git a/include/multiplier/IR/Interpret/Memory.h b/include/multiplier/IR/Interpret/Memory.h new file mode 100644 index 000000000..22290476e --- /dev/null +++ b/include/multiplier/IR/Interpret/Memory.h @@ -0,0 +1,55 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "Value.h" +#include +#include + +namespace mx::ir::interpret { + +// Abstract memory model. The interpreter handles endianness mechanics +// and calls Read/Write on this interface. Implementations own the storage. +// +// ConcreteMemory: flat byte arrays per object. +// ShadowMemory: tracks initialization, taint, allocation state. +// COW memory: O(1) fork for multi-path exploration. +class Memory { + public: + virtual ~Memory(void) = default; + + // Allocate a new memory object. Returns the object ID. + virtual uint32_t Allocate(uint32_t size_bytes, uint32_t align_bytes) = 0; + + // Free a previously allocated object. + virtual void Free(uint32_t object_id) = 0; + + // Read raw bytes from an object at an offset. + // Returns false if the access is out of bounds or the object is freed. + virtual bool Read(uint32_t object_id, int64_t offset, + void *dest, uint32_t size) = 0; + + // Write raw bytes to an object at an offset. + virtual bool Write(uint32_t object_id, int64_t offset, + const void *src, uint32_t size) = 0; + + // Bulk operations. + virtual bool Memset(uint32_t object_id, int64_t offset, + uint8_t value, uint32_t size) = 0; + virtual bool Memcpy(uint32_t dest_obj, int64_t dest_offset, + uint32_t src_obj, int64_t src_offset, + uint32_t size) = 0; + + // Query object metadata. + virtual uint32_t ObjectSize(uint32_t object_id) const = 0; + virtual bool IsAllocated(uint32_t object_id) const = 0; + + // Fork for multi-path exploration (COW). + // Returns a new Memory that shares state until written. + virtual std::unique_ptr Fork(void) const = 0; +}; + +} // namespace mx::ir::interpret diff --git a/include/multiplier/IR/Interpret/Suspension.h b/include/multiplier/IR/Interpret/Suspension.h new file mode 100644 index 000000000..a4824555d --- /dev/null +++ b/include/multiplier/IR/Interpret/Suspension.h @@ -0,0 +1,102 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "Value.h" +#include +#include +#include +#include + +namespace mx { +class FunctionDecl; +} + +namespace mx::ir::interpret { + +// The interpreter yields Suspensions at decision points. +// A Driver returns Resolutions to continue execution. + +// Branch with unknown (symbolic) condition. +struct BranchSuspension { + Value condition; + IRBlock true_block; + IRBlock false_block; +}; + +struct BranchResolution { + bool take_true{true}; + bool take_false{false}; // true = fork both paths +}; + +// Function call — driver decides: inline, skip, or model. +struct CallSuspension { + IRInstruction call_inst; + std::optional target; + std::vector arguments; + bool is_indirect{false}; +}; + +enum class CallAction { + INLINE, // Step into the callee's IR. + SKIP, // Return a default/symbolic value. + MODEL, // Driver provides the return value. +}; + +struct CallResolution { + CallAction action{CallAction::SKIP}; + Value return_value; // For SKIP/MODEL. +}; + +// Load from a symbolic or unknown address. +struct LoadSuspension { + Value address; + uint32_t size_bytes{0}; +}; + +struct LoadResolution { + Value value; +}; + +// Store to a symbolic or unknown address. +struct StoreSuspension { + Value address; + Value value; + uint32_t size_bytes{0}; +}; + +struct StoreResolution { + bool proceed{true}; +}; + +// Need to concretize a symbolic value. +struct ConcretizeSuspension { + Value symbolic_value; +}; + +struct ConcretizeResolution { + Value concrete_value; +}; + +// Union of all suspension types. +using Suspension = std::variant< + BranchSuspension, + CallSuspension, + LoadSuspension, + StoreSuspension, + ConcretizeSuspension +>; + +// Union of all resolution types. +using Resolution = std::variant< + BranchResolution, + CallResolution, + LoadResolution, + StoreResolution, + ConcretizeResolution +>; + +} // namespace mx::ir::interpret diff --git a/include/multiplier/IR/Interpret/Value.h b/include/multiplier/IR/Interpret/Value.h new file mode 100644 index 000000000..4fa12964a --- /dev/null +++ b/include/multiplier/IR/Interpret/Value.h @@ -0,0 +1,78 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include +#include + +namespace mx::ir::interpret { + +// A concrete scalar value: up to 8 bytes, type-punnable. +// The interpreter moves bytes around; the ValueFactory gives them meaning. +struct ScalarValue { + uint64_t bits{0}; + uint8_t width{0}; // 1, 2, 4, or 8 bytes + + static ScalarValue FromU64(uint64_t v, uint8_t w = 8) { + return {v, w}; + } + + static ScalarValue FromI64(int64_t v, uint8_t w = 8) { + uint64_t bits; + std::memcpy(&bits, &v, sizeof(bits)); + return {bits, w}; + } + + static ScalarValue FromF64(double v) { + uint64_t bits; + std::memcpy(&bits, &v, sizeof(bits)); + return {bits, 8}; + } + + static ScalarValue FromF32(float v) { + uint32_t bits; + std::memcpy(&bits, &v, sizeof(bits)); + return {bits, 4}; + } + + int64_t as_i64(void) const { + int64_t v; + std::memcpy(&v, &bits, sizeof(v)); + return v; + } + + double as_f64(void) const { + double v; + std::memcpy(&v, &bits, sizeof(v)); + return v; + } + + float as_f32(void) const { + uint32_t lo = static_cast(bits); + float v; + std::memcpy(&v, &lo, sizeof(v)); + return v; + } +}; + +// Sentinel for undefined/poison values. +struct Undefined {}; + +// Sentinel for a null pointer. +struct NullPtr {}; + +// A pointer into the interpreter's address space. +struct Pointer { + uint32_t object_id{0}; + int64_t offset{0}; +}; + +// The value type the interpreter passes around. +// Concrete implementation. A symbolic layer would extend/wrap this. +using Value = std::variant; + +} // namespace mx::ir::interpret diff --git a/include/multiplier/IR/Interpret/ValueFactory.h b/include/multiplier/IR/Interpret/ValueFactory.h new file mode 100644 index 000000000..4093cc41a --- /dev/null +++ b/include/multiplier/IR/Interpret/ValueFactory.h @@ -0,0 +1,52 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "Value.h" +#include +#include + +namespace mx::ir::interpret { + +// Abstract factory for value operations. The interpreter never performs +// arithmetic directly — it delegates to the factory. This enables: +// - ConcreteValueFactory: direct computation +// - SymbolicValueFactory: builds expression trees +// - TaintValueFactory: wraps inner factory with provenance tracking +// +// Factories compose: Taint(Symbolic(Concrete)). +class ValueFactory { + public: + virtual ~ValueFactory(void) = default; + + // Arithmetic. + virtual Value BinaryOp(OpCode op, const Value &lhs, const Value &rhs) = 0; + virtual Value UnaryOp(OpCode op, const Value &operand) = 0; + virtual Value Compare(OpCode op, const Value &lhs, const Value &rhs) = 0; + + // Cast. + virtual Value Cast(CastOp op, const Value &operand) = 0; + + // Constants. + virtual Value MakeConst(ConstOp op, int64_t signed_val, + uint64_t unsigned_val) = 0; + virtual Value MakeNullPtr(void) = 0; + + // Pointer arithmetic. + virtual Value PtrAdd(const Value &base, const Value &index, + int64_t element_size) = 0; + virtual Value PtrDiff(const Value &lhs, const Value &rhs, + int64_t element_size) = 0; + + // Truth test: returns true/false for concrete, nullopt for symbolic. + virtual std::optional IsTrue(const Value &val) = 0; + + // Select (ternary). + virtual Value Select(const Value &cond, const Value &if_true, + const Value &if_false) = 0; +}; + +} // namespace mx::ir::interpret diff --git a/include/multiplier/IR/Object.h b/include/multiplier/IR/Object.h new file mode 100644 index 000000000..7d07df17c --- /dev/null +++ b/include/multiplier/IR/Object.h @@ -0,0 +1,45 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "../Compiler.h" +#include "../Types.h" +#include "ObjectKind.h" +#include +#include + +namespace mx { + +class VarDecl; +class Type; +class IRObjectImpl; +using IRObjectImplPtr = std::shared_ptr; + +class MX_EXPORT IRObject { + private: + friend class EntityProvider; + friend class Index; + friend class IRFunction; + friend class IRInstruction; + IRObjectImplPtr impl; + + public: + IRObject(void) = default; + explicit IRObject(IRObjectImplPtr impl_) + : impl(std::move(impl_)) {} + + EntityId id(void) const; + ir::ObjectKind kind(void) const; + + std::optional source_declaration(void) const; + std::optional type(void) const; + uint32_t size_bytes(void) const; + uint32_t align_bytes(void) const; + bool needs_memory(void) const; + +}; + +} // namespace mx diff --git a/include/multiplier/IR/ObjectKind.h b/include/multiplier/IR/ObjectKind.h new file mode 100644 index 000000000..0733f883c --- /dev/null +++ b/include/multiplier/IR/ObjectKind.h @@ -0,0 +1,58 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include "../Compiler.h" + +namespace mx::ir { + +// Classification of IR memory objects. +enum class ObjectKind : uint8_t { + LOCAL = 0, // address-taken local variable (needs alloca/load/store) + LOCAL_VALUE = 1, // non-address-taken local (pure value, can be SSA) + PARAMETER = 2, // address-taken function parameter + PARAMETER_VALUE = 3, // non-address-taken parameter (pure value) + GLOBAL = 4, // global variable + THREAD_LOCAL = 5, // thread-local variable + STRING_LITERAL = 6, // string literal storage + COMPOUND_LITERAL = 7, // compound literal storage + RETURN_SLOT = 8, // implicit return value storage + ALLOCA = 9, // dynamic alloca (VLA, etc.) + HEAP = 10, // dynamically allocated (malloc, etc.) +}; + +inline static const char *EnumerationName(ObjectKind) { + return "ObjectKind"; +} + +MX_EXPORT const char *EnumeratorName(ObjectKind kind) noexcept; + +inline static constexpr unsigned NumEnumerators(ObjectKind) { + return 11u; +} + +// Is this an address-taken object that needs memory operations? +inline bool NeedsMemory(ObjectKind kind) { + switch (kind) { + case ObjectKind::LOCAL: + case ObjectKind::PARAMETER: + case ObjectKind::GLOBAL: + case ObjectKind::THREAD_LOCAL: + case ObjectKind::STRING_LITERAL: + case ObjectKind::COMPOUND_LITERAL: + case ObjectKind::RETURN_SLOT: + case ObjectKind::ALLOCA: + case ObjectKind::HEAP: + return true; + case ObjectKind::LOCAL_VALUE: + case ObjectKind::PARAMETER_VALUE: + return false; + } + return true; +} + +} // namespace mx::ir diff --git a/include/multiplier/IR/OpCode.h b/include/multiplier/IR/OpCode.h new file mode 100644 index 000000000..f72daf314 --- /dev/null +++ b/include/multiplier/IR/OpCode.h @@ -0,0 +1,575 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include "../Compiler.h" + +namespace mx::ir { + +// Sub-opcodes for CONST. Stored in the int pool (int_pool[0]). +// Encodes both the type and width of the constant. +enum class ConstOp : uint8_t { + INT8 = 0, + INT16 = 1, + INT32 = 2, + INT64 = 3, + UINT8 = 4, + UINT16 = 5, + UINT32 = 6, + UINT64 = 7, + FLOAT32 = 8, + FLOAT64 = 9, + FLOAT16 = 10, + NULL_PTR = 11, + INF32 = 12, + INF64 = 13, + NAN32 = 14, + NAN64 = 15, + WCHAR16 = 16, + WCHAR32 = 17, + BOOL = 18, +}; + +// Sub-opcodes for ALLOCA. Stored in the int pool (int_pool[0]). +enum class AllocaKind : uint8_t { + LOCAL = 0, // regular local variable + ARG = 1, // argument passing alloca in EXPRESSION_SCOPE + RETURN = 2, // return value storage in EXPRESSION_SCOPE + DYNAMIC = 3, // runtime-sized (VLA, alloca()) +}; + +// Sub-opcodes for CAST. Stored in the int pool (int_pool[0]). +enum class CastOp : uint8_t { + // Sign-extend + SEXT_I8_I16 = 0, + SEXT_I8_I32, + SEXT_I8_I64, + SEXT_I16_I32, + SEXT_I16_I64, + SEXT_I32_I64, + + // Zero-extend + ZEXT_I8_I16, + ZEXT_I8_I32, + ZEXT_I8_I64, + ZEXT_I16_I32, + ZEXT_I16_I64, + ZEXT_I32_I64, + + // Truncate + TRUNC_I16_I8, + TRUNC_I32_I8, + TRUNC_I64_I8, + TRUNC_I32_I16, + TRUNC_I64_I16, + TRUNC_I64_I32, + + // Float widening/narrowing + F32_TO_F64, + F64_TO_F32, + + // Signed int to float + SI8_TO_F32, + SI8_TO_F64, + SI16_TO_F32, + SI16_TO_F64, + SI32_TO_F32, + SI32_TO_F64, + SI64_TO_F32, + SI64_TO_F64, + + // Unsigned int to float + UI8_TO_F32, + UI8_TO_F64, + UI16_TO_F32, + UI16_TO_F64, + UI32_TO_F32, + UI32_TO_F64, + UI64_TO_F32, + UI64_TO_F64, + + // Float to signed int + F32_TO_SI8, + F32_TO_SI16, + F32_TO_SI32, + F32_TO_SI64, + F64_TO_SI8, + F64_TO_SI16, + F64_TO_SI32, + F64_TO_SI64, + + // Float to unsigned int + F32_TO_UI8, + F32_TO_UI16, + F32_TO_UI32, + F32_TO_UI64, + F64_TO_UI8, + F64_TO_UI16, + F64_TO_UI32, + F64_TO_UI64, + + // Pointer conversions + PTR_TO_I32, + PTR_TO_I64, + I32_TO_PTR, + I64_TO_PTR, + + // Bitcast (reinterpret bits, same size) + BITCAST, + + // Identity (no-op, replaces COPY for implicit conversions) + IDENTITY, +}; + +// CastOp classification helpers. +inline bool IsSignExtend(CastOp op) { + return op >= CastOp::SEXT_I8_I16 && op <= CastOp::SEXT_I32_I64; +} + +inline bool IsZeroExtend(CastOp op) { + return op >= CastOp::ZEXT_I8_I16 && op <= CastOp::ZEXT_I32_I64; +} + +inline bool IsTruncate(CastOp op) { + return op >= CastOp::TRUNC_I16_I8 && op <= CastOp::TRUNC_I64_I32; +} + +inline bool IsIntToFloat(CastOp op) { + return op >= CastOp::SI8_TO_F32 && op <= CastOp::UI64_TO_F64; +} + +inline bool IsFloatToInt(CastOp op) { + return op >= CastOp::F32_TO_SI8 && op <= CastOp::F64_TO_UI64; +} + +// Single unified opcode enum for all IR instruction types. The C++ class +// hierarchy on the read side is derived from this enum. +enum class OpCode : uint8_t { + // Constant (sub-opcode in int_pool[0] selects ConstOp). + CONST = 0, + + // Memory (ALLOCA sub-opcode in int_pool[0] selects AllocaKind). + ALLOCA = 1, + MEMORY = 2, // Unified load/store/bulk/string (sub-opcode in int_pool[0] selects MemOp). + + // Logical (produce 0 or 1, no width). + LOGICAL_AND = 15, + LOGICAL_OR = 16, + + LOGICAL_NOT = 26, + + // Cast (sub-opcode in int_pool[0] selects CastOp). + CAST = 27, + + // Call + CALL = 28, + + // Read-modify-write: reads from address, applies an operation, writes back. + // operands = [address, rhs_operand0, rhs_operand1, ...]. + // The loaded value is the implicit LHS of the underlying op. + // flags: bit 0 = returns new value (1) or old value (0, post-increment). + // int_pool[0] = underlying opcode (ADD, SUB, PTR_ADD, ATOMIC_ADD, etc.) + // int_pool[1] = element size (for PTR_ADD only, 0 otherwise) + // int_pool[2] = is_big_endian (0 = little-endian, 1 = big-endian) + READ_MODIFY_WRITE = 29, + + // Misc + SELECT = 30, + + // Terminators + COND_BRANCH = 31, + SWITCH = 32, + RET = 33, + UNREACHABLE = 34, + BREAK = 35, + CONTINUE = 36, + GOTO = 37, // explicit goto label; + IMPLICIT_GOTO = 38, // structural CFG edge (e.g., end of if-then -> merge) + FALLTHROUGH = 39, // explicit [[fallthrough]] + IMPLICIT_FALLTHROUGH = 40, // implicit (no break at end of case) + IMPLICIT_UNREACHABLE = 41, // structurally unreachable (patched empty block) + + // Variadic argument handling + VA_START = 43, // binds va_list to function's variadic pack; op[0] = va_list + VA_COPY = 45, // copies va_list; op[0] = dest, op[1] = src + VA_END = 46, // releases va_list; op[0] = va_list + + // Scope entry/exit markers (not terminators). + ENTER_SCOPE = 47, // marks scope entry; extra = IRStructureId of scope + EXIT_SCOPE = 48, // marks scope exit; extra = IRStructureId of scope + + // (Pointer-producing ops are sized: see GEP_FIELD_32/64, PTR_ADD_32/64, + // PARAM_PTR_32/64, GLOBAL_PTR_32/64, etc. at the end of the enum.) + + // (BITWISE and ABS are sized: see end of enum.) + + // Floating-point operations. Sub-opcode in int_pool[0] selects the + // specific operation (see FloatOp enum). op[0] = primary operand. + FLOAT = 54, + + // Undefined/poison value. Represents a value that is architecturally + // undefined (e.g., __builtin_clz(0)). An analyzer should flag any use. + UNDEFINED = 55, + + // (FRAME_PTR and RETURN_ADDRESS are sized: see end of enum.) + + // (Overflow and atomic ops are sized: see end of enum.) + + // Evaluate all operands, return the last one's value. + LAST_VALUE = 69, + + // Unknown / unhandled expression + UNKNOWN = 70, + + // (RETURN_PTR is sized: see end of enum.) + + // Floating-point comparisons (IEEE 754 semantics, width-specific). + FCMP_EQ_32 = 79, FCMP_EQ_64 = 80, + FCMP_NE_32 = 81, FCMP_NE_64 = 82, + FCMP_LT_32 = 83, FCMP_LT_64 = 84, + FCMP_LE_32 = 85, FCMP_LE_64 = 86, + FCMP_GT_32 = 87, FCMP_GT_64 = 88, + FCMP_GE_32 = 89, FCMP_GE_64 = 90, + + // Floating-point arithmetic (width-specific). + // Integer ADD/SUB/MUL/DIV/REM must not be used for float operands. + FADD_32 = 91, FADD_64 = 92, + FSUB_32 = 93, FSUB_64 = 94, + FMUL_32 = 95, FMUL_64 = 96, + FDIV_32 = 97, FDIV_64 = 98, + FREM_32 = 99, FREM_64 = 100, // C fmod semantics. + FNEG_32 = 101, FNEG_64 = 102, + + // Width-specific integer arithmetic (signed). + ADD_8 = 103, ADD_16 = 104, ADD_32 = 105, ADD_64 = 106, + SUB_8 = 107, SUB_16 = 108, SUB_32 = 109, SUB_64 = 110, + MUL_8 = 111, MUL_16 = 112, MUL_32 = 113, MUL_64 = 114, + DIV_8 = 115, DIV_16 = 116, DIV_32 = 117, DIV_64 = 118, + REM_8 = 119, REM_16 = 120, REM_32 = 121, REM_64 = 122, + + // Width-specific unsigned arithmetic. + UDIV_8 = 123, UDIV_16 = 124, UDIV_32 = 125, UDIV_64 = 126, + UREM_8 = 127, UREM_16 = 128, UREM_32 = 129, UREM_64 = 130, + USHR_8 = 131, USHR_16 = 132, USHR_32 = 133, USHR_64 = 134, + + // Width-specific bitwise operations. + BIT_AND_8 = 135, BIT_AND_16 = 136, BIT_AND_32 = 137, BIT_AND_64 = 138, + BIT_OR_8 = 139, BIT_OR_16 = 140, BIT_OR_32 = 141, BIT_OR_64 = 142, + BIT_XOR_8 = 143, BIT_XOR_16 = 144, BIT_XOR_32 = 145, BIT_XOR_64 = 146, + SHL_8 = 147, SHL_16 = 148, SHL_32 = 149, SHL_64 = 150, + SHR_8 = 151, SHR_16 = 152, SHR_32 = 153, SHR_64 = 154, + + // Width-specific signed comparisons. + CMP_EQ_8 = 155, CMP_EQ_16 = 156, CMP_EQ_32 = 157, CMP_EQ_64 = 158, + CMP_NE_8 = 159, CMP_NE_16 = 160, CMP_NE_32 = 161, CMP_NE_64 = 162, + CMP_LT_8 = 163, CMP_LT_16 = 164, CMP_LT_32 = 165, CMP_LT_64 = 166, + CMP_LE_8 = 167, CMP_LE_16 = 168, CMP_LE_32 = 169, CMP_LE_64 = 170, + CMP_GT_8 = 171, CMP_GT_16 = 172, CMP_GT_32 = 173, CMP_GT_64 = 174, + CMP_GE_8 = 175, CMP_GE_16 = 176, CMP_GE_32 = 177, CMP_GE_64 = 178, + + // Width-specific unsigned comparisons. + UCMP_LT_8 = 179, UCMP_LT_16 = 180, UCMP_LT_32 = 181, UCMP_LT_64 = 182, + UCMP_LE_8 = 183, UCMP_LE_16 = 184, UCMP_LE_32 = 185, UCMP_LE_64 = 186, + UCMP_GT_8 = 187, UCMP_GT_16 = 188, UCMP_GT_32 = 189, UCMP_GT_64 = 190, + UCMP_GE_8 = 191, UCMP_GE_16 = 192, UCMP_GE_32 = 193, UCMP_GE_64 = 194, + + // Width-specific unary operations. + NEG_8 = 195, NEG_16 = 196, NEG_32 = 197, NEG_64 = 198, + BIT_NOT_8 = 199, BIT_NOT_16 = 200, BIT_NOT_32 = 201, BIT_NOT_64 = 202, + + // Width-specific pointer operations. + PTR_ADD_32 = 203, PTR_ADD_64 = 204, + GEP_FIELD_32 = 205, GEP_FIELD_64 = 206, + GLOBAL_PTR_32 = 207, GLOBAL_PTR_64 = 208, + THREAD_LOCAL_PTR_32 = 209, THREAD_LOCAL_PTR_64 = 210, + FUNC_PTR_32 = 211, FUNC_PTR_64 = 212, + STRING_PTR_32 = 213, STRING_PTR_64 = 214, + PARAM_PTR_32 = 215, PARAM_PTR_64 = 216, + FRAME_PTR_32 = 217, FRAME_PTR_64 = 218, + RETURN_PTR_32 = 219, RETURN_PTR_64 = 220, + RETURN_ADDRESS_32 = 221, RETURN_ADDRESS_64 = 222, + + // Width-specific atomic RMW underlying opcodes. + ATOMIC_ADD_8 = 223, ATOMIC_ADD_16 = 224, ATOMIC_ADD_32 = 225, ATOMIC_ADD_64 = 226, + ATOMIC_SUB_8 = 227, ATOMIC_SUB_16 = 228, ATOMIC_SUB_32 = 229, ATOMIC_SUB_64 = 230, + ATOMIC_AND_8 = 231, ATOMIC_AND_16 = 232, ATOMIC_AND_32 = 233, ATOMIC_AND_64 = 234, + ATOMIC_OR_8 = 235, ATOMIC_OR_16 = 236, ATOMIC_OR_32 = 237, ATOMIC_OR_64 = 238, + ATOMIC_XOR_8 = 239, ATOMIC_XOR_16 = 240, ATOMIC_XOR_32 = 241, ATOMIC_XOR_64 = 242, + ATOMIC_NAND_8 = 243, ATOMIC_NAND_16 = 244, ATOMIC_NAND_32 = 245, ATOMIC_NAND_64 = 246, + ATOMIC_EXCHANGE_8 = 247, ATOMIC_EXCHANGE_16 = 248, ATOMIC_EXCHANGE_32 = 249, ATOMIC_EXCHANGE_64 = 250, + + // Width-specific overflow-checked arithmetic (RMW underlying opcodes). + // Placed in gap left by removed unsized opcodes (56-67). + ADD_OVERFLOW_8 = 56, ADD_OVERFLOW_16 = 57, ADD_OVERFLOW_32 = 58, ADD_OVERFLOW_64 = 59, + SUB_OVERFLOW_8 = 60, SUB_OVERFLOW_16 = 61, SUB_OVERFLOW_32 = 62, SUB_OVERFLOW_64 = 63, + MUL_OVERFLOW_8 = 64, MUL_OVERFLOW_16 = 65, MUL_OVERFLOW_32 = 66, MUL_OVERFLOW_64 = 67, + + // Width-specific pointer difference (result is ptrdiff_t). + PTR_DIFF_32 = 3, PTR_DIFF_64 = 4, + + // Width-specific bitwise intrinsics (sub-opcode in int_pool[0] selects BitwiseOp). + BITWISE_8 = 5, BITWISE_16 = 6, BITWISE_32 = 7, BITWISE_64 = 8, + + // Width-specific integer absolute value. + ABS_8 = 9, ABS_16 = 10, ABS_32 = 11, ABS_64 = 12, +}; + +// Returns the human-readable name of an opcode. +inline static const char *EnumerationName(OpCode) { + return "OpCode"; +} + +MX_EXPORT const char *EnumeratorName(OpCode op) noexcept; +MX_EXPORT const char *EnumeratorName(ConstOp op) noexcept; +MX_EXPORT const char *EnumeratorName(AllocaKind op) noexcept; +MX_EXPORT const char *EnumeratorName(CastOp op) noexcept; + +inline static constexpr unsigned NumEnumerators(OpCode) { + return 251u; +} + +// Sub-opcodes for MEMORY. Stored in the int pool (int_pool[0]). +// Encodes direction (load/store), atomicity, endianness, access width, +// plus bulk memory and string operations. +enum class MemOp : uint8_t { + // Loads (non-atomic, little-endian) + LOAD_LE_8 = 0, LOAD_LE_16 = 1, LOAD_LE_32 = 2, LOAD_LE_64 = 3, + // Loads (non-atomic, big-endian) + LOAD_BE_8 = 4, LOAD_BE_16 = 5, LOAD_BE_32 = 6, LOAD_BE_64 = 7, + // Stores (non-atomic, little-endian) + STORE_LE_8 = 8, STORE_LE_16 = 9, STORE_LE_32 = 10, STORE_LE_64 = 11, + // Stores (non-atomic, big-endian) + STORE_BE_8 = 12, STORE_BE_16 = 13, STORE_BE_32 = 14, STORE_BE_64 = 15, + // Atomic loads (little-endian) + ATOMIC_LOAD_LE_8 = 16, ATOMIC_LOAD_LE_16 = 17, ATOMIC_LOAD_LE_32 = 18, ATOMIC_LOAD_LE_64 = 19, + // Atomic loads (big-endian) + ATOMIC_LOAD_BE_8 = 20, ATOMIC_LOAD_BE_16 = 21, ATOMIC_LOAD_BE_32 = 22, ATOMIC_LOAD_BE_64 = 23, + // Atomic stores (little-endian) + ATOMIC_STORE_LE_8 = 24, ATOMIC_STORE_LE_16 = 25, ATOMIC_STORE_LE_32 = 26, ATOMIC_STORE_LE_64 = 27, + // Atomic stores (big-endian) + ATOMIC_STORE_BE_8 = 28, ATOMIC_STORE_BE_16 = 29, ATOMIC_STORE_BE_32 = 30, ATOMIC_STORE_BE_64 = 31, + + // Memory operations. + MEMSET = 32, MEMCPY = 33, MEMMOVE = 34, MEMCMP = 35, MEMCHR = 36, BZERO = 37, + // String operations. + STRLEN = 38, STRNLEN = 39, STRCMP = 40, STRNCMP = 41, STRCHR = 42, STRRCHR = 43, + STRSTR = 44, STRCPY = 45, STRNCPY = 46, STRCAT = 47, STRNCAT = 48, STPCPY = 49, STPNCPY = 50, + // String-to-number. + STRTOI32 = 51, STRTOI64 = 52, STRTOU32 = 53, STRTOU64 = 54, STRTOF32 = 55, STRTOF64 = 56, + + // Bit-field access. Reads/writes individual bit ranges within memory. + // + // Addressing model: + // The address operand (op[0]) points to the base of the containing + // object (e.g., the struct). bit_offset is measured from the LSB of + // the first byte at that address, in the target's bit numbering: + // + // Little-endian: bit 0 is the LSB of byte 0. bit_offset=10, width=5 + // means bits [10..14] spanning bytes 1-2: + // byte 0: [7:0] byte 1: [15:8] byte 2: [23:16] + // field occupies byte1[2:0] and byte2[1:0] + // + // Big-endian: bit 0 is the MSB of byte 0. Layout is reversed. + // + // int_pool layout: [MemOp sub-opcode, bit_offset, bit_width] + // bit_offset and bit_width are compile-time constants (not operands). + // + // Bit-field access (see documentation above). + BIT_READ_LE = 57, BIT_WRITE_LE = 58, + BIT_READ_BE = 59, BIT_WRITE_BE = 60, + + // Atomic compare-and-exchange (sized, endian-aware). + // op[0]=target, op[1]=expected_ptr, op[2]=desired. Returns bool. + CMPXCHG_LE_8 = 61, CMPXCHG_LE_16 = 62, CMPXCHG_LE_32 = 63, CMPXCHG_LE_64 = 64, + CMPXCHG_BE_8 = 65, CMPXCHG_BE_16 = 66, CMPXCHG_BE_32 = 67, CMPXCHG_BE_64 = 68, + + // Variadic argument consumption. op[0]=va_list_ptr. Reads the current + // va_list index, memcpys from the corresponding variadic argument alloca + // in the caller's EXPRESSION_SCOPE, then increments the va_list index. + // type_entity_id specifies the type/size being consumed. + CONSUME_VA_PARAM = 69, + + // Float loads/stores (non-atomic). + LOAD_F32_LE = 70, LOAD_F64_LE = 71, + LOAD_F32_BE = 72, LOAD_F64_BE = 73, + STORE_F32_LE = 74, STORE_F64_LE = 75, + STORE_F32_BE = 76, STORE_F64_BE = 77, +}; + +// MemOp classification helpers. +inline bool IsLoad(MemOp op) { return static_cast(op) < 8; } +inline bool IsStore(MemOp op) { auto v = static_cast(op); return v >= 8 && v < 16; } +inline bool IsAtomicLoad(MemOp op) { auto v = static_cast(op); return v >= 16 && v < 24; } +inline bool IsAtomicStore(MemOp op) { auto v = static_cast(op); return v >= 24 && v < 32; } +inline bool IsFloatLoad(MemOp op) { return op >= MemOp::LOAD_F32_LE && op <= MemOp::LOAD_F64_BE; } +inline bool IsFloatStore(MemOp op) { return op >= MemOp::STORE_F32_LE && op <= MemOp::STORE_F64_BE; } +inline bool IsAnyLoad(MemOp op) { return IsLoad(op) || IsAtomicLoad(op) || IsFloatLoad(op); } +inline bool IsAnyStore(MemOp op) { return IsStore(op) || IsAtomicStore(op) || IsFloatStore(op); } +inline bool IsAtomic(MemOp op) { return static_cast(op) >= 16 && static_cast(op) < 32; } +inline bool IsBigEndian(MemOp op) { + if (static_cast(op) < 32) return (static_cast(op) % 8) >= 4; + if (IsFloatLoad(op) || IsFloatStore(op)) { + return op == MemOp::LOAD_F32_BE || op == MemOp::LOAD_F64_BE || + op == MemOp::STORE_F32_BE || op == MemOp::STORE_F64_BE; + } + return false; +} +inline unsigned AccessSize(MemOp op) { + if (static_cast(op) < 32) { + switch (static_cast(op) % 4) { case 0: return 1; case 1: return 2; case 2: return 4; case 3: return 8; } + } + if (IsFloatLoad(op) || IsFloatStore(op)) { + return (op == MemOp::LOAD_F32_LE || op == MemOp::LOAD_F32_BE || + op == MemOp::STORE_F32_LE || op == MemOp::STORE_F32_BE) ? 4 : 8; + } + return 0; +} +inline bool IsDirectLoadStore(MemOp op) { + return static_cast(op) < 32 || IsFloatLoad(op) || IsFloatStore(op); +} +inline bool IsStringToNumber(MemOp op) { return op >= MemOp::STRTOI32 && op <= MemOp::STRTOF64; } +inline bool IsMemoryBulk(MemOp op) { return op >= MemOp::MEMSET && op <= MemOp::BZERO; } +inline bool IsStringOp(MemOp op) { return op >= MemOp::STRLEN && op <= MemOp::STPNCPY; } +inline bool IsBitAccess(MemOp op) { return op >= MemOp::BIT_READ_LE && op <= MemOp::BIT_WRITE_BE; } +inline bool IsCmpxchg(MemOp op) { return op >= MemOp::CMPXCHG_LE_8 && op <= MemOp::CMPXCHG_BE_64; } +inline bool IsBitRead(MemOp op) { return op == MemOp::BIT_READ_LE || op == MemOp::BIT_READ_BE; } +inline bool IsBitWrite(MemOp op) { return op == MemOp::BIT_WRITE_LE || op == MemOp::BIT_WRITE_BE; } + +// Sub-opcodes for BITWISE_8/16/32/64. Stored in the int pool. +// Width comes from the parent opcode, not the sub-opcode (except BSWAP +// which has its own width in the name since only 16/32/64 make sense). +enum class BitwiseOp : uint8_t { + BSWAP_16 = 0, // Reverse bytes of 16-bit value. + BSWAP_32 = 1, // Reverse bytes of 32-bit value. + BSWAP_64 = 2, // Reverse bytes of 64-bit value. + POPCOUNT = 3, // Number of set bits. + CLZ = 4, // Count leading zeros. UNDEFINED for 0. + CTZ = 5, // Count trailing zeros. UNDEFINED for 0. + FFS = 6, // Find first set (1-indexed). 0 for input 0. + PARITY = 7, // 1 if odd number of set bits. + ROTL = 8, // Rotate left. op[0]=value, op[1]=amount. + ROTR = 9, // Rotate right. op[0]=value, op[1]=amount. +}; + +// Sub-opcodes for FLOAT. Stored in the int pool. +// Each operation has _32 (float) and _64 (double) variants. +// Laid out as pairs: _32 at even indices, _64 at odd. +enum class FloatOp : uint8_t { + ISNAN_32 = 0, ISNAN_64 = 1, // Returns bool. + ISINF_32 = 2, ISINF_64 = 3, // Returns bool. + ISFINITE_32 = 4, ISFINITE_64 = 5, // Returns bool. + FABS_32 = 6, FABS_64 = 7, // Returns |x|. + COPYSIGN_32 = 8, COPYSIGN_64 = 9, // op[0]=x, op[1]=y. Returns x with sign of y. + FMIN_32 = 10, FMIN_64 = 11, // Returns min. + FMAX_32 = 12, FMAX_64 = 13, // Returns max. + CEIL_32 = 14, CEIL_64 = 15, // Returns ceil(x). + FLOOR_32 = 16, FLOOR_64 = 17, // Returns floor(x). + ROUND_32 = 18, ROUND_64 = 19, // Returns round(x). + TRUNC_32 = 20, TRUNC_64 = 21, // Returns trunc(x). + SQRT_32 = 22, SQRT_64 = 23, // Returns sqrt(x). UNDEFINED for negative. + INF_32 = 24, INF_64 = 25, // No operands. Returns +infinity. + NAN_32 = 26, NAN_64 = 27, // No operands. Returns NaN. + HUGE_32 = 28, HUGE_64 = 29, // No operands. Returns HUGE_VAL. + SIN_32 = 30, SIN_64 = 31, + COS_32 = 32, COS_64 = 33, + TAN_32 = 34, TAN_64 = 35, + ASIN_32 = 36, ASIN_64 = 37, // UNDEFINED for |x|>1. + ACOS_32 = 38, ACOS_64 = 39, // UNDEFINED for |x|>1. + ATAN_32 = 40, ATAN_64 = 41, + ATAN2_32 = 42, ATAN2_64 = 43, // op[0]=y, op[1]=x. + EXP_32 = 44, EXP_64 = 45, + EXP2_32 = 46, EXP2_64 = 47, + LOG_32 = 48, LOG_64 = 49, // UNDEFINED for x<=0. + LOG2_32 = 50, LOG2_64 = 51, + LOG10_32 = 52, LOG10_64 = 53, + POW_32 = 54, POW_64 = 55, // op[0]=base, op[1]=exp. + FMOD_32 = 56, FMOD_64 = 57, // C fmod. + REMAINDER_32 = 58, REMAINDER_64 = 59, // IEEE remainder. + FMA_32 = 60, FMA_64 = 61, // op[0]=x, op[1]=y, op[2]=z. x*y+z. + SINH_32 = 62, SINH_64 = 63, + COSH_32 = 64, COSH_64 = 65, + TANH_32 = 66, TANH_64 = 67, + HYPOT_32 = 68, HYPOT_64 = 69, // sqrt(x^2+y^2). + ERF_32 = 70, ERF_64 = 71, + ERFC_32 = 72, ERFC_64 = 73, + TGAMMA_32 = 74, TGAMMA_64 = 75, + LGAMMA_32 = 76, LGAMMA_64 = 77, + FDIM_32 = 78, FDIM_64 = 79, // max(x-y, 0). + SIGNBIT_32 = 80, SIGNBIT_64 = 81, // Returns bool. +}; + +// Classification helpers. +inline bool IsTerminator(OpCode op) { + return op >= OpCode::COND_BRANCH && op <= OpCode::IMPLICIT_UNREACHABLE; +} + +inline bool IsReadModifyWrite(OpCode op) { + return op == OpCode::READ_MODIFY_WRITE; +} + +inline bool IsConstant(OpCode op) { + return op == OpCode::CONST; +} + +inline bool IsBinaryOp(OpCode op) { + return op == OpCode::LOGICAL_AND || op == OpCode::LOGICAL_OR || + op == OpCode::PTR_DIFF_32 || op == OpCode::PTR_DIFF_64 || + (op >= OpCode::FCMP_EQ_32 && op <= OpCode::FCMP_GE_64) || + (op >= OpCode::FADD_32 && op <= OpCode::FREM_64) || + (op >= OpCode::ADD_8 && op <= OpCode::SHR_64) || + (op >= OpCode::CMP_EQ_8 && op <= OpCode::UCMP_GE_64); +} + +inline bool IsFloatArithmetic(OpCode op) { + return op >= OpCode::FADD_32 && op <= OpCode::FNEG_64; +} + +inline bool IsComparison(OpCode op) { + return (op >= OpCode::FCMP_EQ_32 && op <= OpCode::FCMP_GE_64) || + (op >= OpCode::CMP_EQ_8 && op <= OpCode::UCMP_GE_64); +} + +inline bool IsFloatComparison(OpCode op) { + return op >= OpCode::FCMP_EQ_32 && op <= OpCode::FCMP_GE_64; +} + +inline bool IsUnaryOp(OpCode op) { + return op == OpCode::LOGICAL_NOT || + op == OpCode::FNEG_32 || op == OpCode::FNEG_64 || + (op >= OpCode::NEG_8 && op <= OpCode::BIT_NOT_64) || + (op >= OpCode::ABS_8 && op <= OpCode::ABS_64); +} + +inline bool IsCast(OpCode op) { + return op == OpCode::CAST; +} + +inline bool IsPtrOp(OpCode op) { + return (op >= OpCode::PTR_ADD_32 && op <= OpCode::RETURN_ADDRESS_64); +} + +inline bool IsMemoryOp(OpCode op) { + return op == OpCode::MEMORY || op == OpCode::ALLOCA || + (op >= OpCode::GEP_FIELD_32 && op <= OpCode::GEP_FIELD_64) || + (op >= OpCode::PTR_ADD_32 && op <= OpCode::PTR_ADD_64); +} + +// MemOp write classification (bulk ops that write to memory). +inline bool IsMemoryWrite(MemOp op) { + return IsAnyStore(op) || + op == MemOp::MEMSET || op == MemOp::MEMCPY || + op == MemOp::MEMMOVE || op == MemOp::BZERO || + op == MemOp::STRCPY || op == MemOp::STRNCPY || + op == MemOp::STRCAT || op == MemOp::STRNCAT || + op == MemOp::STPCPY || op == MemOp::STPNCPY; +} + +MX_EXPORT const char *EnumeratorName(MemOp op) noexcept; +MX_EXPORT const char *EnumeratorName(BitwiseOp op) noexcept; +MX_EXPORT const char *EnumeratorName(FloatOp op) noexcept; + +} // namespace mx::ir diff --git a/include/multiplier/IR/Structure.h b/include/multiplier/IR/Structure.h new file mode 100644 index 000000000..c59dc8d0a --- /dev/null +++ b/include/multiplier/IR/Structure.h @@ -0,0 +1,72 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "../Compiler.h" +#include "../Types.h" +#include "StructureKind.h" +#include +#include +#include + +namespace mx { + +class IRBlock; +class IRFunction; +class IRObject; +class IRStructureImpl; +class Stmt; +using IRStructureImplPtr = std::shared_ptr; + +class MX_EXPORT IRStructure { + protected: + friend class EntityProvider; + friend class Index; + friend class IRBlock; + friend class IRFunction; + IRStructureImplPtr impl; + + // For derived structure classes. + friend class IRScopeStructure; + friend class IRIfStructure; + friend class IRIfThenStructure; + friend class IRIfElseStructure; + friend class IRForStructure; + friend class IRWhileStructure; + friend class IRDoWhileStructure; + friend class IRSwitchStructure; + friend class IRSwitchCaseStructure; + friend class IRExpressionScopeStructure; + IRStructureImplPtr impl_ptr(void) const { return impl; } + + public: + IRStructure(void) = default; + explicit IRStructure(IRStructureImplPtr impl_) + : impl(std::move(impl_)) {} + + EntityId id(void) const; + ir::StructureKind kind(void) const; + + // AST provenance: the CompoundStmt, IfStmt, ForStmt, etc. + std::optional source_statement(void) const; + + // Parent: another structure or function. + std::optional parent_structure(void) const; + std::optional parent_function(void) const; + + // Children (structures and blocks in source order). + gap::generator child_structures(void) const &; + gap::generator child_blocks(void) const &; + + // Scope-specific: objects (ALLOCAs) declared in this scope. + // Only meaningful for FUNCTION_SCOPE and SCOPE kinds. + gap::generator objects(void) const &; + + // Convenience: scope-kind check. + bool is_scope(void) const; +}; + +} // namespace mx diff --git a/include/multiplier/IR/StructureKind.h b/include/multiplier/IR/StructureKind.h new file mode 100644 index 000000000..67d51275b --- /dev/null +++ b/include/multiplier/IR/StructureKind.h @@ -0,0 +1,70 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include "../Compiler.h" // MX_EXPORT + +namespace mx::ir { + +// Structural entities in the IR hierarchy. These represent the nesting +// structure of the program: scopes, control flow regions, etc. +// Every block has a parent structure, and structures form a tree rooted +// at the function's FUNCTION_SCOPE. +enum class StructureKind : uint8_t { + // Scopes (lexical blocks with variable lifetimes). + FUNCTION_SCOPE = 0, // function body CompoundStmt + SCOPE = 1, // nested CompoundStmt + + // If statement parts. + IF = 2, // the whole if statement + IF_THEN = 3, // then branch + IF_ELSE = 4, // else branch + + // For loop parts. + FOR = 5, // the whole for loop + FOR_INIT = 6, // for(init; ...) + FOR_CONDITION = 7, // for(...; cond; ...) + FOR_BODY = 8, // loop body + FOR_INCREMENT = 9, // for(...; ...; inc) + + // While loop parts. + WHILE = 10, // the whole while loop + WHILE_CONDITION = 11, + WHILE_BODY = 12, + + // Do-while loop parts. + DO_WHILE = 13, // the whole do-while + DO_WHILE_BODY = 14, + DO_WHILE_CONDITION = 15, + + // Switch statement parts. + SWITCH = 16, // the whole switch + SWITCH_CASE = 17, // individual case/default + + // Expression scope: holds argument/return allocas for all calls + // within a full-expression. Extends to the enclosing `;`. + EXPRESSION_SCOPE = 18, +}; + +inline static const char *EnumerationName(StructureKind) { + return "StructureKind"; +} + +MX_EXPORT const char *EnumeratorName(StructureKind kind) noexcept; + +inline static constexpr unsigned NumEnumerators(StructureKind) { + return 19u; +} + +// Classification helpers. +inline bool IsScope(StructureKind kind) { + return kind == StructureKind::FUNCTION_SCOPE || + kind == StructureKind::SCOPE || + kind == StructureKind::EXPRESSION_SCOPE; +} + +} // namespace mx::ir diff --git a/include/multiplier/IR/StructureKinds.h b/include/multiplier/IR/StructureKinds.h new file mode 100644 index 000000000..36057326d --- /dev/null +++ b/include/multiplier/IR/StructureKinds.h @@ -0,0 +1,124 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include "Structure.h" +#include "StructureKind.h" +#include "Block.h" + +namespace mx { + +class Type; + +// Helper macro for derived structure classes. +#define MX_DECLARE_IR_STRUCTURE(ClassName) \ + explicit ClassName(IRStructureImplPtr impl_) \ + : IRStructure(std::move(impl_)) {} \ + static std::optional from(const IRStructure &s); + +// --------------------------------------------------------------------------- +// Scopes +// --------------------------------------------------------------------------- + +// FUNCTION_SCOPE or SCOPE. Tracks variable lifetimes. +class MX_EXPORT IRScopeStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRScopeStructure) + // objects() is inherited from IRStructure. +}; + +// --------------------------------------------------------------------------- +// If statement +// --------------------------------------------------------------------------- + +class MX_EXPORT IRIfStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRIfStructure) + std::optional then_branch(void) const; + std::optional else_branch(void) const; +}; + +class MX_EXPORT IRIfThenStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRIfThenStructure) +}; + +class MX_EXPORT IRIfElseStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRIfElseStructure) +}; + +// --------------------------------------------------------------------------- +// For loop +// --------------------------------------------------------------------------- + +class MX_EXPORT IRForStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRForStructure) + std::optional init(void) const; + std::optional condition(void) const; + std::optional body(void) const; + std::optional increment(void) const; +}; + +// --------------------------------------------------------------------------- +// While loop +// --------------------------------------------------------------------------- + +class MX_EXPORT IRWhileStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRWhileStructure) + std::optional condition(void) const; + std::optional body(void) const; +}; + +// --------------------------------------------------------------------------- +// Do-while loop +// --------------------------------------------------------------------------- + +class MX_EXPORT IRDoWhileStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRDoWhileStructure) + std::optional body(void) const; + std::optional condition(void) const; +}; + +// --------------------------------------------------------------------------- +// Switch statement +// --------------------------------------------------------------------------- + +class IRSwitchCaseStructure; + +class MX_EXPORT IRSwitchStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRSwitchStructure) + gap::generator cases(void) const &; + std::optional default_case(void) const; +}; + +class MX_EXPORT IRSwitchCaseStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRSwitchCaseStructure) + int64_t low(void) const; + int64_t high(void) const; + bool is_range(void) const; + bool is_default(void) const; + + // The target block for this case (first child block). + IRBlock target_block(void) const; +}; + +// --------------------------------------------------------------------------- +// Expression scope (argument/return allocas for calls in a full-expression) +// --------------------------------------------------------------------------- + +class MX_EXPORT IRExpressionScopeStructure : public IRStructure { + public: + MX_DECLARE_IR_STRUCTURE(IRExpressionScopeStructure) + // objects() inherited — yields argument/return allocas for all calls. +}; + +} // namespace mx diff --git a/include/multiplier/Index.h b/include/multiplier/Index.h index 6be991a4d..db09ef64e 100644 --- a/include/multiplier/Index.h +++ b/include/multiplier/Index.h @@ -26,6 +26,7 @@ #include "Frontend/Macro.h" #include "Frontend/TokenKind.h" #include "Frontend/TokenCategory.h" +#include "Entity.h" #include "Fragment.h" #include "Iterator.h" #include "Reference.h" @@ -65,6 +66,7 @@ using VariantEntity = std::variant< MX_DECLARE_ENTITY_VARIANT, MX_DECLARE_ENTITY_VARIANT, MX_DECLARE_ENTITY_VARIANT, + MX_DECLARE_ENTITY_VARIANT, MX_DECLARE_ENTITY_VARIANT)>; #undef MX_DECLARE_ENTITY_VARIANT @@ -99,6 +101,7 @@ class MX_EXPORT Index final { MX_FRIEND, MX_FRIEND, MX_FRIEND, + MX_FRIEND, MX_FRIEND) #undef MX_FRIEND @@ -128,6 +131,9 @@ class MX_EXPORT Index final { // by specifying the path to that database. static Index from_database(std::filesystem::path path); + // Get the index version (unique ID + version number). + IndexVersion version(void) const; + static Index containing(const Compilation &entity); static Index containing(const CXXBaseSpecifier &entity); static Index containing(const CXXCtorInitializer &entity); @@ -167,6 +173,7 @@ class MX_EXPORT Index final { MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_GETTER, MX_IGNORE_ENTITY_CATEGORY, MX_DECLARE_GETTER, MX_DECLARE_GETTER, MX_DECLARE_GETTER, MX_DECLARE_GETTER, + MX_DECLARE_GETTER, MX_DECLARE_GETTER) #undef MX_DECLARE_GETTER @@ -239,6 +246,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_REFERENCE_AS, MX_REFERENCE_AS, MX_REFERENCE_AS, MX_REFERENCE_AS, + MX_REFERENCE_AS, MX_REFERENCE_AS) #undef MX_REFERENCE_AS } else { diff --git a/include/multiplier/Iterator.h b/include/multiplier/Iterator.h index ca873021c..bbd19ee17 100644 --- a/include/multiplier/Iterator.h +++ b/include/multiplier/Iterator.h @@ -25,6 +25,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_FORWARD_DECLARE_ENTITY, MX_FORWARD_DECLARE_ENTITY, MX_FORWARD_DECLARE_ENTITY, MX_FORWARD_DECLARE_ENTITY, + MX_FORWARD_DECLARE_ENTITY, MX_FORWARD_DECLARE_ENTITY) #undef MX_FORWARD_DECLARE_ENTITY diff --git a/include/multiplier/Reference.h b/include/multiplier/Reference.h index c965d2535..7750a42cc 100644 --- a/include/multiplier/Reference.h +++ b/include/multiplier/Reference.h @@ -223,6 +223,7 @@ class MX_EXPORT Reference { MX_FRIEND, MX_FRIEND, MX_FRIEND, + MX_FRIEND, MX_FRIEND) #undef MX_FRIEND @@ -294,6 +295,7 @@ class MX_EXPORT Reference { MX_DECLARE_REF_GETTER, MX_DECLARE_REF_GETTER, MX_DECLARE_REF_GETTER, + MX_DECLARE_REF_GETTER, MX_DECLARE_REF_GETTER) #undef MX_DECLARE_REF_GETTER diff --git a/include/multiplier/Types.h b/include/multiplier/Types.h index 327c3b98d..cd41c9bad 100644 --- a/include/multiplier/Types.h +++ b/include/multiplier/Types.h @@ -21,6 +21,25 @@ namespace mx { class Token; +// Identifies a specific index and its version state. +struct MX_EXPORT IndexVersion { + uint64_t index_id{0}; // Unique random ID for this index + unsigned version{0}; // Monotonically increasing version number + + bool operator==(const IndexVersion &other) const noexcept { + return index_id == other.index_id && version == other.version; + } + + bool operator!=(const IndexVersion &other) const noexcept { + return !(*this == other); + } + + // Same index, possibly different version. + bool same_index(const IndexVersion &other) const noexcept { + return index_id == other.index_id; + } +}; + enum class AttrKind : unsigned short; enum class DeclKind : unsigned char; enum class MacroKind : unsigned char; @@ -28,8 +47,14 @@ enum class StmtKind : unsigned char; enum class TokenKind : unsigned short; enum class TypeKind : unsigned char; +namespace ir { +enum class BlockKind : uint8_t; +enum class OpCode : uint8_t; +enum class StructureKind : uint8_t; +} // namespace ir + #define MX_IGNORE_ENTITY_CATEGORY(ns_path, type_name, lower_name, enum_name, category) -#define MX_FOR_EACH_ENTITY_CATEGORY(file_, token_, type_, frag_, frag_offset_, pseudo_, tu_) \ +#define MX_FOR_EACH_ENTITY_CATEGORY(file_, token_, type_, frag_, frag_offset_, pseudo_, tu_, ir_) \ frag_(::mx::, Fragment, fragment, FRAGMENT, 1) \ frag_offset_(::mx::, Decl, declaration, DECLARATION, 2) \ frag_offset_(::mx::, Stmt, statement, STATEMENT, 3) \ @@ -43,7 +68,12 @@ enum class TypeKind : unsigned char; pseudo_(::mx::, CXXBaseSpecifier, cxx_base_specifier, CXX_BASE_SPECIFIER, 11) \ pseudo_(::mx::, Designator, designator, DESIGNATOR, 12) \ pseudo_(::mx::, CXXCtorInitializer, cxx_ctor_initializer, CXX_CTOR_INITIALIZER, 13) \ - tu_(::mx::, Compilation, compilation, COMPILATION, 14) + tu_(::mx::, Compilation, compilation, COMPILATION, 14) \ + ir_(::mx::, IRFunction, ir_function, IR_FUNCTION, 15) \ + ir_(::mx::, IRBlock, ir_block, IR_BLOCK, 16) \ + ir_(::mx::, IRInstruction, ir_instruction, IR_INSTRUCTION, 17) \ + ir_(::mx::, IRObject, ir_object, IR_OBJECT, 18) \ + ir_(::mx::, IRStructure, ir_structure, IR_STRUCTURE, 19) #define MX_DECLARE_ENTITY_CLASS(ns_path, type, lower, enum_, val) \ class type;\ @@ -55,6 +85,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_CLASS, MX_DECLARE_ENTITY_CLASS, MX_DECLARE_ENTITY_CLASS, MX_DECLARE_ENTITY_CLASS, + MX_DECLARE_ENTITY_CLASS, MX_DECLARE_ENTITY_CLASS) #undef MX_DECLARE_ENTITY_CLASS @@ -69,6 +100,7 @@ enum class EntityCategory : int { MX_DECLARE_ENTITY_CATEGORY_ENUM, MX_DECLARE_ENTITY_CATEGORY_ENUM, MX_DECLARE_ENTITY_CATEGORY_ENUM, + MX_DECLARE_ENTITY_CATEGORY_ENUM, MX_DECLARE_ENTITY_CATEGORY_ENUM) #undef MX_DECLARE_ENTITY_CATEGORY_ENUM }; @@ -96,6 +128,15 @@ struct DesignatorId; struct CXXCtorInitializerId; struct CompilationId; +// IR entities. +struct IRFunctionId; +struct IRBlockId; +struct IRInstructionId; +struct IRObjectId; +struct IRStructureId; +// NOTE: IRSwitchCaseId has been removed; switch cases are now IRStructureId +// with StructureKind::SWITCH_CASE. + using EntityOffset = uint32_t; using SignedEntityOffset = int32_t; @@ -107,6 +148,7 @@ inline static constexpr unsigned NumEnumerators(EntityCategory) { MX_COUNT_ENTITY_CATEGORIES, MX_COUNT_ENTITY_CATEGORIES, MX_COUNT_ENTITY_CATEGORIES, + MX_COUNT_ENTITY_CATEGORIES, MX_COUNT_ENTITY_CATEGORIES); #undef MX_COUNT_ENTITY_CATEGORIES } @@ -337,6 +379,70 @@ struct MX_EXPORT CXXCtorInitializerId final { auto operator<=>(const CXXCtorInitializerId &) const noexcept = default; }; +// IR entity IDs. These follow the same packing scheme as pseudo entities: +// (fragment_id, sub_kind, offset) where sub_kind is in the IR range. + +enum class IREntityKind : uint8_t { + IR_FUNCTION = 0, + IR_BLOCK = 1, + IR_INSTRUCTION = 2, + IR_OBJECT = 3, + IR_STRUCTURE = 4, +}; + +inline static const char *EnumerationName(IREntityKind) { + return "IREntityKind"; +} + +MX_EXPORT const char *EnumeratorName(IREntityKind) noexcept; + +inline static constexpr unsigned NumEnumerators(IREntityKind) { + return 5u; +} + +struct MX_EXPORT IRFunctionId final { + RawEntityId fragment_id; + EntityOffset offset; + static constexpr IREntityKind kind = IREntityKind::IR_FUNCTION; + bool operator==(const IRFunctionId &) const noexcept = default; + auto operator<=>(const IRFunctionId &) const noexcept = default; +}; + +struct MX_EXPORT IRBlockId final { + RawEntityId fragment_id; + EntityOffset offset; + ir::BlockKind block_kind; + static constexpr IREntityKind kind = IREntityKind::IR_BLOCK; + bool operator==(const IRBlockId &) const noexcept = default; + auto operator<=>(const IRBlockId &) const noexcept = default; +}; + +struct MX_EXPORT IRInstructionId final { + RawEntityId fragment_id; + EntityOffset offset; + ir::OpCode opcode; + static constexpr IREntityKind kind = IREntityKind::IR_INSTRUCTION; + bool operator==(const IRInstructionId &) const noexcept = default; + auto operator<=>(const IRInstructionId &) const noexcept = default; +}; + +struct MX_EXPORT IRObjectId final { + RawEntityId fragment_id; + EntityOffset offset; + static constexpr IREntityKind kind = IREntityKind::IR_OBJECT; + bool operator==(const IRObjectId &) const noexcept = default; + auto operator<=>(const IRObjectId &) const noexcept = default; +}; + +struct MX_EXPORT IRStructureId final { + RawEntityId fragment_id; + EntityOffset offset; + ir::StructureKind structure_kind; + static constexpr IREntityKind kind = IREntityKind::IR_STRUCTURE; + bool operator==(const IRStructureId &) const noexcept = default; + auto operator<=>(const IRStructureId &) const noexcept = default; +}; + // Translation units represent a compilation. From a translation unit we can // get the compile command, etc. struct MX_EXPORT CompilationId { @@ -383,6 +489,16 @@ struct MX_EXPORT FragmentId final { : fragment_id(id_.fragment_id) {} inline /* implicit */ FragmentId(const CXXCtorInitializerId &id_) : fragment_id(id_.fragment_id) {} + inline /* implicit */ FragmentId(const IRFunctionId &id_) + : fragment_id(id_.fragment_id) {} + inline /* implicit */ FragmentId(const IRBlockId &id_) + : fragment_id(id_.fragment_id) {} + inline /* implicit */ FragmentId(const IRInstructionId &id_) + : fragment_id(id_.fragment_id) {} + inline /* implicit */ FragmentId(const IRObjectId &id_) + : fragment_id(id_.fragment_id) {} + inline /* implicit */ FragmentId(const IRStructureId &id_) + : fragment_id(id_.fragment_id) {} static std::optional from(const EntityId &); }; @@ -410,6 +526,7 @@ using VariantId = std::variant< MX_ENTITY_ID_VARIANT, MX_ENTITY_ID_VARIANT, MX_ENTITY_ID_VARIANT, + MX_ENTITY_ID_VARIANT, MX_ENTITY_ID_VARIANT) ParsedTokenId, MacroTokenId, FileTokenId, TypeTokenId>; #undef MX_ENTITY_ID_VARIANT @@ -448,6 +565,11 @@ class MX_EXPORT EntityId final { /* implicit */ EntityId(DesignatorId id); /* implicit */ EntityId(CXXCtorInitializerId id); /* implicit */ EntityId(CompilationId id); + /* implicit */ EntityId(IRFunctionId id); + /* implicit */ EntityId(IRBlockId id); + /* implicit */ EntityId(IRInstructionId id); + /* implicit */ EntityId(IRObjectId id); + /* implicit */ EntityId(IRStructureId id); template /* implicit */ inline EntityId(SpecificEntityId); @@ -616,6 +738,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_MAP_ENTITY_TYPE, MX_MAP_ENTITY_TYPE, MX_MAP_ENTITY_TYPE, MX_MAP_ENTITY_TYPE, + MX_MAP_ENTITY_TYPE, MX_MAP_ENTITY_TYPE) #undef MX_MAP_ENTITY_TYPE diff --git a/include/multiplier/Visitor.inc.h b/include/multiplier/Visitor.inc.h index f8f1dbeab..1ca405efc 100644 --- a/include/multiplier/Visitor.inc.h +++ b/include/multiplier/Visitor.inc.h @@ -107,6 +107,9 @@ #ifndef MX_VISIT_BASE # define MX_VISIT_BASE(...) #endif +#ifndef MX_VISIT_ENTITY_ID +# define MX_VISIT_ENTITY_ID(...) +#endif #ifndef MX_VISIT_DECL_LINK # define MX_VISIT_DECL_LINK(...) #endif @@ -14042,12 +14045,13 @@ MX_BEGIN_VISIT_ABSTRACT_STMT(Stmt) MX_ENTER_VISIT_Stmt MX_VISIT_DECL_LINK(Stmt, parent_declaration, 0) MX_VISIT_STMT_LINK(Stmt, parent_statement, 1) - MX_VISIT_OPTIONAL_ENTITY(Stmt, referenced_declaration, 2, MX_APPLY_FUNC, ReferencedDecl, Decl, NthStmt) - MX_VISIT_ENTITY(Stmt, ignore_containers, 3, MX_APPLY_METHOD, IgnoreContainers, Stmt, NthStmt) - MX_VISIT_ENTITY_LIST(Stmt, children, 4, MX_APPLY_METHOD, Children, Stmt, NthStmt) - MX_VISIT_TOKEN_RANGE(Stmt, tokens, 5, 6, NthStmt) - MX_VISIT_ENUM(Stmt, kind, 7, MX_APPLY_METHOD, Kind, StmtKind, NthStmt) - MX_VISIT_ENTITY(Stmt, strip_label_like_statements, 8, MX_APPLY_METHOD, StripLabelLikeStatements, Stmt, NthStmt) + MX_VISIT_ENTITY_ID(Stmt, ir, 2) + MX_VISIT_OPTIONAL_ENTITY(Stmt, referenced_declaration, 3, MX_APPLY_FUNC, ReferencedDecl, Decl, NthStmt) + MX_VISIT_ENTITY(Stmt, ignore_containers, 4, MX_APPLY_METHOD, IgnoreContainers, Stmt, NthStmt) + MX_VISIT_ENTITY_LIST(Stmt, children, 5, MX_APPLY_METHOD, Children, Stmt, NthStmt) + MX_VISIT_TOKEN_RANGE(Stmt, tokens, 6, 7, NthStmt) + MX_VISIT_ENUM(Stmt, kind, 8, MX_APPLY_METHOD, Kind, StmtKind, NthStmt) + MX_VISIT_ENTITY(Stmt, strip_label_like_statements, 9, MX_APPLY_METHOD, StripLabelLikeStatements, Stmt, NthStmt) MX_EXIT_VISIT_Stmt MX_END_VISIT_STMT(Stmt) @@ -14061,12 +14065,12 @@ MX_END_VISIT_STMT(Stmt) MX_BEGIN_VISIT_STMT(SEHTryStmt) MX_ENTER_VISIT_SEHTryStmt MX_VISIT_BASE(SEHTryStmt, Stmt) - MX_VISIT_ENTITY(SEHTryStmt, except_handler, 9, MX_APPLY_METHOD, ExceptHandler, SEHExceptStmt, NthStmt) - MX_VISIT_ENTITY(SEHTryStmt, finally_handler, 10, MX_APPLY_METHOD, FinallyHandler, SEHFinallyStmt, NthStmt) - MX_VISIT_ENTITY(SEHTryStmt, handler, 11, MX_APPLY_METHOD, Handler, Stmt, NthStmt) - MX_VISIT_BOOL(SEHTryStmt, is_cxx_try, 12, MX_APPLY_METHOD, IsCXXTry, bool, NthStmt) - MX_VISIT_ENTITY(SEHTryStmt, try_block, 13, MX_APPLY_METHOD, TryBlock, CompoundStmt, NthStmt) - MX_VISIT_ENTITY(SEHTryStmt, try_token, 14, MX_APPLY_METHOD, TryToken, Token, NthStmt) + MX_VISIT_ENTITY(SEHTryStmt, except_handler, 10, MX_APPLY_METHOD, ExceptHandler, SEHExceptStmt, NthStmt) + MX_VISIT_ENTITY(SEHTryStmt, finally_handler, 11, MX_APPLY_METHOD, FinallyHandler, SEHFinallyStmt, NthStmt) + MX_VISIT_ENTITY(SEHTryStmt, handler, 12, MX_APPLY_METHOD, Handler, Stmt, NthStmt) + MX_VISIT_BOOL(SEHTryStmt, is_cxx_try, 13, MX_APPLY_METHOD, IsCXXTry, bool, NthStmt) + MX_VISIT_ENTITY(SEHTryStmt, try_block, 14, MX_APPLY_METHOD, TryBlock, CompoundStmt, NthStmt) + MX_VISIT_ENTITY(SEHTryStmt, try_token, 15, MX_APPLY_METHOD, TryToken, Token, NthStmt) MX_EXIT_VISIT_SEHTryStmt MX_END_VISIT_STMT(SEHTryStmt) @@ -14080,7 +14084,7 @@ MX_END_VISIT_STMT(SEHTryStmt) MX_BEGIN_VISIT_STMT(SEHLeaveStmt) MX_ENTER_VISIT_SEHLeaveStmt MX_VISIT_BASE(SEHLeaveStmt, Stmt) - MX_VISIT_ENTITY(SEHLeaveStmt, leave_token, 9, MX_APPLY_METHOD, LeaveToken, Token, NthStmt) + MX_VISIT_ENTITY(SEHLeaveStmt, leave_token, 10, MX_APPLY_METHOD, LeaveToken, Token, NthStmt) MX_EXIT_VISIT_SEHLeaveStmt MX_END_VISIT_STMT(SEHLeaveStmt) @@ -14094,8 +14098,8 @@ MX_END_VISIT_STMT(SEHLeaveStmt) MX_BEGIN_VISIT_STMT(SEHFinallyStmt) MX_ENTER_VISIT_SEHFinallyStmt MX_VISIT_BASE(SEHFinallyStmt, Stmt) - MX_VISIT_ENTITY(SEHFinallyStmt, block, 9, MX_APPLY_METHOD, Block, CompoundStmt, NthStmt) - MX_VISIT_ENTITY(SEHFinallyStmt, finally_token, 10, MX_APPLY_METHOD, FinallyToken, Token, NthStmt) + MX_VISIT_ENTITY(SEHFinallyStmt, block, 10, MX_APPLY_METHOD, Block, CompoundStmt, NthStmt) + MX_VISIT_ENTITY(SEHFinallyStmt, finally_token, 11, MX_APPLY_METHOD, FinallyToken, Token, NthStmt) MX_EXIT_VISIT_SEHFinallyStmt MX_END_VISIT_STMT(SEHFinallyStmt) @@ -14109,9 +14113,9 @@ MX_END_VISIT_STMT(SEHFinallyStmt) MX_BEGIN_VISIT_STMT(SEHExceptStmt) MX_ENTER_VISIT_SEHExceptStmt MX_VISIT_BASE(SEHExceptStmt, Stmt) - MX_VISIT_ENTITY(SEHExceptStmt, block, 9, MX_APPLY_METHOD, Block, CompoundStmt, NthStmt) - MX_VISIT_ENTITY(SEHExceptStmt, except_token, 10, MX_APPLY_METHOD, ExceptToken, Token, NthStmt) - MX_VISIT_ENTITY(SEHExceptStmt, filter_expression, 11, MX_APPLY_METHOD, FilterExpression, Expr, NthStmt) + MX_VISIT_ENTITY(SEHExceptStmt, block, 10, MX_APPLY_METHOD, Block, CompoundStmt, NthStmt) + MX_VISIT_ENTITY(SEHExceptStmt, except_token, 11, MX_APPLY_METHOD, ExceptToken, Token, NthStmt) + MX_VISIT_ENTITY(SEHExceptStmt, filter_expression, 12, MX_APPLY_METHOD, FilterExpression, Expr, NthStmt) MX_EXIT_VISIT_SEHExceptStmt MX_END_VISIT_STMT(SEHExceptStmt) @@ -14125,9 +14129,9 @@ MX_END_VISIT_STMT(SEHExceptStmt) MX_BEGIN_VISIT_STMT(ReturnStmt) MX_ENTER_VISIT_ReturnStmt MX_VISIT_BASE(ReturnStmt, Stmt) - MX_VISIT_OPTIONAL_ENTITY(ReturnStmt, nrvo_candidate, 9, MX_APPLY_METHOD, NRVOCandidate, VarDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(ReturnStmt, return_value, 10, MX_APPLY_METHOD, ReturnValue, Expr, NthStmt) - MX_VISIT_ENTITY(ReturnStmt, return_token, 11, MX_APPLY_METHOD, ReturnToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ReturnStmt, nrvo_candidate, 10, MX_APPLY_METHOD, NRVOCandidate, VarDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ReturnStmt, return_value, 11, MX_APPLY_METHOD, ReturnValue, Expr, NthStmt) + MX_VISIT_ENTITY(ReturnStmt, return_token, 12, MX_APPLY_METHOD, ReturnToken, Token, NthStmt) MX_EXIT_VISIT_ReturnStmt MX_END_VISIT_STMT(ReturnStmt) @@ -14141,11 +14145,11 @@ MX_END_VISIT_STMT(ReturnStmt) MX_BEGIN_VISIT_STMT(ObjCForCollectionStmt) MX_ENTER_VISIT_ObjCForCollectionStmt MX_VISIT_BASE(ObjCForCollectionStmt, Stmt) - MX_VISIT_ENTITY(ObjCForCollectionStmt, body, 9, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(ObjCForCollectionStmt, collection, 10, MX_APPLY_METHOD, Collection, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCForCollectionStmt, element, 11, MX_APPLY_METHOD, Element, Stmt, NthStmt) - MX_VISIT_ENTITY(ObjCForCollectionStmt, for_token, 13, MX_APPLY_METHOD, ForToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCForCollectionStmt, r_paren_token, 14, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCForCollectionStmt, body, 10, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(ObjCForCollectionStmt, collection, 11, MX_APPLY_METHOD, Collection, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCForCollectionStmt, element, 12, MX_APPLY_METHOD, Element, Stmt, NthStmt) + MX_VISIT_ENTITY(ObjCForCollectionStmt, for_token, 14, MX_APPLY_METHOD, ForToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCForCollectionStmt, r_paren_token, 15, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_ObjCForCollectionStmt MX_END_VISIT_STMT(ObjCForCollectionStmt) @@ -14159,8 +14163,8 @@ MX_END_VISIT_STMT(ObjCForCollectionStmt) MX_BEGIN_VISIT_STMT(ObjCAutoreleasePoolStmt) MX_ENTER_VISIT_ObjCAutoreleasePoolStmt MX_VISIT_BASE(ObjCAutoreleasePoolStmt, Stmt) - MX_VISIT_ENTITY(ObjCAutoreleasePoolStmt, at_token, 9, MX_APPLY_METHOD, AtToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCAutoreleasePoolStmt, sub_statement, 10, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(ObjCAutoreleasePoolStmt, at_token, 10, MX_APPLY_METHOD, AtToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCAutoreleasePoolStmt, sub_statement, 11, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) MX_EXIT_VISIT_ObjCAutoreleasePoolStmt MX_END_VISIT_STMT(ObjCAutoreleasePoolStmt) @@ -14174,10 +14178,10 @@ MX_END_VISIT_STMT(ObjCAutoreleasePoolStmt) MX_BEGIN_VISIT_STMT(ObjCAtTryStmt) MX_ENTER_VISIT_ObjCAtTryStmt MX_VISIT_BASE(ObjCAtTryStmt, Stmt) - MX_VISIT_ENTITY(ObjCAtTryStmt, at_try_token, 9, MX_APPLY_METHOD, AtTryToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCAtTryStmt, finally_statement, 10, MX_APPLY_METHOD, FinallyStatement, ObjCAtFinallyStmt, NthStmt) - MX_VISIT_ENTITY(ObjCAtTryStmt, try_body, 11, MX_APPLY_METHOD, TryBody, Stmt, NthStmt) - MX_VISIT_ENTITY_LIST(ObjCAtTryStmt, catch_statements, 15, MX_APPLY_METHOD, CatchStatements, ObjCAtCatchStmt, NthStmt) + MX_VISIT_ENTITY(ObjCAtTryStmt, at_try_token, 10, MX_APPLY_METHOD, AtTryToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCAtTryStmt, finally_statement, 11, MX_APPLY_METHOD, FinallyStatement, ObjCAtFinallyStmt, NthStmt) + MX_VISIT_ENTITY(ObjCAtTryStmt, try_body, 12, MX_APPLY_METHOD, TryBody, Stmt, NthStmt) + MX_VISIT_ENTITY_LIST(ObjCAtTryStmt, catch_statements, 16, MX_APPLY_METHOD, CatchStatements, ObjCAtCatchStmt, NthStmt) MX_EXIT_VISIT_ObjCAtTryStmt MX_END_VISIT_STMT(ObjCAtTryStmt) @@ -14191,8 +14195,8 @@ MX_END_VISIT_STMT(ObjCAtTryStmt) MX_BEGIN_VISIT_STMT(ObjCAtThrowStmt) MX_ENTER_VISIT_ObjCAtThrowStmt MX_VISIT_BASE(ObjCAtThrowStmt, Stmt) - MX_VISIT_ENTITY(ObjCAtThrowStmt, throw_expression, 9, MX_APPLY_METHOD, ThrowExpression, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCAtThrowStmt, throw_token, 10, MX_APPLY_METHOD, ThrowToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCAtThrowStmt, throw_expression, 10, MX_APPLY_METHOD, ThrowExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCAtThrowStmt, throw_token, 11, MX_APPLY_METHOD, ThrowToken, Token, NthStmt) MX_EXIT_VISIT_ObjCAtThrowStmt MX_END_VISIT_STMT(ObjCAtThrowStmt) @@ -14206,9 +14210,9 @@ MX_END_VISIT_STMT(ObjCAtThrowStmt) MX_BEGIN_VISIT_STMT(ObjCAtSynchronizedStmt) MX_ENTER_VISIT_ObjCAtSynchronizedStmt MX_VISIT_BASE(ObjCAtSynchronizedStmt, Stmt) - MX_VISIT_ENTITY(ObjCAtSynchronizedStmt, at_synchronized_token, 9, MX_APPLY_METHOD, AtSynchronizedToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCAtSynchronizedStmt, synch_body, 10, MX_APPLY_METHOD, SynchBody, CompoundStmt, NthStmt) - MX_VISIT_ENTITY(ObjCAtSynchronizedStmt, synch_expression, 11, MX_APPLY_METHOD, SynchExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCAtSynchronizedStmt, at_synchronized_token, 10, MX_APPLY_METHOD, AtSynchronizedToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCAtSynchronizedStmt, synch_body, 11, MX_APPLY_METHOD, SynchBody, CompoundStmt, NthStmt) + MX_VISIT_ENTITY(ObjCAtSynchronizedStmt, synch_expression, 12, MX_APPLY_METHOD, SynchExpression, Expr, NthStmt) MX_EXIT_VISIT_ObjCAtSynchronizedStmt MX_END_VISIT_STMT(ObjCAtSynchronizedStmt) @@ -14222,8 +14226,8 @@ MX_END_VISIT_STMT(ObjCAtSynchronizedStmt) MX_BEGIN_VISIT_STMT(ObjCAtFinallyStmt) MX_ENTER_VISIT_ObjCAtFinallyStmt MX_VISIT_BASE(ObjCAtFinallyStmt, Stmt) - MX_VISIT_ENTITY(ObjCAtFinallyStmt, at_finally_token, 9, MX_APPLY_METHOD, AtFinallyToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCAtFinallyStmt, finally_body, 10, MX_APPLY_METHOD, FinallyBody, Stmt, NthStmt) + MX_VISIT_ENTITY(ObjCAtFinallyStmt, at_finally_token, 10, MX_APPLY_METHOD, AtFinallyToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCAtFinallyStmt, finally_body, 11, MX_APPLY_METHOD, FinallyBody, Stmt, NthStmt) MX_EXIT_VISIT_ObjCAtFinallyStmt MX_END_VISIT_STMT(ObjCAtFinallyStmt) @@ -14237,11 +14241,11 @@ MX_END_VISIT_STMT(ObjCAtFinallyStmt) MX_BEGIN_VISIT_STMT(ObjCAtCatchStmt) MX_ENTER_VISIT_ObjCAtCatchStmt MX_VISIT_BASE(ObjCAtCatchStmt, Stmt) - MX_VISIT_ENTITY(ObjCAtCatchStmt, at_catch_token, 9, MX_APPLY_METHOD, AtCatchToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCAtCatchStmt, catch_body, 10, MX_APPLY_METHOD, CatchBody, Stmt, NthStmt) - MX_VISIT_ENTITY(ObjCAtCatchStmt, catch_parameter_declaration, 11, MX_APPLY_METHOD, CatchParameterDeclaration, VarDecl, NthStmt) - MX_VISIT_ENTITY(ObjCAtCatchStmt, r_paren_token, 13, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_BOOL(ObjCAtCatchStmt, has_ellipsis, 12, MX_APPLY_METHOD, HasEllipsis, bool, NthStmt) + MX_VISIT_ENTITY(ObjCAtCatchStmt, at_catch_token, 10, MX_APPLY_METHOD, AtCatchToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCAtCatchStmt, catch_body, 11, MX_APPLY_METHOD, CatchBody, Stmt, NthStmt) + MX_VISIT_ENTITY(ObjCAtCatchStmt, catch_parameter_declaration, 12, MX_APPLY_METHOD, CatchParameterDeclaration, VarDecl, NthStmt) + MX_VISIT_ENTITY(ObjCAtCatchStmt, r_paren_token, 14, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_BOOL(ObjCAtCatchStmt, has_ellipsis, 13, MX_APPLY_METHOD, HasEllipsis, bool, NthStmt) MX_EXIT_VISIT_ObjCAtCatchStmt MX_END_VISIT_STMT(ObjCAtCatchStmt) @@ -14255,12 +14259,12 @@ MX_END_VISIT_STMT(ObjCAtCatchStmt) MX_BEGIN_VISIT_ABSTRACT_STMT(OMPExecutableDirective) MX_ENTER_VISIT_OMPExecutableDirective MX_VISIT_BASE(OMPExecutableDirective, Stmt) - MX_VISIT_ENTITY(OMPExecutableDirective, associated_statement, 9, MX_APPLY_METHOD, AssociatedStatement, Stmt, NthStmt) - MX_VISIT_ENTITY(OMPExecutableDirective, innermost_captured_statement, 10, MX_APPLY_METHOD, InnermostCapturedStatement, CapturedStmt, NthStmt) - MX_VISIT_ENTITY(OMPExecutableDirective, raw_statement, 11, MX_APPLY_METHOD, RawStatement, Stmt, NthStmt) - MX_VISIT_ENTITY(OMPExecutableDirective, structured_block, 13, MX_APPLY_METHOD, StructuredBlock, Stmt, NthStmt) - MX_VISIT_BOOL(OMPExecutableDirective, has_associated_statement, 12, MX_APPLY_METHOD, HasAssociatedStatement, bool, NthStmt) - MX_VISIT_BOOL(OMPExecutableDirective, is_standalone_directive, 16, MX_APPLY_METHOD, IsStandaloneDirective, bool, NthStmt) + MX_VISIT_ENTITY(OMPExecutableDirective, associated_statement, 10, MX_APPLY_METHOD, AssociatedStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPExecutableDirective, innermost_captured_statement, 11, MX_APPLY_METHOD, InnermostCapturedStatement, CapturedStmt, NthStmt) + MX_VISIT_ENTITY(OMPExecutableDirective, raw_statement, 12, MX_APPLY_METHOD, RawStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPExecutableDirective, structured_block, 14, MX_APPLY_METHOD, StructuredBlock, Stmt, NthStmt) + MX_VISIT_BOOL(OMPExecutableDirective, has_associated_statement, 13, MX_APPLY_METHOD, HasAssociatedStatement, bool, NthStmt) + MX_VISIT_BOOL(OMPExecutableDirective, is_standalone_directive, 17, MX_APPLY_METHOD, IsStandaloneDirective, bool, NthStmt) MX_EXIT_VISIT_OMPExecutableDirective MX_END_VISIT_STMT(OMPExecutableDirective) @@ -14287,7 +14291,7 @@ MX_END_VISIT_STMT(OMPErrorDirective) MX_BEGIN_VISIT_STMT(OMPDispatchDirective) MX_ENTER_VISIT_OMPDispatchDirective MX_VISIT_BASE(OMPDispatchDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPDispatchDirective, target_call_token, 14, MX_APPLY_METHOD, TargetCallToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPDispatchDirective, target_call_token, 15, MX_APPLY_METHOD, TargetCallToken, Token, NthStmt) MX_EXIT_VISIT_OMPDispatchDirective MX_END_VISIT_STMT(OMPDispatchDirective) @@ -14366,16 +14370,16 @@ MX_END_VISIT_STMT(OMPBarrierDirective) MX_BEGIN_VISIT_STMT(OMPAtomicDirective) MX_ENTER_VISIT_OMPAtomicDirective MX_VISIT_BASE(OMPAtomicDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPAtomicDirective, condition_expression, 14, MX_APPLY_METHOD, ConditionExpression, Expr, NthStmt) - MX_VISIT_ENTITY(OMPAtomicDirective, d, 17, MX_APPLY_METHOD, D, Expr, NthStmt) - MX_VISIT_ENTITY(OMPAtomicDirective, expression, 18, MX_APPLY_METHOD, Expression, Expr, NthStmt) - MX_VISIT_ENTITY(OMPAtomicDirective, r, 19, MX_APPLY_METHOD, R, Expr, NthStmt) - MX_VISIT_ENTITY(OMPAtomicDirective, update_expression, 20, MX_APPLY_METHOD, UpdateExpression, Expr, NthStmt) - MX_VISIT_ENTITY(OMPAtomicDirective, v, 21, MX_APPLY_METHOD, V, Expr, NthStmt) - MX_VISIT_ENTITY(OMPAtomicDirective, x, 22, MX_APPLY_METHOD, X, Expr, NthStmt) - MX_VISIT_BOOL(OMPAtomicDirective, is_fail_only, 23, MX_APPLY_METHOD, IsFailOnly, bool, NthStmt) - MX_VISIT_BOOL(OMPAtomicDirective, is_postfix_update, 24, MX_APPLY_METHOD, IsPostfixUpdate, bool, NthStmt) - MX_VISIT_BOOL(OMPAtomicDirective, is_xlhs_in_rhs_part, 25, MX_APPLY_METHOD, IsXLHSInRHSPart, bool, NthStmt) + MX_VISIT_ENTITY(OMPAtomicDirective, condition_expression, 15, MX_APPLY_METHOD, ConditionExpression, Expr, NthStmt) + MX_VISIT_ENTITY(OMPAtomicDirective, d, 18, MX_APPLY_METHOD, D, Expr, NthStmt) + MX_VISIT_ENTITY(OMPAtomicDirective, expression, 19, MX_APPLY_METHOD, Expression, Expr, NthStmt) + MX_VISIT_ENTITY(OMPAtomicDirective, r, 20, MX_APPLY_METHOD, R, Expr, NthStmt) + MX_VISIT_ENTITY(OMPAtomicDirective, update_expression, 21, MX_APPLY_METHOD, UpdateExpression, Expr, NthStmt) + MX_VISIT_ENTITY(OMPAtomicDirective, v, 22, MX_APPLY_METHOD, V, Expr, NthStmt) + MX_VISIT_ENTITY(OMPAtomicDirective, x, 23, MX_APPLY_METHOD, X, Expr, NthStmt) + MX_VISIT_BOOL(OMPAtomicDirective, is_fail_only, 24, MX_APPLY_METHOD, IsFailOnly, bool, NthStmt) + MX_VISIT_BOOL(OMPAtomicDirective, is_postfix_update, 25, MX_APPLY_METHOD, IsPostfixUpdate, bool, NthStmt) + MX_VISIT_BOOL(OMPAtomicDirective, is_xlhs_in_rhs_part, 26, MX_APPLY_METHOD, IsXLHSInRHSPart, bool, NthStmt) MX_EXIT_VISIT_OMPAtomicDirective MX_END_VISIT_STMT(OMPAtomicDirective) @@ -14428,7 +14432,7 @@ MX_END_VISIT_STMT(OMPTaskwaitDirective) MX_BEGIN_VISIT_STMT(OMPTaskgroupDirective) MX_ENTER_VISIT_OMPTaskgroupDirective MX_VISIT_BASE(OMPTaskgroupDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPTaskgroupDirective, reduction_reference, 14, MX_APPLY_METHOD, ReductionReference, Expr, NthStmt) + MX_VISIT_ENTITY(OMPTaskgroupDirective, reduction_reference, 15, MX_APPLY_METHOD, ReductionReference, Expr, NthStmt) MX_EXIT_VISIT_OMPTaskgroupDirective MX_END_VISIT_STMT(OMPTaskgroupDirective) @@ -14442,7 +14446,7 @@ MX_END_VISIT_STMT(OMPTaskgroupDirective) MX_BEGIN_VISIT_STMT(OMPTaskDirective) MX_ENTER_VISIT_OMPTaskDirective MX_VISIT_BASE(OMPTaskDirective, OMPExecutableDirective) - MX_VISIT_BOOL(OMPTaskDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_BOOL(OMPTaskDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPTaskDirective MX_END_VISIT_STMT(OMPTaskDirective) @@ -14482,8 +14486,8 @@ MX_END_VISIT_STMT(OMPTargetTeamsDirective) MX_BEGIN_VISIT_STMT(OMPTargetParallelDirective) MX_ENTER_VISIT_OMPTargetParallelDirective MX_VISIT_BASE(OMPTargetParallelDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPTargetParallelDirective, task_reduction_reference_expression, 14, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPTargetParallelDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPTargetParallelDirective, task_reduction_reference_expression, 15, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPTargetParallelDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPTargetParallelDirective MX_END_VISIT_STMT(OMPTargetParallelDirective) @@ -14562,8 +14566,8 @@ MX_END_VISIT_STMT(OMPSingleDirective) MX_BEGIN_VISIT_STMT(OMPSectionsDirective) MX_ENTER_VISIT_OMPSectionsDirective MX_VISIT_BASE(OMPSectionsDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPSectionsDirective, task_reduction_reference_expression, 14, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPSectionsDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPSectionsDirective, task_reduction_reference_expression, 15, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPSectionsDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPSectionsDirective MX_END_VISIT_STMT(OMPSectionsDirective) @@ -14577,7 +14581,7 @@ MX_END_VISIT_STMT(OMPSectionsDirective) MX_BEGIN_VISIT_STMT(OMPSectionDirective) MX_ENTER_VISIT_OMPSectionDirective MX_VISIT_BASE(OMPSectionDirective, OMPExecutableDirective) - MX_VISIT_BOOL(OMPSectionDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_BOOL(OMPSectionDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPSectionDirective MX_END_VISIT_STMT(OMPSectionDirective) @@ -14617,8 +14621,8 @@ MX_END_VISIT_STMT(OMPScanDirective) MX_BEGIN_VISIT_STMT(OMPParallelSectionsDirective) MX_ENTER_VISIT_OMPParallelSectionsDirective MX_VISIT_BASE(OMPParallelSectionsDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPParallelSectionsDirective, task_reduction_reference_expression, 14, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPParallelSectionsDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPParallelSectionsDirective, task_reduction_reference_expression, 15, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPParallelSectionsDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPParallelSectionsDirective MX_END_VISIT_STMT(OMPParallelSectionsDirective) @@ -14632,7 +14636,7 @@ MX_END_VISIT_STMT(OMPParallelSectionsDirective) MX_BEGIN_VISIT_STMT(OMPParallelMasterDirective) MX_ENTER_VISIT_OMPParallelMasterDirective MX_VISIT_BASE(OMPParallelMasterDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPParallelMasterDirective, task_reduction_reference_expression, 14, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_ENTITY(OMPParallelMasterDirective, task_reduction_reference_expression, 15, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) MX_EXIT_VISIT_OMPParallelMasterDirective MX_END_VISIT_STMT(OMPParallelMasterDirective) @@ -14646,7 +14650,7 @@ MX_END_VISIT_STMT(OMPParallelMasterDirective) MX_BEGIN_VISIT_STMT(OMPParallelMaskedDirective) MX_ENTER_VISIT_OMPParallelMaskedDirective MX_VISIT_BASE(OMPParallelMaskedDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPParallelMaskedDirective, task_reduction_reference_expression, 14, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_ENTITY(OMPParallelMaskedDirective, task_reduction_reference_expression, 15, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) MX_EXIT_VISIT_OMPParallelMaskedDirective MX_END_VISIT_STMT(OMPParallelMaskedDirective) @@ -14660,8 +14664,8 @@ MX_END_VISIT_STMT(OMPParallelMaskedDirective) MX_BEGIN_VISIT_STMT(OMPParallelDirective) MX_ENTER_VISIT_OMPParallelDirective MX_VISIT_BASE(OMPParallelDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPParallelDirective, task_reduction_reference_expression, 14, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPParallelDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPParallelDirective, task_reduction_reference_expression, 15, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPParallelDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPParallelDirective MX_END_VISIT_STMT(OMPParallelDirective) @@ -14688,7 +14692,7 @@ MX_END_VISIT_STMT(OMPOrderedDirective) MX_BEGIN_VISIT_STMT(OMPMetaDirective) MX_ENTER_VISIT_OMPMetaDirective MX_VISIT_BASE(OMPMetaDirective, OMPExecutableDirective) - MX_VISIT_ENTITY(OMPMetaDirective, if_statement, 14, MX_APPLY_METHOD, IfStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPMetaDirective, if_statement, 15, MX_APPLY_METHOD, IfStatement, Stmt, NthStmt) MX_EXIT_VISIT_OMPMetaDirective MX_END_VISIT_STMT(OMPMetaDirective) @@ -14728,7 +14732,7 @@ MX_END_VISIT_STMT(OMPMaskedDirective) MX_BEGIN_VISIT_ABSTRACT_STMT(OMPLoopBasedDirective) MX_ENTER_VISIT_OMPLoopBasedDirective MX_VISIT_BASE(OMPLoopBasedDirective, OMPExecutableDirective) - MX_VISIT_INT(OMPLoopBasedDirective, loops_number, 26, MX_APPLY_METHOD, LoopsNumber, uint32_t, NthStmt) + MX_VISIT_INT(OMPLoopBasedDirective, loops_number, 27, MX_APPLY_METHOD, LoopsNumber, uint32_t, NthStmt) MX_EXIT_VISIT_OMPLoopBasedDirective MX_END_VISIT_STMT(OMPLoopBasedDirective) @@ -14742,8 +14746,8 @@ MX_END_VISIT_STMT(OMPLoopBasedDirective) MX_BEGIN_VISIT_ABSTRACT_STMT(OMPLoopTransformationDirective) MX_ENTER_VISIT_OMPLoopTransformationDirective MX_VISIT_BASE(OMPLoopTransformationDirective, OMPLoopBasedDirective) - MX_VISIT_ENTITY(OMPLoopTransformationDirective, pre_initializers, 14, MX_APPLY_METHOD, PreInitializers, Stmt, NthStmt) - MX_VISIT_ENTITY(OMPLoopTransformationDirective, transformed_statement, 17, MX_APPLY_METHOD, TransformedStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPLoopTransformationDirective, pre_initializers, 15, MX_APPLY_METHOD, PreInitializers, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPLoopTransformationDirective, transformed_statement, 18, MX_APPLY_METHOD, TransformedStatement, Stmt, NthStmt) MX_EXIT_VISIT_OMPLoopTransformationDirective MX_END_VISIT_STMT(OMPLoopTransformationDirective) @@ -14783,43 +14787,43 @@ MX_END_VISIT_STMT(OMPTileDirective) MX_BEGIN_VISIT_ABSTRACT_STMT(OMPLoopDirective) MX_ENTER_VISIT_OMPLoopDirective MX_VISIT_BASE(OMPLoopDirective, OMPLoopBasedDirective) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, counters, 15, MX_APPLY_METHOD, Counters, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, dependent_counters, 27, MX_APPLY_METHOD, DependentCounters, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, dependent_initializers, 28, MX_APPLY_METHOD, DependentInitializers, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, finals, 29, MX_APPLY_METHOD, Finals, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, finals_conditions, 30, MX_APPLY_METHOD, FinalsConditions, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, body, 14, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, calculate_last_iteration, 17, MX_APPLY_METHOD, CalculateLastIteration, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_condition, 18, MX_APPLY_METHOD, CombinedCondition, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_distance_condition, 19, MX_APPLY_METHOD, CombinedDistanceCondition, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_ensure_upper_bound, 20, MX_APPLY_METHOD, CombinedEnsureUpperBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_initializer, 21, MX_APPLY_METHOD, CombinedInitializer, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_lower_bound_variable, 22, MX_APPLY_METHOD, CombinedLowerBoundVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_next_lower_bound, 31, MX_APPLY_METHOD, CombinedNextLowerBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_next_upper_bound, 32, MX_APPLY_METHOD, CombinedNextUpperBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_parallel_for_in_distance_condition, 33, MX_APPLY_METHOD, CombinedParallelForInDistanceCondition, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, combined_upper_bound_variable, 34, MX_APPLY_METHOD, CombinedUpperBoundVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, condition, 35, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, distance_increment, 36, MX_APPLY_METHOD, DistanceIncrement, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, ensure_upper_bound, 37, MX_APPLY_METHOD, EnsureUpperBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, increment, 38, MX_APPLY_METHOD, Increment, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, initializer, 39, MX_APPLY_METHOD, Initializer, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, is_last_iteration_variable, 40, MX_APPLY_METHOD, IsLastIterationVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, iteration_variable, 41, MX_APPLY_METHOD, IterationVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, last_iteration, 42, MX_APPLY_METHOD, LastIteration, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, lower_bound_variable, 43, MX_APPLY_METHOD, LowerBoundVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, next_lower_bound, 44, MX_APPLY_METHOD, NextLowerBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, next_upper_bound, 45, MX_APPLY_METHOD, NextUpperBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, pre_condition, 46, MX_APPLY_METHOD, PreCondition, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, pre_initializers, 47, MX_APPLY_METHOD, PreInitializers, Stmt, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, prev_ensure_upper_bound, 48, MX_APPLY_METHOD, PrevEnsureUpperBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, prev_lower_bound_variable, 49, MX_APPLY_METHOD, PrevLowerBoundVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, prev_upper_bound_variable, 50, MX_APPLY_METHOD, PrevUpperBoundVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, stride_variable, 51, MX_APPLY_METHOD, StrideVariable, Expr, NthStmt) - MX_VISIT_ENTITY(OMPLoopDirective, upper_bound_variable, 52, MX_APPLY_METHOD, UpperBoundVariable, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, initializers, 53, MX_APPLY_METHOD, Initializers, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, private_counters, 54, MX_APPLY_METHOD, PrivateCounters, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPLoopDirective, updates, 55, MX_APPLY_METHOD, Updates, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, counters, 16, MX_APPLY_METHOD, Counters, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, dependent_counters, 28, MX_APPLY_METHOD, DependentCounters, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, dependent_initializers, 29, MX_APPLY_METHOD, DependentInitializers, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, finals, 30, MX_APPLY_METHOD, Finals, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, finals_conditions, 31, MX_APPLY_METHOD, FinalsConditions, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, body, 15, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, calculate_last_iteration, 18, MX_APPLY_METHOD, CalculateLastIteration, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_condition, 19, MX_APPLY_METHOD, CombinedCondition, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_distance_condition, 20, MX_APPLY_METHOD, CombinedDistanceCondition, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_ensure_upper_bound, 21, MX_APPLY_METHOD, CombinedEnsureUpperBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_initializer, 22, MX_APPLY_METHOD, CombinedInitializer, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_lower_bound_variable, 23, MX_APPLY_METHOD, CombinedLowerBoundVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_next_lower_bound, 32, MX_APPLY_METHOD, CombinedNextLowerBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_next_upper_bound, 33, MX_APPLY_METHOD, CombinedNextUpperBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_parallel_for_in_distance_condition, 34, MX_APPLY_METHOD, CombinedParallelForInDistanceCondition, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, combined_upper_bound_variable, 35, MX_APPLY_METHOD, CombinedUpperBoundVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, condition, 36, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, distance_increment, 37, MX_APPLY_METHOD, DistanceIncrement, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, ensure_upper_bound, 38, MX_APPLY_METHOD, EnsureUpperBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, increment, 39, MX_APPLY_METHOD, Increment, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, initializer, 40, MX_APPLY_METHOD, Initializer, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, is_last_iteration_variable, 41, MX_APPLY_METHOD, IsLastIterationVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, iteration_variable, 42, MX_APPLY_METHOD, IterationVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, last_iteration, 43, MX_APPLY_METHOD, LastIteration, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, lower_bound_variable, 44, MX_APPLY_METHOD, LowerBoundVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, next_lower_bound, 45, MX_APPLY_METHOD, NextLowerBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, next_upper_bound, 46, MX_APPLY_METHOD, NextUpperBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, pre_condition, 47, MX_APPLY_METHOD, PreCondition, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, pre_initializers, 48, MX_APPLY_METHOD, PreInitializers, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, prev_ensure_upper_bound, 49, MX_APPLY_METHOD, PrevEnsureUpperBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, prev_lower_bound_variable, 50, MX_APPLY_METHOD, PrevLowerBoundVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, prev_upper_bound_variable, 51, MX_APPLY_METHOD, PrevUpperBoundVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, stride_variable, 52, MX_APPLY_METHOD, StrideVariable, Expr, NthStmt) + MX_VISIT_ENTITY(OMPLoopDirective, upper_bound_variable, 53, MX_APPLY_METHOD, UpperBoundVariable, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, initializers, 54, MX_APPLY_METHOD, Initializers, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, private_counters, 55, MX_APPLY_METHOD, PrivateCounters, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPLoopDirective, updates, 56, MX_APPLY_METHOD, Updates, Expr, NthStmt) MX_EXIT_VISIT_OMPLoopDirective MX_END_VISIT_STMT(OMPLoopDirective) @@ -14859,8 +14863,8 @@ MX_END_VISIT_STMT(OMPForSimdDirective) MX_BEGIN_VISIT_STMT(OMPForDirective) MX_ENTER_VISIT_OMPForDirective MX_VISIT_BASE(OMPForDirective, OMPLoopDirective) - MX_VISIT_ENTITY(OMPForDirective, task_reduction_reference_expression, 56, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPForDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPForDirective, task_reduction_reference_expression, 57, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPForDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPForDirective MX_END_VISIT_STMT(OMPForDirective) @@ -14900,8 +14904,8 @@ MX_END_VISIT_STMT(OMPDistributeParallelForSimdDirective) MX_BEGIN_VISIT_STMT(OMPDistributeParallelForDirective) MX_ENTER_VISIT_OMPDistributeParallelForDirective MX_VISIT_BASE(OMPDistributeParallelForDirective, OMPLoopDirective) - MX_VISIT_ENTITY(OMPDistributeParallelForDirective, task_reduction_reference_expression, 56, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPDistributeParallelForDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPDistributeParallelForDirective, task_reduction_reference_expression, 57, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPDistributeParallelForDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPDistributeParallelForDirective MX_END_VISIT_STMT(OMPDistributeParallelForDirective) @@ -14967,8 +14971,8 @@ MX_END_VISIT_STMT(OMPTeamsDistributeParallelForSimdDirective) MX_BEGIN_VISIT_STMT(OMPTeamsDistributeParallelForDirective) MX_ENTER_VISIT_OMPTeamsDistributeParallelForDirective MX_VISIT_BASE(OMPTeamsDistributeParallelForDirective, OMPLoopDirective) - MX_VISIT_ENTITY(OMPTeamsDistributeParallelForDirective, task_reduction_reference_expression, 56, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPTeamsDistributeParallelForDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPTeamsDistributeParallelForDirective, task_reduction_reference_expression, 57, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPTeamsDistributeParallelForDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPTeamsDistributeParallelForDirective MX_END_VISIT_STMT(OMPTeamsDistributeParallelForDirective) @@ -15008,7 +15012,7 @@ MX_END_VISIT_STMT(OMPTaskLoopSimdDirective) MX_BEGIN_VISIT_STMT(OMPTaskLoopDirective) MX_ENTER_VISIT_OMPTaskLoopDirective MX_VISIT_BASE(OMPTaskLoopDirective, OMPLoopDirective) - MX_VISIT_BOOL(OMPTaskLoopDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_BOOL(OMPTaskLoopDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPTaskLoopDirective MX_END_VISIT_STMT(OMPTaskLoopDirective) @@ -15061,8 +15065,8 @@ MX_END_VISIT_STMT(OMPTargetTeamsDistributeParallelForSimdDirective) MX_BEGIN_VISIT_STMT(OMPTargetTeamsDistributeParallelForDirective) MX_ENTER_VISIT_OMPTargetTeamsDistributeParallelForDirective MX_VISIT_BASE(OMPTargetTeamsDistributeParallelForDirective, OMPLoopDirective) - MX_VISIT_ENTITY(OMPTargetTeamsDistributeParallelForDirective, task_reduction_reference_expression, 56, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPTargetTeamsDistributeParallelForDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPTargetTeamsDistributeParallelForDirective, task_reduction_reference_expression, 57, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPTargetTeamsDistributeParallelForDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPTargetTeamsDistributeParallelForDirective MX_END_VISIT_STMT(OMPTargetTeamsDistributeParallelForDirective) @@ -15128,8 +15132,8 @@ MX_END_VISIT_STMT(OMPTargetParallelForSimdDirective) MX_BEGIN_VISIT_STMT(OMPTargetParallelForDirective) MX_ENTER_VISIT_OMPTargetParallelForDirective MX_VISIT_BASE(OMPTargetParallelForDirective, OMPLoopDirective) - MX_VISIT_ENTITY(OMPTargetParallelForDirective, task_reduction_reference_expression, 56, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPTargetParallelForDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPTargetParallelForDirective, task_reduction_reference_expression, 57, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPTargetParallelForDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPTargetParallelForDirective MX_END_VISIT_STMT(OMPTargetParallelForDirective) @@ -15169,7 +15173,7 @@ MX_END_VISIT_STMT(OMPParallelMasterTaskLoopSimdDirective) MX_BEGIN_VISIT_STMT(OMPParallelMasterTaskLoopDirective) MX_ENTER_VISIT_OMPParallelMasterTaskLoopDirective MX_VISIT_BASE(OMPParallelMasterTaskLoopDirective, OMPLoopDirective) - MX_VISIT_BOOL(OMPParallelMasterTaskLoopDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_BOOL(OMPParallelMasterTaskLoopDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPParallelMasterTaskLoopDirective MX_END_VISIT_STMT(OMPParallelMasterTaskLoopDirective) @@ -15196,7 +15200,7 @@ MX_END_VISIT_STMT(OMPParallelMaskedTaskLoopSimdDirective) MX_BEGIN_VISIT_STMT(OMPParallelMaskedTaskLoopDirective) MX_ENTER_VISIT_OMPParallelMaskedTaskLoopDirective MX_VISIT_BASE(OMPParallelMaskedTaskLoopDirective, OMPLoopDirective) - MX_VISIT_BOOL(OMPParallelMaskedTaskLoopDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_BOOL(OMPParallelMaskedTaskLoopDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPParallelMaskedTaskLoopDirective MX_END_VISIT_STMT(OMPParallelMaskedTaskLoopDirective) @@ -15236,8 +15240,8 @@ MX_END_VISIT_STMT(OMPParallelForSimdDirective) MX_BEGIN_VISIT_STMT(OMPParallelForDirective) MX_ENTER_VISIT_OMPParallelForDirective MX_VISIT_BASE(OMPParallelForDirective, OMPLoopDirective) - MX_VISIT_ENTITY(OMPParallelForDirective, task_reduction_reference_expression, 56, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OMPParallelForDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_ENTITY(OMPParallelForDirective, task_reduction_reference_expression, 57, MX_APPLY_METHOD, TaskReductionReferenceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OMPParallelForDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPParallelForDirective MX_END_VISIT_STMT(OMPParallelForDirective) @@ -15264,7 +15268,7 @@ MX_END_VISIT_STMT(OMPMasterTaskLoopSimdDirective) MX_BEGIN_VISIT_STMT(OMPMasterTaskLoopDirective) MX_ENTER_VISIT_OMPMasterTaskLoopDirective MX_VISIT_BASE(OMPMasterTaskLoopDirective, OMPLoopDirective) - MX_VISIT_BOOL(OMPMasterTaskLoopDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_BOOL(OMPMasterTaskLoopDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPMasterTaskLoopDirective MX_END_VISIT_STMT(OMPMasterTaskLoopDirective) @@ -15291,7 +15295,7 @@ MX_END_VISIT_STMT(OMPMaskedTaskLoopSimdDirective) MX_BEGIN_VISIT_STMT(OMPMaskedTaskLoopDirective) MX_ENTER_VISIT_OMPMaskedTaskLoopDirective MX_VISIT_BASE(OMPMaskedTaskLoopDirective, OMPLoopDirective) - MX_VISIT_BOOL(OMPMaskedTaskLoopDirective, has_cancel, 23, MX_APPLY_METHOD, HasCancel, bool, NthStmt) + MX_VISIT_BOOL(OMPMaskedTaskLoopDirective, has_cancel, 24, MX_APPLY_METHOD, HasCancel, bool, NthStmt) MX_EXIT_VISIT_OMPMaskedTaskLoopDirective MX_END_VISIT_STMT(OMPMaskedTaskLoopDirective) @@ -15331,10 +15335,10 @@ MX_END_VISIT_STMT(OMPFlushDirective) MX_BEGIN_VISIT_STMT(OMPCanonicalLoop) MX_ENTER_VISIT_OMPCanonicalLoop MX_VISIT_BASE(OMPCanonicalLoop, Stmt) - MX_VISIT_ENTITY(OMPCanonicalLoop, distance_func, 9, MX_APPLY_METHOD, DistanceFunc, CapturedStmt, NthStmt) - MX_VISIT_ENTITY(OMPCanonicalLoop, loop_statement, 10, MX_APPLY_METHOD, LoopStatement, Stmt, NthStmt) - MX_VISIT_ENTITY(OMPCanonicalLoop, loop_variable_func, 11, MX_APPLY_METHOD, LoopVariableFunc, CapturedStmt, NthStmt) - MX_VISIT_ENTITY(OMPCanonicalLoop, loop_variable_reference, 13, MX_APPLY_METHOD, LoopVariableReference, DeclRefExpr, NthStmt) + MX_VISIT_ENTITY(OMPCanonicalLoop, distance_func, 10, MX_APPLY_METHOD, DistanceFunc, CapturedStmt, NthStmt) + MX_VISIT_ENTITY(OMPCanonicalLoop, loop_statement, 11, MX_APPLY_METHOD, LoopStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(OMPCanonicalLoop, loop_variable_func, 12, MX_APPLY_METHOD, LoopVariableFunc, CapturedStmt, NthStmt) + MX_VISIT_ENTITY(OMPCanonicalLoop, loop_variable_reference, 14, MX_APPLY_METHOD, LoopVariableReference, DeclRefExpr, NthStmt) MX_EXIT_VISIT_OMPCanonicalLoop MX_END_VISIT_STMT(OMPCanonicalLoop) @@ -15348,8 +15352,8 @@ MX_END_VISIT_STMT(OMPCanonicalLoop) MX_BEGIN_VISIT_STMT(NullStmt) MX_ENTER_VISIT_NullStmt MX_VISIT_BASE(NullStmt, Stmt) - MX_VISIT_ENTITY(NullStmt, semi_token, 9, MX_APPLY_METHOD, SemiToken, Token, NthStmt) - MX_VISIT_BOOL(NullStmt, has_leading_empty_macro, 12, MX_APPLY_METHOD, HasLeadingEmptyMacro, bool, NthStmt) + MX_VISIT_ENTITY(NullStmt, semi_token, 10, MX_APPLY_METHOD, SemiToken, Token, NthStmt) + MX_VISIT_BOOL(NullStmt, has_leading_empty_macro, 13, MX_APPLY_METHOD, HasLeadingEmptyMacro, bool, NthStmt) MX_EXIT_VISIT_NullStmt MX_END_VISIT_STMT(NullStmt) @@ -15363,10 +15367,10 @@ MX_END_VISIT_STMT(NullStmt) MX_BEGIN_VISIT_STMT(MSDependentExistsStmt) MX_ENTER_VISIT_MSDependentExistsStmt MX_VISIT_BASE(MSDependentExistsStmt, Stmt) - MX_VISIT_ENTITY(MSDependentExistsStmt, keyword_token, 9, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) - MX_VISIT_ENTITY(MSDependentExistsStmt, sub_statement, 10, MX_APPLY_METHOD, SubStatement, CompoundStmt, NthStmt) - MX_VISIT_BOOL(MSDependentExistsStmt, is_if_exists, 12, MX_APPLY_METHOD, IsIfExists, bool, NthStmt) - MX_VISIT_BOOL(MSDependentExistsStmt, is_if_not_exists, 16, MX_APPLY_METHOD, IsIfNotExists, bool, NthStmt) + MX_VISIT_ENTITY(MSDependentExistsStmt, keyword_token, 10, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) + MX_VISIT_ENTITY(MSDependentExistsStmt, sub_statement, 11, MX_APPLY_METHOD, SubStatement, CompoundStmt, NthStmt) + MX_VISIT_BOOL(MSDependentExistsStmt, is_if_exists, 13, MX_APPLY_METHOD, IsIfExists, bool, NthStmt) + MX_VISIT_BOOL(MSDependentExistsStmt, is_if_not_exists, 17, MX_APPLY_METHOD, IsIfNotExists, bool, NthStmt) MX_EXIT_VISIT_MSDependentExistsStmt MX_END_VISIT_STMT(MSDependentExistsStmt) @@ -15380,10 +15384,10 @@ MX_END_VISIT_STMT(MSDependentExistsStmt) MX_BEGIN_VISIT_STMT(IndirectGotoStmt) MX_ENTER_VISIT_IndirectGotoStmt MX_VISIT_BASE(IndirectGotoStmt, Stmt) - MX_VISIT_OPTIONAL_ENTITY(IndirectGotoStmt, constant_target, 9, MX_APPLY_METHOD, ConstantTarget, LabelDecl, NthStmt) - MX_VISIT_ENTITY(IndirectGotoStmt, goto_token, 10, MX_APPLY_METHOD, GotoToken, Token, NthStmt) - MX_VISIT_ENTITY(IndirectGotoStmt, star_token, 11, MX_APPLY_METHOD, StarToken, Token, NthStmt) - MX_VISIT_ENTITY(IndirectGotoStmt, target, 13, MX_APPLY_METHOD, Target, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(IndirectGotoStmt, constant_target, 10, MX_APPLY_METHOD, ConstantTarget, LabelDecl, NthStmt) + MX_VISIT_ENTITY(IndirectGotoStmt, goto_token, 11, MX_APPLY_METHOD, GotoToken, Token, NthStmt) + MX_VISIT_ENTITY(IndirectGotoStmt, star_token, 12, MX_APPLY_METHOD, StarToken, Token, NthStmt) + MX_VISIT_ENTITY(IndirectGotoStmt, target, 14, MX_APPLY_METHOD, Target, Expr, NthStmt) MX_EXIT_VISIT_IndirectGotoStmt MX_END_VISIT_STMT(IndirectGotoStmt) @@ -15397,26 +15401,26 @@ MX_END_VISIT_STMT(IndirectGotoStmt) MX_BEGIN_VISIT_STMT(IfStmt) MX_ENTER_VISIT_IfStmt MX_VISIT_BASE(IfStmt, Stmt) - MX_VISIT_ENTITY(IfStmt, condition, 9, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(IfStmt, condition_variable, 10, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(IfStmt, condition_variable_declaration_statement, 11, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(IfStmt, else_, 13, MX_APPLY_METHOD, Else, Stmt, NthStmt) - MX_VISIT_ENTITY(IfStmt, else_token, 14, MX_APPLY_METHOD, ElseToken, Token, NthStmt) - MX_VISIT_ENTITY(IfStmt, if_token, 17, MX_APPLY_METHOD, IfToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(IfStmt, initializer, 18, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) - MX_VISIT_ENTITY(IfStmt, l_paren_token, 19, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(IfStmt, nondiscarded_case, 20, MX_APPLY_METHOD, NondiscardedCase, Stmt, NthStmt) - MX_VISIT_ENTITY(IfStmt, r_paren_token, 21, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENUM(IfStmt, statement_kind, 57, MX_APPLY_METHOD, StatementKind, IfStatementKind, NthStmt) - MX_VISIT_ENTITY(IfStmt, then, 22, MX_APPLY_METHOD, Then, Stmt, NthStmt) - MX_VISIT_BOOL(IfStmt, has_else_storage, 12, MX_APPLY_METHOD, HasElseStorage, bool, NthStmt) - MX_VISIT_BOOL(IfStmt, has_initializer_storage, 16, MX_APPLY_METHOD, HasInitializerStorage, bool, NthStmt) - MX_VISIT_BOOL(IfStmt, has_variable_storage, 23, MX_APPLY_METHOD, HasVariableStorage, bool, NthStmt) - MX_VISIT_BOOL(IfStmt, is_consteval, 24, MX_APPLY_METHOD, IsConsteval, bool, NthStmt) - MX_VISIT_BOOL(IfStmt, is_constexpr, 25, MX_APPLY_METHOD, IsConstexpr, bool, NthStmt) - MX_VISIT_BOOL(IfStmt, is_negated_consteval, 58, MX_APPLY_METHOD, IsNegatedConsteval, bool, NthStmt) - MX_VISIT_BOOL(IfStmt, is_non_negated_consteval, 59, MX_APPLY_METHOD, IsNonNegatedConsteval, bool, NthStmt) - MX_VISIT_BOOL(IfStmt, is_obj_c_availability_check, 60, MX_APPLY_METHOD, IsObjCAvailabilityCheck, bool, NthStmt) + MX_VISIT_ENTITY(IfStmt, condition, 10, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(IfStmt, condition_variable, 11, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(IfStmt, condition_variable_declaration_statement, 12, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(IfStmt, else_, 14, MX_APPLY_METHOD, Else, Stmt, NthStmt) + MX_VISIT_ENTITY(IfStmt, else_token, 15, MX_APPLY_METHOD, ElseToken, Token, NthStmt) + MX_VISIT_ENTITY(IfStmt, if_token, 18, MX_APPLY_METHOD, IfToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(IfStmt, initializer, 19, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) + MX_VISIT_ENTITY(IfStmt, l_paren_token, 20, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(IfStmt, nondiscarded_case, 21, MX_APPLY_METHOD, NondiscardedCase, Stmt, NthStmt) + MX_VISIT_ENTITY(IfStmt, r_paren_token, 22, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENUM(IfStmt, statement_kind, 58, MX_APPLY_METHOD, StatementKind, IfStatementKind, NthStmt) + MX_VISIT_ENTITY(IfStmt, then, 23, MX_APPLY_METHOD, Then, Stmt, NthStmt) + MX_VISIT_BOOL(IfStmt, has_else_storage, 13, MX_APPLY_METHOD, HasElseStorage, bool, NthStmt) + MX_VISIT_BOOL(IfStmt, has_initializer_storage, 17, MX_APPLY_METHOD, HasInitializerStorage, bool, NthStmt) + MX_VISIT_BOOL(IfStmt, has_variable_storage, 24, MX_APPLY_METHOD, HasVariableStorage, bool, NthStmt) + MX_VISIT_BOOL(IfStmt, is_consteval, 25, MX_APPLY_METHOD, IsConsteval, bool, NthStmt) + MX_VISIT_BOOL(IfStmt, is_constexpr, 26, MX_APPLY_METHOD, IsConstexpr, bool, NthStmt) + MX_VISIT_BOOL(IfStmt, is_negated_consteval, 59, MX_APPLY_METHOD, IsNegatedConsteval, bool, NthStmt) + MX_VISIT_BOOL(IfStmt, is_non_negated_consteval, 60, MX_APPLY_METHOD, IsNonNegatedConsteval, bool, NthStmt) + MX_VISIT_BOOL(IfStmt, is_obj_c_availability_check, 61, MX_APPLY_METHOD, IsObjCAvailabilityCheck, bool, NthStmt) MX_EXIT_VISIT_IfStmt MX_END_VISIT_STMT(IfStmt) @@ -15430,9 +15434,9 @@ MX_END_VISIT_STMT(IfStmt) MX_BEGIN_VISIT_STMT(GotoStmt) MX_ENTER_VISIT_GotoStmt MX_VISIT_BASE(GotoStmt, Stmt) - MX_VISIT_ENTITY(GotoStmt, goto_token, 9, MX_APPLY_METHOD, GotoToken, Token, NthStmt) - MX_VISIT_ENTITY(GotoStmt, label, 10, MX_APPLY_METHOD, Label, LabelDecl, NthStmt) - MX_VISIT_ENTITY(GotoStmt, label_token, 11, MX_APPLY_METHOD, LabelToken, Token, NthStmt) + MX_VISIT_ENTITY(GotoStmt, goto_token, 10, MX_APPLY_METHOD, GotoToken, Token, NthStmt) + MX_VISIT_ENTITY(GotoStmt, label, 11, MX_APPLY_METHOD, Label, LabelDecl, NthStmt) + MX_VISIT_ENTITY(GotoStmt, label_token, 12, MX_APPLY_METHOD, LabelToken, Token, NthStmt) MX_EXIT_VISIT_GotoStmt MX_END_VISIT_STMT(GotoStmt) @@ -15446,15 +15450,15 @@ MX_END_VISIT_STMT(GotoStmt) MX_BEGIN_VISIT_STMT(ForStmt) MX_ENTER_VISIT_ForStmt MX_VISIT_BASE(ForStmt, Stmt) - MX_VISIT_ENTITY(ForStmt, body, 9, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(ForStmt, condition, 10, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(ForStmt, condition_variable, 11, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(ForStmt, condition_variable_declaration_statement, 13, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) - MX_VISIT_ENTITY(ForStmt, for_token, 14, MX_APPLY_METHOD, ForToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(ForStmt, increment, 17, MX_APPLY_METHOD, Increment, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(ForStmt, initializer, 18, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) - MX_VISIT_ENTITY(ForStmt, l_paren_token, 19, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(ForStmt, r_paren_token, 20, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ForStmt, body, 10, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ForStmt, condition, 11, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ForStmt, condition_variable, 12, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ForStmt, condition_variable_declaration_statement, 14, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) + MX_VISIT_ENTITY(ForStmt, for_token, 15, MX_APPLY_METHOD, ForToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ForStmt, increment, 18, MX_APPLY_METHOD, Increment, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ForStmt, initializer, 19, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) + MX_VISIT_ENTITY(ForStmt, l_paren_token, 20, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ForStmt, r_paren_token, 21, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_ForStmt MX_END_VISIT_STMT(ForStmt) @@ -15468,11 +15472,11 @@ MX_END_VISIT_STMT(ForStmt) MX_BEGIN_VISIT_STMT(DoStmt) MX_ENTER_VISIT_DoStmt MX_VISIT_BASE(DoStmt, Stmt) - MX_VISIT_ENTITY(DoStmt, body, 9, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(DoStmt, condition, 10, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_ENTITY(DoStmt, do_token, 11, MX_APPLY_METHOD, DoToken, Token, NthStmt) - MX_VISIT_ENTITY(DoStmt, r_paren_token, 13, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(DoStmt, while_token, 14, MX_APPLY_METHOD, WhileToken, Token, NthStmt) + MX_VISIT_ENTITY(DoStmt, body, 10, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(DoStmt, condition, 11, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_ENTITY(DoStmt, do_token, 12, MX_APPLY_METHOD, DoToken, Token, NthStmt) + MX_VISIT_ENTITY(DoStmt, r_paren_token, 14, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(DoStmt, while_token, 15, MX_APPLY_METHOD, WhileToken, Token, NthStmt) MX_EXIT_VISIT_DoStmt MX_END_VISIT_STMT(DoStmt) @@ -15486,9 +15490,9 @@ MX_END_VISIT_STMT(DoStmt) MX_BEGIN_VISIT_STMT(DeclStmt) MX_ENTER_VISIT_DeclStmt MX_VISIT_BASE(DeclStmt, Stmt) - MX_VISIT_ENTITY_LIST(DeclStmt, declarations, 15, MX_APPLY_METHOD, Declarations, Decl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(DeclStmt, single_declaration, 9, MX_APPLY_METHOD, SingleDeclaration, Decl, NthStmt) - MX_VISIT_BOOL(DeclStmt, is_single_declaration, 12, MX_APPLY_METHOD, IsSingleDeclaration, bool, NthStmt) + MX_VISIT_ENTITY_LIST(DeclStmt, declarations, 16, MX_APPLY_METHOD, Declarations, Decl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(DeclStmt, single_declaration, 10, MX_APPLY_METHOD, SingleDeclaration, Decl, NthStmt) + MX_VISIT_BOOL(DeclStmt, is_single_declaration, 13, MX_APPLY_METHOD, IsSingleDeclaration, bool, NthStmt) MX_EXIT_VISIT_DeclStmt MX_END_VISIT_STMT(DeclStmt) @@ -15502,23 +15506,23 @@ MX_END_VISIT_STMT(DeclStmt) MX_BEGIN_VISIT_STMT(CoroutineBodyStmt) MX_ENTER_VISIT_CoroutineBodyStmt MX_VISIT_BASE(CoroutineBodyStmt, Stmt) - MX_VISIT_ENTITY_LIST(CoroutineBodyStmt, children_excl_body, 15, MX_APPLY_METHOD, ChildrenExclBody, Stmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, allocate, 9, MX_APPLY_METHOD, Allocate, Expr, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, body, 10, MX_APPLY_METHOD, Body, CompoundStmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, deallocate, 11, MX_APPLY_METHOD, Deallocate, Expr, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, exception_handler, 13, MX_APPLY_METHOD, ExceptionHandler, Stmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, fallthrough_handler, 14, MX_APPLY_METHOD, FallthroughHandler, Stmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, final_suspend_statement, 17, MX_APPLY_METHOD, FinalSuspendStatement, Stmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, initializer_suspend_statement, 18, MX_APPLY_METHOD, InitializerSuspendStatement, Stmt, NthStmt) - MX_VISIT_ENTITY_LIST(CoroutineBodyStmt, parameter_moves, 27, MX_APPLY_METHOD, ParameterMoves, Stmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, promise_declaration, 19, MX_APPLY_METHOD, PromiseDeclaration, VarDecl, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, promise_declaration_statement, 20, MX_APPLY_METHOD, PromiseDeclarationStatement, Stmt, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CoroutineBodyStmt, result_declaration, 21, MX_APPLY_METHOD, ResultDeclaration, Stmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, return_statement, 22, MX_APPLY_METHOD, ReturnStatement, Stmt, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CoroutineBodyStmt, return_statement_on_alloc_failure, 31, MX_APPLY_METHOD, ReturnStatementOnAllocFailure, Stmt, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, return_value, 32, MX_APPLY_METHOD, ReturnValue, Expr, NthStmt) - MX_VISIT_ENTITY(CoroutineBodyStmt, return_value_initializer, 33, MX_APPLY_METHOD, ReturnValueInitializer, Expr, NthStmt) - MX_VISIT_BOOL(CoroutineBodyStmt, has_dependent_promise_type, 12, MX_APPLY_METHOD, HasDependentPromiseType, bool, NthStmt) + MX_VISIT_ENTITY_LIST(CoroutineBodyStmt, children_excl_body, 16, MX_APPLY_METHOD, ChildrenExclBody, Stmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, allocate, 10, MX_APPLY_METHOD, Allocate, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, body, 11, MX_APPLY_METHOD, Body, CompoundStmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, deallocate, 12, MX_APPLY_METHOD, Deallocate, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, exception_handler, 14, MX_APPLY_METHOD, ExceptionHandler, Stmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, fallthrough_handler, 15, MX_APPLY_METHOD, FallthroughHandler, Stmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, final_suspend_statement, 18, MX_APPLY_METHOD, FinalSuspendStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, initializer_suspend_statement, 19, MX_APPLY_METHOD, InitializerSuspendStatement, Stmt, NthStmt) + MX_VISIT_ENTITY_LIST(CoroutineBodyStmt, parameter_moves, 28, MX_APPLY_METHOD, ParameterMoves, Stmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, promise_declaration, 20, MX_APPLY_METHOD, PromiseDeclaration, VarDecl, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, promise_declaration_statement, 21, MX_APPLY_METHOD, PromiseDeclarationStatement, Stmt, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CoroutineBodyStmt, result_declaration, 22, MX_APPLY_METHOD, ResultDeclaration, Stmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, return_statement, 23, MX_APPLY_METHOD, ReturnStatement, Stmt, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CoroutineBodyStmt, return_statement_on_alloc_failure, 32, MX_APPLY_METHOD, ReturnStatementOnAllocFailure, Stmt, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, return_value, 33, MX_APPLY_METHOD, ReturnValue, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineBodyStmt, return_value_initializer, 34, MX_APPLY_METHOD, ReturnValueInitializer, Expr, NthStmt) + MX_VISIT_BOOL(CoroutineBodyStmt, has_dependent_promise_type, 13, MX_APPLY_METHOD, HasDependentPromiseType, bool, NthStmt) MX_EXIT_VISIT_CoroutineBodyStmt MX_END_VISIT_STMT(CoroutineBodyStmt) @@ -15532,10 +15536,10 @@ MX_END_VISIT_STMT(CoroutineBodyStmt) MX_BEGIN_VISIT_STMT(CoreturnStmt) MX_ENTER_VISIT_CoreturnStmt MX_VISIT_BASE(CoreturnStmt, Stmt) - MX_VISIT_ENTITY(CoreturnStmt, keyword_token, 9, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CoreturnStmt, operand, 10, MX_APPLY_METHOD, Operand, Expr, NthStmt) - MX_VISIT_ENTITY(CoreturnStmt, promise_call, 11, MX_APPLY_METHOD, PromiseCall, Expr, NthStmt) - MX_VISIT_BOOL(CoreturnStmt, is_implicit, 12, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) + MX_VISIT_ENTITY(CoreturnStmt, keyword_token, 10, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CoreturnStmt, operand, 11, MX_APPLY_METHOD, Operand, Expr, NthStmt) + MX_VISIT_ENTITY(CoreturnStmt, promise_call, 12, MX_APPLY_METHOD, PromiseCall, Expr, NthStmt) + MX_VISIT_BOOL(CoreturnStmt, is_implicit, 13, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) MX_EXIT_VISIT_CoreturnStmt MX_END_VISIT_STMT(CoreturnStmt) @@ -15549,7 +15553,7 @@ MX_END_VISIT_STMT(CoreturnStmt) MX_BEGIN_VISIT_STMT(ContinueStmt) MX_ENTER_VISIT_ContinueStmt MX_VISIT_BASE(ContinueStmt, Stmt) - MX_VISIT_ENTITY(ContinueStmt, continue_token, 9, MX_APPLY_METHOD, ContinueToken, Token, NthStmt) + MX_VISIT_ENTITY(ContinueStmt, continue_token, 10, MX_APPLY_METHOD, ContinueToken, Token, NthStmt) MX_EXIT_VISIT_ContinueStmt MX_END_VISIT_STMT(ContinueStmt) @@ -15563,11 +15567,11 @@ MX_END_VISIT_STMT(ContinueStmt) MX_BEGIN_VISIT_STMT(CompoundStmt) MX_ENTER_VISIT_CompoundStmt MX_VISIT_BASE(CompoundStmt, Stmt) - MX_VISIT_ENTITY(CompoundStmt, left_brace_token, 9, MX_APPLY_METHOD, LeftBraceToken, Token, NthStmt) - MX_VISIT_ENTITY(CompoundStmt, right_brace_token, 10, MX_APPLY_METHOD, RightBraceToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CompoundStmt, statement_expression_result, 11, MX_APPLY_METHOD, StatementExpressionResult, Stmt, NthStmt) - MX_VISIT_BOOL(CompoundStmt, has_stored_fp_features, 12, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) - MX_VISIT_INT(CompoundStmt, size, 26, MX_APPLY_METHOD, Size, uint32_t, NthStmt) + MX_VISIT_ENTITY(CompoundStmt, left_brace_token, 10, MX_APPLY_METHOD, LeftBraceToken, Token, NthStmt) + MX_VISIT_ENTITY(CompoundStmt, right_brace_token, 11, MX_APPLY_METHOD, RightBraceToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CompoundStmt, statement_expression_result, 12, MX_APPLY_METHOD, StatementExpressionResult, Stmt, NthStmt) + MX_VISIT_BOOL(CompoundStmt, has_stored_fp_features, 13, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) + MX_VISIT_INT(CompoundStmt, size, 27, MX_APPLY_METHOD, Size, uint32_t, NthStmt) MX_EXIT_VISIT_CompoundStmt MX_END_VISIT_STMT(CompoundStmt) @@ -15581,10 +15585,10 @@ MX_END_VISIT_STMT(CompoundStmt) MX_BEGIN_VISIT_STMT(CapturedStmt) MX_ENTER_VISIT_CapturedStmt MX_VISIT_BASE(CapturedStmt, Stmt) - MX_VISIT_ENTITY(CapturedStmt, captured_declaration, 9, MX_APPLY_METHOD, CapturedDeclaration, CapturedDecl, NthStmt) - MX_VISIT_ENTITY(CapturedStmt, captured_record_declaration, 10, MX_APPLY_METHOD, CapturedRecordDeclaration, RecordDecl, NthStmt) - MX_VISIT_ENUM(CapturedStmt, captured_region_kind, 57, MX_APPLY_METHOD, CapturedRegionKind, CapturedRegionKind, NthStmt) - MX_VISIT_ENTITY(CapturedStmt, captured_statement, 11, MX_APPLY_METHOD, CapturedStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(CapturedStmt, captured_declaration, 10, MX_APPLY_METHOD, CapturedDeclaration, CapturedDecl, NthStmt) + MX_VISIT_ENTITY(CapturedStmt, captured_record_declaration, 11, MX_APPLY_METHOD, CapturedRecordDeclaration, RecordDecl, NthStmt) + MX_VISIT_ENUM(CapturedStmt, captured_region_kind, 58, MX_APPLY_METHOD, CapturedRegionKind, CapturedRegionKind, NthStmt) + MX_VISIT_ENTITY(CapturedStmt, captured_statement, 12, MX_APPLY_METHOD, CapturedStatement, Stmt, NthStmt) MX_EXIT_VISIT_CapturedStmt MX_END_VISIT_STMT(CapturedStmt) @@ -15598,9 +15602,9 @@ MX_END_VISIT_STMT(CapturedStmt) MX_BEGIN_VISIT_STMT(CXXTryStmt) MX_ENTER_VISIT_CXXTryStmt MX_VISIT_BASE(CXXTryStmt, Stmt) - MX_VISIT_ENTITY(CXXTryStmt, try_block, 9, MX_APPLY_METHOD, TryBlock, CompoundStmt, NthStmt) - MX_VISIT_ENTITY(CXXTryStmt, try_token, 10, MX_APPLY_METHOD, TryToken, Token, NthStmt) - MX_VISIT_ENTITY_LIST(CXXTryStmt, handlers, 15, MX_APPLY_METHOD, Handlers, CXXCatchStmt, NthStmt) + MX_VISIT_ENTITY(CXXTryStmt, try_block, 10, MX_APPLY_METHOD, TryBlock, CompoundStmt, NthStmt) + MX_VISIT_ENTITY(CXXTryStmt, try_token, 11, MX_APPLY_METHOD, TryToken, Token, NthStmt) + MX_VISIT_ENTITY_LIST(CXXTryStmt, handlers, 16, MX_APPLY_METHOD, Handlers, CXXCatchStmt, NthStmt) MX_EXIT_VISIT_CXXTryStmt MX_END_VISIT_STMT(CXXTryStmt) @@ -15614,20 +15618,20 @@ MX_END_VISIT_STMT(CXXTryStmt) MX_BEGIN_VISIT_STMT(CXXForRangeStmt) MX_ENTER_VISIT_CXXForRangeStmt MX_VISIT_BASE(CXXForRangeStmt, Stmt) - MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, begin_statement, 9, MX_APPLY_METHOD, BeginStatement, DeclStmt, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, body, 10, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, coawait_token, 11, MX_APPLY_METHOD, CoawaitToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, colon_token, 13, MX_APPLY_METHOD, ColonToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, condition, 14, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, end_statement, 17, MX_APPLY_METHOD, EndStatement, DeclStmt, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, for_token, 18, MX_APPLY_METHOD, ForToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, increment, 19, MX_APPLY_METHOD, Increment, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, initializer, 20, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, loop_variable_statement, 21, MX_APPLY_METHOD, LoopVariableStatement, DeclStmt, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, loop_variable, 22, MX_APPLY_METHOD, LoopVariable, VarDecl, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, r_paren_token, 31, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, range_initializer, 32, MX_APPLY_METHOD, RangeInitializer, Expr, NthStmt) - MX_VISIT_ENTITY(CXXForRangeStmt, range_statement, 33, MX_APPLY_METHOD, RangeStatement, DeclStmt, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, begin_statement, 10, MX_APPLY_METHOD, BeginStatement, DeclStmt, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, body, 11, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, coawait_token, 12, MX_APPLY_METHOD, CoawaitToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, colon_token, 14, MX_APPLY_METHOD, ColonToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, condition, 15, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, end_statement, 18, MX_APPLY_METHOD, EndStatement, DeclStmt, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, for_token, 19, MX_APPLY_METHOD, ForToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, increment, 20, MX_APPLY_METHOD, Increment, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXForRangeStmt, initializer, 21, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, loop_variable_statement, 22, MX_APPLY_METHOD, LoopVariableStatement, DeclStmt, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, loop_variable, 23, MX_APPLY_METHOD, LoopVariable, VarDecl, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, r_paren_token, 32, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, range_initializer, 33, MX_APPLY_METHOD, RangeInitializer, Expr, NthStmt) + MX_VISIT_ENTITY(CXXForRangeStmt, range_statement, 34, MX_APPLY_METHOD, RangeStatement, DeclStmt, NthStmt) MX_EXIT_VISIT_CXXForRangeStmt MX_END_VISIT_STMT(CXXForRangeStmt) @@ -15641,10 +15645,10 @@ MX_END_VISIT_STMT(CXXForRangeStmt) MX_BEGIN_VISIT_STMT(CXXCatchStmt) MX_ENTER_VISIT_CXXCatchStmt MX_VISIT_BASE(CXXCatchStmt, Stmt) - MX_VISIT_ENTITY(CXXCatchStmt, catch_token, 9, MX_APPLY_METHOD, CatchToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXCatchStmt, caught_type, 10, MX_APPLY_METHOD, CaughtType, Type, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXCatchStmt, exception_declaration, 11, MX_APPLY_METHOD, ExceptionDeclaration, VarDecl, NthStmt) - MX_VISIT_ENTITY(CXXCatchStmt, handler_block, 13, MX_APPLY_METHOD, HandlerBlock, Stmt, NthStmt) + MX_VISIT_ENTITY(CXXCatchStmt, catch_token, 10, MX_APPLY_METHOD, CatchToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXCatchStmt, caught_type, 11, MX_APPLY_METHOD, CaughtType, Type, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXCatchStmt, exception_declaration, 12, MX_APPLY_METHOD, ExceptionDeclaration, VarDecl, NthStmt) + MX_VISIT_ENTITY(CXXCatchStmt, handler_block, 14, MX_APPLY_METHOD, HandlerBlock, Stmt, NthStmt) MX_EXIT_VISIT_CXXCatchStmt MX_END_VISIT_STMT(CXXCatchStmt) @@ -15658,7 +15662,7 @@ MX_END_VISIT_STMT(CXXCatchStmt) MX_BEGIN_VISIT_STMT(BreakStmt) MX_ENTER_VISIT_BreakStmt MX_VISIT_BASE(BreakStmt, Stmt) - MX_VISIT_ENTITY(BreakStmt, break_token, 9, MX_APPLY_METHOD, BreakToken, Token, NthStmt) + MX_VISIT_ENTITY(BreakStmt, break_token, 10, MX_APPLY_METHOD, BreakToken, Token, NthStmt) MX_EXIT_VISIT_BreakStmt MX_END_VISIT_STMT(BreakStmt) @@ -15672,17 +15676,17 @@ MX_END_VISIT_STMT(BreakStmt) MX_BEGIN_VISIT_ABSTRACT_STMT(AsmStmt) MX_ENTER_VISIT_AsmStmt MX_VISIT_BASE(AsmStmt, Stmt) - MX_VISIT_TEXT(AsmStmt, generate_assembly_string, 61, MX_APPLY_METHOD, GenerateAssemblyString, basic_string, NthStmt) - MX_VISIT_ENTITY(AsmStmt, assembly_token, 9, MX_APPLY_METHOD, AssemblyToken, Token, NthStmt) - MX_VISIT_ENTITY_LIST(AsmStmt, inputs, 15, MX_APPLY_METHOD, Inputs, Expr, NthStmt) - MX_VISIT_BOOL(AsmStmt, is_simple, 12, MX_APPLY_METHOD, IsSimple, bool, NthStmt) - MX_VISIT_BOOL(AsmStmt, is_volatile, 16, MX_APPLY_METHOD, IsVolatile, bool, NthStmt) - MX_VISIT_ENTITY_LIST(AsmStmt, outputs, 27, MX_APPLY_METHOD, Outputs, Expr, NthStmt) - MX_VISIT_TEXT_LIST(AsmStmt, output_constraints, 62, MX_APPLY_METHOD, OutputConstraints, basic_string_view, NthStmt) - MX_VISIT_ENTITY_LIST(AsmStmt, output_expressions, 28, MX_APPLY_METHOD, OutputExpressions, Expr, NthStmt) - MX_VISIT_TEXT_LIST(AsmStmt, input_constraints, 63, MX_APPLY_METHOD, InputConstraints, basic_string_view, NthStmt) - MX_VISIT_ENTITY_LIST(AsmStmt, input_expressions, 29, MX_APPLY_METHOD, InputExpressions, Expr, NthStmt) - MX_VISIT_TEXT_LIST(AsmStmt, clobbers, 64, MX_APPLY_METHOD, Clobbers, basic_string_view, NthStmt) + MX_VISIT_TEXT(AsmStmt, generate_assembly_string, 62, MX_APPLY_METHOD, GenerateAssemblyString, basic_string, NthStmt) + MX_VISIT_ENTITY(AsmStmt, assembly_token, 10, MX_APPLY_METHOD, AssemblyToken, Token, NthStmt) + MX_VISIT_ENTITY_LIST(AsmStmt, inputs, 16, MX_APPLY_METHOD, Inputs, Expr, NthStmt) + MX_VISIT_BOOL(AsmStmt, is_simple, 13, MX_APPLY_METHOD, IsSimple, bool, NthStmt) + MX_VISIT_BOOL(AsmStmt, is_volatile, 17, MX_APPLY_METHOD, IsVolatile, bool, NthStmt) + MX_VISIT_ENTITY_LIST(AsmStmt, outputs, 28, MX_APPLY_METHOD, Outputs, Expr, NthStmt) + MX_VISIT_TEXT_LIST(AsmStmt, output_constraints, 63, MX_APPLY_METHOD, OutputConstraints, basic_string_view, NthStmt) + MX_VISIT_ENTITY_LIST(AsmStmt, output_expressions, 29, MX_APPLY_METHOD, OutputExpressions, Expr, NthStmt) + MX_VISIT_TEXT_LIST(AsmStmt, input_constraints, 64, MX_APPLY_METHOD, InputConstraints, basic_string_view, NthStmt) + MX_VISIT_ENTITY_LIST(AsmStmt, input_expressions, 30, MX_APPLY_METHOD, InputExpressions, Expr, NthStmt) + MX_VISIT_TEXT_LIST(AsmStmt, clobbers, 65, MX_APPLY_METHOD, Clobbers, basic_string_view, NthStmt) MX_EXIT_VISIT_AsmStmt MX_END_VISIT_STMT(AsmStmt) @@ -15696,11 +15700,11 @@ MX_END_VISIT_STMT(AsmStmt) MX_BEGIN_VISIT_STMT(MSAsmStmt) MX_ENTER_VISIT_MSAsmStmt MX_VISIT_BASE(MSAsmStmt, AsmStmt) - MX_VISIT_TEXT_LIST(MSAsmStmt, all_constraints, 65, MX_APPLY_METHOD, AllConstraints, basic_string_view, NthStmt) - MX_VISIT_ENTITY_LIST(MSAsmStmt, all_expressions, 30, MX_APPLY_METHOD, AllExpressions, Expr, NthStmt) - MX_VISIT_TEXT(MSAsmStmt, assembly_string, 66, MX_APPLY_METHOD, AssemblyString, basic_string_view, NthStmt) - MX_VISIT_ENTITY(MSAsmStmt, l_brace_token, 10, MX_APPLY_METHOD, LBraceToken, Token, NthStmt) - MX_VISIT_BOOL(MSAsmStmt, has_braces, 23, MX_APPLY_METHOD, HasBraces, bool, NthStmt) + MX_VISIT_TEXT_LIST(MSAsmStmt, all_constraints, 66, MX_APPLY_METHOD, AllConstraints, basic_string_view, NthStmt) + MX_VISIT_ENTITY_LIST(MSAsmStmt, all_expressions, 31, MX_APPLY_METHOD, AllExpressions, Expr, NthStmt) + MX_VISIT_TEXT(MSAsmStmt, assembly_string, 67, MX_APPLY_METHOD, AssemblyString, basic_string_view, NthStmt) + MX_VISIT_ENTITY(MSAsmStmt, l_brace_token, 11, MX_APPLY_METHOD, LBraceToken, Token, NthStmt) + MX_VISIT_BOOL(MSAsmStmt, has_braces, 24, MX_APPLY_METHOD, HasBraces, bool, NthStmt) MX_EXIT_VISIT_MSAsmStmt MX_END_VISIT_STMT(MSAsmStmt) @@ -15714,17 +15718,17 @@ MX_END_VISIT_STMT(MSAsmStmt) MX_BEGIN_VISIT_STMT(GCCAsmStmt) MX_ENTER_VISIT_GCCAsmStmt MX_VISIT_BASE(GCCAsmStmt, AsmStmt) - MX_VISIT_ENTITY(GCCAsmStmt, assembly_string, 10, MX_APPLY_METHOD, AssemblyString, StringLiteral, NthStmt) - MX_VISIT_ENTITY(GCCAsmStmt, r_paren_token, 11, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_BOOL(GCCAsmStmt, is_assembly_goto, 23, MX_APPLY_METHOD, IsAssemblyGoto, bool, NthStmt) - MX_VISIT_ENTITY_LIST(GCCAsmStmt, labels, 30, MX_APPLY_METHOD, Labels, AddrLabelExpr, NthStmt) - MX_VISIT_ENTITY_LIST(GCCAsmStmt, output_constraint_literals, 53, MX_APPLY_METHOD, OutputConstraintLiterals, StringLiteral, NthStmt) - MX_VISIT_TEXT_LIST(GCCAsmStmt, output_names, 65, MX_APPLY_METHOD, OutputNames, basic_string_view, NthStmt) - MX_VISIT_ENTITY_LIST(GCCAsmStmt, input_constraint_literals, 54, MX_APPLY_METHOD, InputConstraintLiterals, StringLiteral, NthStmt) - MX_VISIT_TEXT_LIST(GCCAsmStmt, input_names, 67, MX_APPLY_METHOD, InputNames, basic_string_view, NthStmt) - MX_VISIT_ENTITY_LIST(GCCAsmStmt, clobber_string_literals, 55, MX_APPLY_METHOD, ClobberStringLiterals, StringLiteral, NthStmt) - MX_VISIT_ENTITY_LIST(GCCAsmStmt, label_expressions, 68, MX_APPLY_METHOD, LabelExpressions, AddrLabelExpr, NthStmt) - MX_VISIT_TEXT_LIST(GCCAsmStmt, label_names, 69, MX_APPLY_METHOD, LabelNames, basic_string_view, NthStmt) + MX_VISIT_ENTITY(GCCAsmStmt, assembly_string, 11, MX_APPLY_METHOD, AssemblyString, StringLiteral, NthStmt) + MX_VISIT_ENTITY(GCCAsmStmt, r_paren_token, 12, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_BOOL(GCCAsmStmt, is_assembly_goto, 24, MX_APPLY_METHOD, IsAssemblyGoto, bool, NthStmt) + MX_VISIT_ENTITY_LIST(GCCAsmStmt, labels, 31, MX_APPLY_METHOD, Labels, AddrLabelExpr, NthStmt) + MX_VISIT_ENTITY_LIST(GCCAsmStmt, output_constraint_literals, 54, MX_APPLY_METHOD, OutputConstraintLiterals, StringLiteral, NthStmt) + MX_VISIT_TEXT_LIST(GCCAsmStmt, output_names, 66, MX_APPLY_METHOD, OutputNames, basic_string_view, NthStmt) + MX_VISIT_ENTITY_LIST(GCCAsmStmt, input_constraint_literals, 55, MX_APPLY_METHOD, InputConstraintLiterals, StringLiteral, NthStmt) + MX_VISIT_TEXT_LIST(GCCAsmStmt, input_names, 68, MX_APPLY_METHOD, InputNames, basic_string_view, NthStmt) + MX_VISIT_ENTITY_LIST(GCCAsmStmt, clobber_string_literals, 56, MX_APPLY_METHOD, ClobberStringLiterals, StringLiteral, NthStmt) + MX_VISIT_ENTITY_LIST(GCCAsmStmt, label_expressions, 69, MX_APPLY_METHOD, LabelExpressions, AddrLabelExpr, NthStmt) + MX_VISIT_TEXT_LIST(GCCAsmStmt, label_names, 70, MX_APPLY_METHOD, LabelNames, basic_string_view, NthStmt) MX_EXIT_VISIT_GCCAsmStmt MX_END_VISIT_STMT(GCCAsmStmt) @@ -15738,14 +15742,14 @@ MX_END_VISIT_STMT(GCCAsmStmt) MX_BEGIN_VISIT_STMT(WhileStmt) MX_ENTER_VISIT_WhileStmt MX_VISIT_BASE(WhileStmt, Stmt) - MX_VISIT_ENTITY(WhileStmt, body, 9, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(WhileStmt, condition, 10, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(WhileStmt, condition_variable, 11, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(WhileStmt, condition_variable_declaration_statement, 13, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) - MX_VISIT_ENTITY(WhileStmt, l_paren_token, 14, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(WhileStmt, r_paren_token, 17, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(WhileStmt, while_token, 18, MX_APPLY_METHOD, WhileToken, Token, NthStmt) - MX_VISIT_BOOL(WhileStmt, has_variable_storage, 12, MX_APPLY_METHOD, HasVariableStorage, bool, NthStmt) + MX_VISIT_ENTITY(WhileStmt, body, 10, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(WhileStmt, condition, 11, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(WhileStmt, condition_variable, 12, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(WhileStmt, condition_variable_declaration_statement, 14, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) + MX_VISIT_ENTITY(WhileStmt, l_paren_token, 15, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(WhileStmt, r_paren_token, 18, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(WhileStmt, while_token, 19, MX_APPLY_METHOD, WhileToken, Token, NthStmt) + MX_VISIT_BOOL(WhileStmt, has_variable_storage, 13, MX_APPLY_METHOD, HasVariableStorage, bool, NthStmt) MX_EXIT_VISIT_WhileStmt MX_END_VISIT_STMT(WhileStmt) @@ -15759,7 +15763,7 @@ MX_END_VISIT_STMT(WhileStmt) MX_BEGIN_VISIT_ABSTRACT_STMT(ValueStmt) MX_ENTER_VISIT_ValueStmt MX_VISIT_BASE(ValueStmt, Stmt) - MX_VISIT_OPTIONAL_ENTITY(ValueStmt, expression_statement, 9, MX_APPLY_METHOD, ExpressionStatement, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(ValueStmt, expression_statement, 10, MX_APPLY_METHOD, ExpressionStatement, Expr, NthStmt) MX_EXIT_VISIT_ValueStmt MX_END_VISIT_STMT(ValueStmt) @@ -15773,11 +15777,11 @@ MX_END_VISIT_STMT(ValueStmt) MX_BEGIN_VISIT_STMT(LabelStmt) MX_ENTER_VISIT_LabelStmt MX_VISIT_BASE(LabelStmt, ValueStmt) - MX_VISIT_ENTITY(LabelStmt, declaration, 10, MX_APPLY_METHOD, Declaration, LabelDecl, NthStmt) - MX_VISIT_ENTITY(LabelStmt, identifier_token, 11, MX_APPLY_METHOD, IdentifierToken, Token, NthStmt) - MX_VISIT_TEXT(LabelStmt, name, 61, MX_APPLY_METHOD, Name, basic_string_view, NthStmt) - MX_VISIT_ENTITY(LabelStmt, sub_statement, 13, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) - MX_VISIT_BOOL(LabelStmt, is_side_entry, 12, MX_APPLY_METHOD, IsSideEntry, bool, NthStmt) + MX_VISIT_ENTITY(LabelStmt, declaration, 11, MX_APPLY_METHOD, Declaration, LabelDecl, NthStmt) + MX_VISIT_ENTITY(LabelStmt, identifier_token, 12, MX_APPLY_METHOD, IdentifierToken, Token, NthStmt) + MX_VISIT_TEXT(LabelStmt, name, 62, MX_APPLY_METHOD, Name, basic_string_view, NthStmt) + MX_VISIT_ENTITY(LabelStmt, sub_statement, 14, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) + MX_VISIT_BOOL(LabelStmt, is_side_entry, 13, MX_APPLY_METHOD, IsSideEntry, bool, NthStmt) MX_EXIT_VISIT_LabelStmt MX_END_VISIT_STMT(LabelStmt) @@ -15791,45 +15795,45 @@ MX_END_VISIT_STMT(LabelStmt) MX_BEGIN_VISIT_ABSTRACT_STMT(Expr) MX_ENTER_VISIT_Expr MX_VISIT_BASE(Expr, ValueStmt) - MX_VISIT_ENTITY(Expr, ignore_casts, 10, MX_APPLY_METHOD, IgnoreCasts, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_conversion_operator_single_step, 11, MX_APPLY_METHOD, IgnoreConversionOperatorSingleStep, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_implicit_casts, 13, MX_APPLY_METHOD, IgnoreImplicitCasts, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_implicit, 14, MX_APPLY_METHOD, IgnoreImplicit, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_implicit_as_written, 17, MX_APPLY_METHOD, IgnoreImplicitAsWritten, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_parenthesis_base_casts, 18, MX_APPLY_METHOD, IgnoreParenthesisBaseCasts, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_parenthesis_casts, 19, MX_APPLY_METHOD, IgnoreParenthesisCasts, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_parenthesis_implicit_casts, 20, MX_APPLY_METHOD, IgnoreParenthesisImplicitCasts, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_parenthesis_l_value_casts, 21, MX_APPLY_METHOD, IgnoreParenthesisLValueCasts, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(Expr, ignore_parenthesis_noop_casts, 22, MX_APPLY_METHOD, IgnoreParenthesisNoopCasts, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_parentheses, 31, MX_APPLY_METHOD, IgnoreParentheses, Expr, NthStmt) - MX_VISIT_ENTITY(Expr, ignore_unless_spelled_in_source, 32, MX_APPLY_METHOD, IgnoreUnlessSpelledInSource, Expr, NthStmt) - MX_VISIT_BOOL(Expr, contains_errors, 12, MX_APPLY_METHOD, ContainsErrors, bool, NthStmt) - MX_VISIT_BOOL(Expr, contains_unexpanded_parameter_pack, 16, MX_APPLY_METHOD, ContainsUnexpandedParameterPack, bool, NthStmt) - MX_VISIT_ENTITY(Expr, expression_token, 33, MX_APPLY_METHOD, ExpressionToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(Expr, obj_c_property, 34, MX_APPLY_METHOD, ObjCProperty, ObjCPropertyRefExpr, NthStmt) - MX_VISIT_ENUM(Expr, object_kind, 57, MX_APPLY_METHOD, ObjectKind, ExprObjectKind, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(Expr, referenced_declaration_of_callee, 35, MX_APPLY_METHOD, ReferencedDeclarationOfCallee, Decl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(Expr, source_bit_field, 36, MX_APPLY_METHOD, SourceBitField, FieldDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(Expr, type, 37, MX_APPLY_METHOD, Type, Type, NthStmt) - MX_VISIT_ENUM(Expr, value_kind, 70, MX_APPLY_METHOD, ValueKind, ExprValueKind, NthStmt) - MX_VISIT_BOOL(Expr, has_non_trivial_call, 23, MX_APPLY_METHOD, HasNonTrivialCall, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_default_argument, 24, MX_APPLY_METHOD, IsDefaultArgument, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_gl_value, 25, MX_APPLY_METHOD, IsGLValue, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_implicit_cxx_this, 58, MX_APPLY_METHOD, IsImplicitCXXThis, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_instantiation_dependent, 59, MX_APPLY_METHOD, IsInstantiationDependent, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_l_value, 60, MX_APPLY_METHOD, IsLValue, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_objcgc_candidate, 71, MX_APPLY_METHOD, IsOBJCGCCandidate, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_obj_c_self_expression, 72, MX_APPLY_METHOD, IsObjCSelfExpression, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_ordinary_or_bit_field_object, 73, MX_APPLY_METHOD, IsOrdinaryOrBitFieldObject, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_pr_value, 74, MX_APPLY_METHOD, IsPRValue, bool, NthStmt) - MX_VISIT_OPTIONAL_BOOL(Expr, is_read_if_discarded_in_c_plus_plus11, 75, MX_APPLY_METHOD, IsReadIfDiscardedInCPlusPlus11, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_type_dependent, 77, MX_APPLY_METHOD, IsTypeDependent, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_value_dependent, 78, MX_APPLY_METHOD, IsValueDependent, bool, NthStmt) - MX_VISIT_BOOL(Expr, is_x_value, 79, MX_APPLY_METHOD, IsXValue, bool, NthStmt) - MX_VISIT_BOOL(Expr, refers_to_bit_field, 80, MX_APPLY_METHOD, RefersToBitField, bool, NthStmt) - MX_VISIT_BOOL(Expr, refers_to_global_register_variable, 81, MX_APPLY_METHOD, RefersToGlobalRegisterVariable, bool, NthStmt) - MX_VISIT_BOOL(Expr, refers_to_matrix_element, 82, MX_APPLY_METHOD, RefersToMatrixElement, bool, NthStmt) - MX_VISIT_BOOL(Expr, refers_to_vector_element, 83, MX_APPLY_METHOD, RefersToVectorElement, bool, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_casts, 11, MX_APPLY_METHOD, IgnoreCasts, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_conversion_operator_single_step, 12, MX_APPLY_METHOD, IgnoreConversionOperatorSingleStep, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_implicit_casts, 14, MX_APPLY_METHOD, IgnoreImplicitCasts, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_implicit, 15, MX_APPLY_METHOD, IgnoreImplicit, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_implicit_as_written, 18, MX_APPLY_METHOD, IgnoreImplicitAsWritten, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_parenthesis_base_casts, 19, MX_APPLY_METHOD, IgnoreParenthesisBaseCasts, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_parenthesis_casts, 20, MX_APPLY_METHOD, IgnoreParenthesisCasts, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_parenthesis_implicit_casts, 21, MX_APPLY_METHOD, IgnoreParenthesisImplicitCasts, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_parenthesis_l_value_casts, 22, MX_APPLY_METHOD, IgnoreParenthesisLValueCasts, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(Expr, ignore_parenthesis_noop_casts, 23, MX_APPLY_METHOD, IgnoreParenthesisNoopCasts, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_parentheses, 32, MX_APPLY_METHOD, IgnoreParentheses, Expr, NthStmt) + MX_VISIT_ENTITY(Expr, ignore_unless_spelled_in_source, 33, MX_APPLY_METHOD, IgnoreUnlessSpelledInSource, Expr, NthStmt) + MX_VISIT_BOOL(Expr, contains_errors, 13, MX_APPLY_METHOD, ContainsErrors, bool, NthStmt) + MX_VISIT_BOOL(Expr, contains_unexpanded_parameter_pack, 17, MX_APPLY_METHOD, ContainsUnexpandedParameterPack, bool, NthStmt) + MX_VISIT_ENTITY(Expr, expression_token, 34, MX_APPLY_METHOD, ExpressionToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(Expr, obj_c_property, 35, MX_APPLY_METHOD, ObjCProperty, ObjCPropertyRefExpr, NthStmt) + MX_VISIT_ENUM(Expr, object_kind, 58, MX_APPLY_METHOD, ObjectKind, ExprObjectKind, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(Expr, referenced_declaration_of_callee, 36, MX_APPLY_METHOD, ReferencedDeclarationOfCallee, Decl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(Expr, source_bit_field, 37, MX_APPLY_METHOD, SourceBitField, FieldDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(Expr, type, 38, MX_APPLY_METHOD, Type, Type, NthStmt) + MX_VISIT_ENUM(Expr, value_kind, 71, MX_APPLY_METHOD, ValueKind, ExprValueKind, NthStmt) + MX_VISIT_BOOL(Expr, has_non_trivial_call, 24, MX_APPLY_METHOD, HasNonTrivialCall, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_default_argument, 25, MX_APPLY_METHOD, IsDefaultArgument, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_gl_value, 26, MX_APPLY_METHOD, IsGLValue, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_implicit_cxx_this, 59, MX_APPLY_METHOD, IsImplicitCXXThis, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_instantiation_dependent, 60, MX_APPLY_METHOD, IsInstantiationDependent, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_l_value, 61, MX_APPLY_METHOD, IsLValue, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_objcgc_candidate, 72, MX_APPLY_METHOD, IsOBJCGCCandidate, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_obj_c_self_expression, 73, MX_APPLY_METHOD, IsObjCSelfExpression, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_ordinary_or_bit_field_object, 74, MX_APPLY_METHOD, IsOrdinaryOrBitFieldObject, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_pr_value, 75, MX_APPLY_METHOD, IsPRValue, bool, NthStmt) + MX_VISIT_OPTIONAL_BOOL(Expr, is_read_if_discarded_in_c_plus_plus11, 76, MX_APPLY_METHOD, IsReadIfDiscardedInCPlusPlus11, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_type_dependent, 78, MX_APPLY_METHOD, IsTypeDependent, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_value_dependent, 79, MX_APPLY_METHOD, IsValueDependent, bool, NthStmt) + MX_VISIT_BOOL(Expr, is_x_value, 80, MX_APPLY_METHOD, IsXValue, bool, NthStmt) + MX_VISIT_BOOL(Expr, refers_to_bit_field, 81, MX_APPLY_METHOD, RefersToBitField, bool, NthStmt) + MX_VISIT_BOOL(Expr, refers_to_global_register_variable, 82, MX_APPLY_METHOD, RefersToGlobalRegisterVariable, bool, NthStmt) + MX_VISIT_BOOL(Expr, refers_to_matrix_element, 83, MX_APPLY_METHOD, RefersToMatrixElement, bool, NthStmt) + MX_VISIT_BOOL(Expr, refers_to_vector_element, 84, MX_APPLY_METHOD, RefersToVectorElement, bool, NthStmt) MX_EXIT_VISIT_Expr MX_END_VISIT_STMT(Expr) @@ -15843,8 +15847,8 @@ MX_END_VISIT_STMT(Expr) MX_BEGIN_VISIT_STMT(DesignatedInitUpdateExpr) MX_ENTER_VISIT_DesignatedInitUpdateExpr MX_VISIT_BASE(DesignatedInitUpdateExpr, Expr) - MX_VISIT_ENTITY(DesignatedInitUpdateExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(DesignatedInitUpdateExpr, updater, 39, MX_APPLY_METHOD, Updater, InitListExpr, NthStmt) + MX_VISIT_ENTITY(DesignatedInitUpdateExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(DesignatedInitUpdateExpr, updater, 40, MX_APPLY_METHOD, Updater, InitListExpr, NthStmt) MX_EXIT_VISIT_DesignatedInitUpdateExpr MX_END_VISIT_STMT(DesignatedInitUpdateExpr) @@ -15858,14 +15862,14 @@ MX_END_VISIT_STMT(DesignatedInitUpdateExpr) MX_BEGIN_VISIT_STMT(DesignatedInitExpr) MX_ENTER_VISIT_DesignatedInitExpr MX_VISIT_BASE(DesignatedInitExpr, Expr) - MX_VISIT_ENTITY_LIST(DesignatedInitExpr, designators, 15, MX_APPLY_METHOD, Designators, Designator, NthStmt) - MX_VISIT_TOKEN_RANGE(DesignatedInitExpr, designators_tokens, 38, 39, NthStmt) - MX_VISIT_ENTITY(DesignatedInitExpr, equal_or_colon_token, 40, MX_APPLY_METHOD, EqualOrColonToken, Token, NthStmt) - MX_VISIT_ENTITY(DesignatedInitExpr, initializer, 41, MX_APPLY_METHOD, Initializer, Expr, NthStmt) - MX_VISIT_BOOL(DesignatedInitExpr, is_direct_initializer, 84, MX_APPLY_METHOD, IsDirectInitializer, bool, NthStmt) - MX_VISIT_INT(DesignatedInitExpr, size, 26, MX_APPLY_METHOD, Size, uint32_t, NthStmt) - MX_VISIT_BOOL(DesignatedInitExpr, uses_gnu_syntax, 85, MX_APPLY_METHOD, UsesGNUSyntax, bool, NthStmt) - MX_VISIT_ENTITY_LIST(DesignatedInitExpr, sub_expressions, 27, MX_APPLY_METHOD, SubExpressions, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(DesignatedInitExpr, designators, 16, MX_APPLY_METHOD, Designators, Designator, NthStmt) + MX_VISIT_TOKEN_RANGE(DesignatedInitExpr, designators_tokens, 39, 40, NthStmt) + MX_VISIT_ENTITY(DesignatedInitExpr, equal_or_colon_token, 41, MX_APPLY_METHOD, EqualOrColonToken, Token, NthStmt) + MX_VISIT_ENTITY(DesignatedInitExpr, initializer, 42, MX_APPLY_METHOD, Initializer, Expr, NthStmt) + MX_VISIT_BOOL(DesignatedInitExpr, is_direct_initializer, 85, MX_APPLY_METHOD, IsDirectInitializer, bool, NthStmt) + MX_VISIT_INT(DesignatedInitExpr, size, 27, MX_APPLY_METHOD, Size, uint32_t, NthStmt) + MX_VISIT_BOOL(DesignatedInitExpr, uses_gnu_syntax, 86, MX_APPLY_METHOD, UsesGNUSyntax, bool, NthStmt) + MX_VISIT_ENTITY_LIST(DesignatedInitExpr, sub_expressions, 28, MX_APPLY_METHOD, SubExpressions, Expr, NthStmt) MX_EXIT_VISIT_DesignatedInitExpr MX_END_VISIT_STMT(DesignatedInitExpr) @@ -15879,11 +15883,11 @@ MX_END_VISIT_STMT(DesignatedInitExpr) MX_BEGIN_VISIT_STMT(DependentScopeDeclRefExpr) MX_ENTER_VISIT_DependentScopeDeclRefExpr MX_VISIT_BASE(DependentScopeDeclRefExpr, Expr) - MX_VISIT_ENTITY(DependentScopeDeclRefExpr, l_angle_token, 38, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(DependentScopeDeclRefExpr, r_angle_token, 39, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(DependentScopeDeclRefExpr, template_keyword_token, 40, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) - MX_VISIT_BOOL(DependentScopeDeclRefExpr, has_explicit_template_arguments, 84, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) - MX_VISIT_BOOL(DependentScopeDeclRefExpr, has_template_keyword, 85, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) + MX_VISIT_ENTITY(DependentScopeDeclRefExpr, l_angle_token, 39, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(DependentScopeDeclRefExpr, r_angle_token, 40, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(DependentScopeDeclRefExpr, template_keyword_token, 41, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) + MX_VISIT_BOOL(DependentScopeDeclRefExpr, has_explicit_template_arguments, 85, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) + MX_VISIT_BOOL(DependentScopeDeclRefExpr, has_template_keyword, 86, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) MX_EXIT_VISIT_DependentScopeDeclRefExpr MX_END_VISIT_STMT(DependentScopeDeclRefExpr) @@ -15897,9 +15901,9 @@ MX_END_VISIT_STMT(DependentScopeDeclRefExpr) MX_BEGIN_VISIT_STMT(DependentCoawaitExpr) MX_ENTER_VISIT_DependentCoawaitExpr MX_VISIT_BASE(DependentCoawaitExpr, Expr) - MX_VISIT_ENTITY(DependentCoawaitExpr, keyword_token, 38, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) - MX_VISIT_ENTITY(DependentCoawaitExpr, operand, 39, MX_APPLY_METHOD, Operand, Expr, NthStmt) - MX_VISIT_ENTITY(DependentCoawaitExpr, operator_coawait_lookup, 40, MX_APPLY_METHOD, OperatorCoawaitLookup, UnresolvedLookupExpr, NthStmt) + MX_VISIT_ENTITY(DependentCoawaitExpr, keyword_token, 39, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) + MX_VISIT_ENTITY(DependentCoawaitExpr, operand, 40, MX_APPLY_METHOD, Operand, Expr, NthStmt) + MX_VISIT_ENTITY(DependentCoawaitExpr, operator_coawait_lookup, 41, MX_APPLY_METHOD, OperatorCoawaitLookup, UnresolvedLookupExpr, NthStmt) MX_EXIT_VISIT_DependentCoawaitExpr MX_END_VISIT_STMT(DependentCoawaitExpr) @@ -15913,17 +15917,17 @@ MX_END_VISIT_STMT(DependentCoawaitExpr) MX_BEGIN_VISIT_STMT(DeclRefExpr) MX_ENTER_VISIT_DeclRefExpr MX_VISIT_BASE(DeclRefExpr, Expr) - MX_VISIT_ENTITY(DeclRefExpr, declaration, 38, MX_APPLY_METHOD, Declaration, ValueDecl, NthStmt) - MX_VISIT_ENTITY(DeclRefExpr, l_angle_token, 39, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(DeclRefExpr, r_angle_token, 40, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(DeclRefExpr, template_keyword_token, 41, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) - MX_VISIT_BOOL(DeclRefExpr, had_multiple_candidates, 84, MX_APPLY_METHOD, HadMultipleCandidates, bool, NthStmt) - MX_VISIT_BOOL(DeclRefExpr, has_explicit_template_arguments, 85, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) - MX_VISIT_BOOL(DeclRefExpr, has_qualifier, 86, MX_APPLY_METHOD, HasQualifier, bool, NthStmt) - MX_VISIT_BOOL(DeclRefExpr, is_captured_by_copy_in_lambda_with_explicit_object_parameter, 87, MX_APPLY_METHOD, IsCapturedByCopyInLambdaWithExplicitObjectParameter, bool, NthStmt) - MX_VISIT_BOOL(DeclRefExpr, is_immediate_escalating, 88, MX_APPLY_METHOD, IsImmediateEscalating, bool, NthStmt) - MX_VISIT_ENUM(DeclRefExpr, is_non_odr_use, 89, MX_APPLY_METHOD, IsNonOdrUse, NonOdrUseReason, NthStmt) - MX_VISIT_BOOL(DeclRefExpr, refers_to_enclosing_variable_or_capture, 90, MX_APPLY_METHOD, RefersToEnclosingVariableOrCapture, bool, NthStmt) + MX_VISIT_ENTITY(DeclRefExpr, declaration, 39, MX_APPLY_METHOD, Declaration, ValueDecl, NthStmt) + MX_VISIT_ENTITY(DeclRefExpr, l_angle_token, 40, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(DeclRefExpr, r_angle_token, 41, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(DeclRefExpr, template_keyword_token, 42, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) + MX_VISIT_BOOL(DeclRefExpr, had_multiple_candidates, 85, MX_APPLY_METHOD, HadMultipleCandidates, bool, NthStmt) + MX_VISIT_BOOL(DeclRefExpr, has_explicit_template_arguments, 86, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) + MX_VISIT_BOOL(DeclRefExpr, has_qualifier, 87, MX_APPLY_METHOD, HasQualifier, bool, NthStmt) + MX_VISIT_BOOL(DeclRefExpr, is_captured_by_copy_in_lambda_with_explicit_object_parameter, 88, MX_APPLY_METHOD, IsCapturedByCopyInLambdaWithExplicitObjectParameter, bool, NthStmt) + MX_VISIT_BOOL(DeclRefExpr, is_immediate_escalating, 89, MX_APPLY_METHOD, IsImmediateEscalating, bool, NthStmt) + MX_VISIT_ENUM(DeclRefExpr, is_non_odr_use, 90, MX_APPLY_METHOD, IsNonOdrUse, NonOdrUseReason, NthStmt) + MX_VISIT_BOOL(DeclRefExpr, refers_to_enclosing_variable_or_capture, 91, MX_APPLY_METHOD, RefersToEnclosingVariableOrCapture, bool, NthStmt) MX_EXIT_VISIT_DeclRefExpr MX_END_VISIT_STMT(DeclRefExpr) @@ -15937,13 +15941,13 @@ MX_END_VISIT_STMT(DeclRefExpr) MX_BEGIN_VISIT_ABSTRACT_STMT(CoroutineSuspendExpr) MX_ENTER_VISIT_CoroutineSuspendExpr MX_VISIT_BASE(CoroutineSuspendExpr, Expr) - MX_VISIT_ENTITY(CoroutineSuspendExpr, common_expression, 38, MX_APPLY_METHOD, CommonExpression, Expr, NthStmt) - MX_VISIT_ENTITY(CoroutineSuspendExpr, keyword_token, 39, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) - MX_VISIT_ENTITY(CoroutineSuspendExpr, opaque_value, 40, MX_APPLY_METHOD, OpaqueValue, OpaqueValueExpr, NthStmt) - MX_VISIT_ENTITY(CoroutineSuspendExpr, operand, 41, MX_APPLY_METHOD, Operand, Expr, NthStmt) - MX_VISIT_ENTITY(CoroutineSuspendExpr, ready_expression, 42, MX_APPLY_METHOD, ReadyExpression, Expr, NthStmt) - MX_VISIT_ENTITY(CoroutineSuspendExpr, resume_expression, 43, MX_APPLY_METHOD, ResumeExpression, Expr, NthStmt) - MX_VISIT_ENTITY(CoroutineSuspendExpr, suspend_expression, 44, MX_APPLY_METHOD, SuspendExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineSuspendExpr, common_expression, 39, MX_APPLY_METHOD, CommonExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineSuspendExpr, keyword_token, 40, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) + MX_VISIT_ENTITY(CoroutineSuspendExpr, opaque_value, 41, MX_APPLY_METHOD, OpaqueValue, OpaqueValueExpr, NthStmt) + MX_VISIT_ENTITY(CoroutineSuspendExpr, operand, 42, MX_APPLY_METHOD, Operand, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineSuspendExpr, ready_expression, 43, MX_APPLY_METHOD, ReadyExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineSuspendExpr, resume_expression, 44, MX_APPLY_METHOD, ResumeExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CoroutineSuspendExpr, suspend_expression, 45, MX_APPLY_METHOD, SuspendExpression, Expr, NthStmt) MX_EXIT_VISIT_CoroutineSuspendExpr MX_END_VISIT_STMT(CoroutineSuspendExpr) @@ -15957,7 +15961,7 @@ MX_END_VISIT_STMT(CoroutineSuspendExpr) MX_BEGIN_VISIT_STMT(CoawaitExpr) MX_ENTER_VISIT_CoawaitExpr MX_VISIT_BASE(CoawaitExpr, CoroutineSuspendExpr) - MX_VISIT_BOOL(CoawaitExpr, is_implicit, 84, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) + MX_VISIT_BOOL(CoawaitExpr, is_implicit, 85, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) MX_EXIT_VISIT_CoawaitExpr MX_END_VISIT_STMT(CoawaitExpr) @@ -15984,9 +15988,9 @@ MX_END_VISIT_STMT(CoyieldExpr) MX_BEGIN_VISIT_STMT(ConvertVectorExpr) MX_ENTER_VISIT_ConvertVectorExpr MX_VISIT_BASE(ConvertVectorExpr, Expr) - MX_VISIT_ENTITY(ConvertVectorExpr, builtin_token, 38, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) - MX_VISIT_ENTITY(ConvertVectorExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(ConvertVectorExpr, src_expression, 40, MX_APPLY_METHOD, SrcExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ConvertVectorExpr, builtin_token, 39, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) + MX_VISIT_ENTITY(ConvertVectorExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ConvertVectorExpr, src_expression, 41, MX_APPLY_METHOD, SrcExpression, Expr, NthStmt) MX_EXIT_VISIT_ConvertVectorExpr MX_END_VISIT_STMT(ConvertVectorExpr) @@ -16000,13 +16004,13 @@ MX_END_VISIT_STMT(ConvertVectorExpr) MX_BEGIN_VISIT_STMT(ConceptSpecializationExpr) MX_ENTER_VISIT_ConceptSpecializationExpr MX_VISIT_BASE(ConceptSpecializationExpr, Expr) - MX_VISIT_ENTITY(ConceptSpecializationExpr, concept_name_token, 38, MX_APPLY_METHOD, ConceptNameToken, Token, NthStmt) - MX_VISIT_ENTITY(ConceptSpecializationExpr, found_declaration, 39, MX_APPLY_METHOD, FoundDeclaration, NamedDecl, NthStmt) - MX_VISIT_ENTITY(ConceptSpecializationExpr, named_concept, 40, MX_APPLY_METHOD, NamedConcept, ConceptDecl, NthStmt) - MX_VISIT_ENTITY(ConceptSpecializationExpr, specialization_declaration, 41, MX_APPLY_METHOD, SpecializationDeclaration, ImplicitConceptSpecializationDecl, NthStmt) - MX_VISIT_ENTITY_LIST(ConceptSpecializationExpr, template_arguments, 15, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthStmt) - MX_VISIT_ENTITY(ConceptSpecializationExpr, template_keyword_token, 42, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) - MX_VISIT_BOOL(ConceptSpecializationExpr, has_explicit_template_arguments, 84, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) + MX_VISIT_ENTITY(ConceptSpecializationExpr, concept_name_token, 39, MX_APPLY_METHOD, ConceptNameToken, Token, NthStmt) + MX_VISIT_ENTITY(ConceptSpecializationExpr, found_declaration, 40, MX_APPLY_METHOD, FoundDeclaration, NamedDecl, NthStmt) + MX_VISIT_ENTITY(ConceptSpecializationExpr, named_concept, 41, MX_APPLY_METHOD, NamedConcept, ConceptDecl, NthStmt) + MX_VISIT_ENTITY(ConceptSpecializationExpr, specialization_declaration, 42, MX_APPLY_METHOD, SpecializationDeclaration, ImplicitConceptSpecializationDecl, NthStmt) + MX_VISIT_ENTITY_LIST(ConceptSpecializationExpr, template_arguments, 16, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthStmt) + MX_VISIT_ENTITY(ConceptSpecializationExpr, template_keyword_token, 43, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) + MX_VISIT_BOOL(ConceptSpecializationExpr, has_explicit_template_arguments, 85, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) MX_EXIT_VISIT_ConceptSpecializationExpr MX_END_VISIT_STMT(ConceptSpecializationExpr) @@ -16020,9 +16024,9 @@ MX_END_VISIT_STMT(ConceptSpecializationExpr) MX_BEGIN_VISIT_STMT(CompoundLiteralExpr) MX_ENTER_VISIT_CompoundLiteralExpr MX_VISIT_BASE(CompoundLiteralExpr, Expr) - MX_VISIT_ENTITY(CompoundLiteralExpr, initializer, 38, MX_APPLY_METHOD, Initializer, Expr, NthStmt) - MX_VISIT_ENTITY(CompoundLiteralExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_BOOL(CompoundLiteralExpr, is_file_scope, 84, MX_APPLY_METHOD, IsFileScope, bool, NthStmt) + MX_VISIT_ENTITY(CompoundLiteralExpr, initializer, 39, MX_APPLY_METHOD, Initializer, Expr, NthStmt) + MX_VISIT_ENTITY(CompoundLiteralExpr, l_paren_token, 40, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_BOOL(CompoundLiteralExpr, is_file_scope, 85, MX_APPLY_METHOD, IsFileScope, bool, NthStmt) MX_EXIT_VISIT_CompoundLiteralExpr MX_END_VISIT_STMT(CompoundLiteralExpr) @@ -16036,14 +16040,14 @@ MX_END_VISIT_STMT(CompoundLiteralExpr) MX_BEGIN_VISIT_STMT(ChooseExpr) MX_ENTER_VISIT_ChooseExpr MX_VISIT_BASE(ChooseExpr, Expr) - MX_VISIT_ENTITY(ChooseExpr, builtin_token, 38, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) - MX_VISIT_ENTITY(ChooseExpr, chosen_sub_expression, 39, MX_APPLY_METHOD, ChosenSubExpression, Expr, NthStmt) - MX_VISIT_ENTITY(ChooseExpr, condition, 40, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_ENTITY(ChooseExpr, lhs, 41, MX_APPLY_METHOD, LHS, Expr, NthStmt) - MX_VISIT_ENTITY(ChooseExpr, rhs, 42, MX_APPLY_METHOD, RHS, Expr, NthStmt) - MX_VISIT_ENTITY(ChooseExpr, r_paren_token, 43, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_BOOL(ChooseExpr, is_condition_dependent, 84, MX_APPLY_METHOD, IsConditionDependent, bool, NthStmt) - MX_VISIT_BOOL(ChooseExpr, is_condition_true, 85, MX_APPLY_METHOD, IsConditionTrue, bool, NthStmt) + MX_VISIT_ENTITY(ChooseExpr, builtin_token, 39, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) + MX_VISIT_ENTITY(ChooseExpr, chosen_sub_expression, 40, MX_APPLY_METHOD, ChosenSubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ChooseExpr, condition, 41, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_ENTITY(ChooseExpr, lhs, 42, MX_APPLY_METHOD, LHS, Expr, NthStmt) + MX_VISIT_ENTITY(ChooseExpr, rhs, 43, MX_APPLY_METHOD, RHS, Expr, NthStmt) + MX_VISIT_ENTITY(ChooseExpr, r_paren_token, 44, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_BOOL(ChooseExpr, is_condition_dependent, 85, MX_APPLY_METHOD, IsConditionDependent, bool, NthStmt) + MX_VISIT_BOOL(ChooseExpr, is_condition_true, 86, MX_APPLY_METHOD, IsConditionTrue, bool, NthStmt) MX_EXIT_VISIT_ChooseExpr MX_END_VISIT_STMT(ChooseExpr) @@ -16057,9 +16061,9 @@ MX_END_VISIT_STMT(ChooseExpr) MX_BEGIN_VISIT_STMT(CharacterLiteral) MX_ENTER_VISIT_CharacterLiteral MX_VISIT_BASE(CharacterLiteral, Expr) - MX_VISIT_ENUM(CharacterLiteral, literal_kind, 89, MX_APPLY_METHOD, LiteralKind, CharacterLiteralKind, NthStmt) - MX_VISIT_ENTITY(CharacterLiteral, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_INT(CharacterLiteral, value, 26, MX_APPLY_METHOD, Value, uint32_t, NthStmt) + MX_VISIT_ENUM(CharacterLiteral, literal_kind, 90, MX_APPLY_METHOD, LiteralKind, CharacterLiteralKind, NthStmt) + MX_VISIT_ENTITY(CharacterLiteral, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_INT(CharacterLiteral, value, 27, MX_APPLY_METHOD, Value, uint32_t, NthStmt) MX_EXIT_VISIT_CharacterLiteral MX_END_VISIT_STMT(CharacterLiteral) @@ -16073,14 +16077,14 @@ MX_END_VISIT_STMT(CharacterLiteral) MX_BEGIN_VISIT_ABSTRACT_STMT(CastExpr) MX_ENTER_VISIT_CastExpr MX_VISIT_BASE(CastExpr, Expr) - MX_VISIT_BOOL(CastExpr, changes_volatile_qualification, 84, MX_APPLY_METHOD, ChangesVolatileQualification, bool, NthStmt) - MX_VISIT_ENUM(CastExpr, cast_kind, 89, MX_APPLY_METHOD, CastKind, CastKind, NthStmt) - MX_VISIT_TEXT(CastExpr, cast_kind_name, 61, MX_APPLY_METHOD, CastKindName, basic_string_view, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CastExpr, conversion_function, 38, MX_APPLY_METHOD, ConversionFunction, NamedDecl, NthStmt) - MX_VISIT_ENTITY(CastExpr, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) - MX_VISIT_ENTITY(CastExpr, sub_expression_as_written, 40, MX_APPLY_METHOD, SubExpressionAsWritten, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CastExpr, target_union_field, 41, MX_APPLY_METHOD, TargetUnionField, FieldDecl, NthStmt) - MX_VISIT_BOOL(CastExpr, has_stored_fp_features, 85, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) + MX_VISIT_BOOL(CastExpr, changes_volatile_qualification, 85, MX_APPLY_METHOD, ChangesVolatileQualification, bool, NthStmt) + MX_VISIT_ENUM(CastExpr, cast_kind, 90, MX_APPLY_METHOD, CastKind, CastKind, NthStmt) + MX_VISIT_TEXT(CastExpr, cast_kind_name, 62, MX_APPLY_METHOD, CastKindName, basic_string_view, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CastExpr, conversion_function, 39, MX_APPLY_METHOD, ConversionFunction, NamedDecl, NthStmt) + MX_VISIT_ENTITY(CastExpr, sub_expression, 40, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CastExpr, sub_expression_as_written, 41, MX_APPLY_METHOD, SubExpressionAsWritten, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CastExpr, target_union_field, 42, MX_APPLY_METHOD, TargetUnionField, FieldDecl, NthStmt) + MX_VISIT_BOOL(CastExpr, has_stored_fp_features, 86, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) MX_EXIT_VISIT_CastExpr MX_END_VISIT_STMT(CastExpr) @@ -16094,7 +16098,7 @@ MX_END_VISIT_STMT(CastExpr) MX_BEGIN_VISIT_STMT(ImplicitCastExpr) MX_ENTER_VISIT_ImplicitCastExpr MX_VISIT_BASE(ImplicitCastExpr, CastExpr) - MX_VISIT_BOOL(ImplicitCastExpr, is_part_of_explicit_cast, 86, MX_APPLY_METHOD, IsPartOfExplicitCast, bool, NthStmt) + MX_VISIT_BOOL(ImplicitCastExpr, is_part_of_explicit_cast, 87, MX_APPLY_METHOD, IsPartOfExplicitCast, bool, NthStmt) MX_EXIT_VISIT_ImplicitCastExpr MX_END_VISIT_STMT(ImplicitCastExpr) @@ -16108,7 +16112,7 @@ MX_END_VISIT_STMT(ImplicitCastExpr) MX_BEGIN_VISIT_ABSTRACT_STMT(ExplicitCastExpr) MX_ENTER_VISIT_ExplicitCastExpr MX_VISIT_BASE(ExplicitCastExpr, CastExpr) - MX_VISIT_ENTITY(ExplicitCastExpr, type_as_written, 42, MX_APPLY_METHOD, TypeAsWritten, Type, NthStmt) + MX_VISIT_ENTITY(ExplicitCastExpr, type_as_written, 43, MX_APPLY_METHOD, TypeAsWritten, Type, NthStmt) MX_EXIT_VISIT_ExplicitCastExpr MX_END_VISIT_STMT(ExplicitCastExpr) @@ -16122,10 +16126,10 @@ MX_END_VISIT_STMT(ExplicitCastExpr) MX_BEGIN_VISIT_ABSTRACT_STMT(CXXNamedCastExpr) MX_ENTER_VISIT_CXXNamedCastExpr MX_VISIT_BASE(CXXNamedCastExpr, ExplicitCastExpr) - MX_VISIT_TOKEN_RANGE(CXXNamedCastExpr, angle_brackets, 43, 44, NthStmt) - MX_VISIT_TEXT(CXXNamedCastExpr, cast_name, 66, MX_APPLY_METHOD, CastName, basic_string_view, NthStmt) - MX_VISIT_ENTITY(CXXNamedCastExpr, operator_token, 45, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXNamedCastExpr, r_paren_token, 46, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_TOKEN_RANGE(CXXNamedCastExpr, angle_brackets, 44, 45, NthStmt) + MX_VISIT_TEXT(CXXNamedCastExpr, cast_name, 67, MX_APPLY_METHOD, CastName, basic_string_view, NthStmt) + MX_VISIT_ENTITY(CXXNamedCastExpr, operator_token, 46, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXNamedCastExpr, r_paren_token, 47, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_CXXNamedCastExpr MX_END_VISIT_STMT(CXXNamedCastExpr) @@ -16139,7 +16143,7 @@ MX_END_VISIT_STMT(CXXNamedCastExpr) MX_BEGIN_VISIT_STMT(CXXDynamicCastExpr) MX_ENTER_VISIT_CXXDynamicCastExpr MX_VISIT_BASE(CXXDynamicCastExpr, CXXNamedCastExpr) - MX_VISIT_BOOL(CXXDynamicCastExpr, is_always_null, 86, MX_APPLY_METHOD, IsAlwaysNull, bool, NthStmt) + MX_VISIT_BOOL(CXXDynamicCastExpr, is_always_null, 87, MX_APPLY_METHOD, IsAlwaysNull, bool, NthStmt) MX_EXIT_VISIT_CXXDynamicCastExpr MX_END_VISIT_STMT(CXXDynamicCastExpr) @@ -16205,9 +16209,9 @@ MX_END_VISIT_STMT(CXXReinterpretCastExpr) MX_BEGIN_VISIT_STMT(CXXFunctionalCastExpr) MX_ENTER_VISIT_CXXFunctionalCastExpr MX_VISIT_BASE(CXXFunctionalCastExpr, ExplicitCastExpr) - MX_VISIT_ENTITY(CXXFunctionalCastExpr, l_paren_token, 43, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXFunctionalCastExpr, r_paren_token, 44, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_BOOL(CXXFunctionalCastExpr, is_list_initialization, 86, MX_APPLY_METHOD, IsListInitialization, bool, NthStmt) + MX_VISIT_ENTITY(CXXFunctionalCastExpr, l_paren_token, 44, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXFunctionalCastExpr, r_paren_token, 45, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_BOOL(CXXFunctionalCastExpr, is_list_initialization, 87, MX_APPLY_METHOD, IsListInitialization, bool, NthStmt) MX_EXIT_VISIT_CXXFunctionalCastExpr MX_END_VISIT_STMT(CXXFunctionalCastExpr) @@ -16221,8 +16225,8 @@ MX_END_VISIT_STMT(CXXFunctionalCastExpr) MX_BEGIN_VISIT_STMT(CStyleCastExpr) MX_ENTER_VISIT_CStyleCastExpr MX_VISIT_BASE(CStyleCastExpr, ExplicitCastExpr) - MX_VISIT_ENTITY(CStyleCastExpr, l_paren_token, 43, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(CStyleCastExpr, r_paren_token, 44, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(CStyleCastExpr, l_paren_token, 44, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(CStyleCastExpr, r_paren_token, 45, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_CStyleCastExpr MX_END_VISIT_STMT(CStyleCastExpr) @@ -16249,10 +16253,10 @@ MX_END_VISIT_STMT(BuiltinBitCastExpr) MX_BEGIN_VISIT_STMT(ObjCBridgedCastExpr) MX_ENTER_VISIT_ObjCBridgedCastExpr MX_VISIT_BASE(ObjCBridgedCastExpr, ExplicitCastExpr) - MX_VISIT_ENTITY(ObjCBridgedCastExpr, bridge_keyword_token, 43, MX_APPLY_METHOD, BridgeKeywordToken, Token, NthStmt) - MX_VISIT_ENUM(ObjCBridgedCastExpr, bridge_kind, 91, MX_APPLY_METHOD, BridgeKind, ObjCBridgeCastKind, NthStmt) - MX_VISIT_TEXT(ObjCBridgedCastExpr, bridge_kind_name, 66, MX_APPLY_METHOD, BridgeKindName, basic_string_view, NthStmt) - MX_VISIT_ENTITY(ObjCBridgedCastExpr, l_paren_token, 44, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCBridgedCastExpr, bridge_keyword_token, 44, MX_APPLY_METHOD, BridgeKeywordToken, Token, NthStmt) + MX_VISIT_ENUM(ObjCBridgedCastExpr, bridge_kind, 92, MX_APPLY_METHOD, BridgeKind, ObjCBridgeCastKind, NthStmt) + MX_VISIT_TEXT(ObjCBridgedCastExpr, bridge_kind_name, 67, MX_APPLY_METHOD, BridgeKindName, basic_string_view, NthStmt) + MX_VISIT_ENTITY(ObjCBridgedCastExpr, l_paren_token, 45, MX_APPLY_METHOD, LParenToken, Token, NthStmt) MX_EXIT_VISIT_ObjCBridgedCastExpr MX_END_VISIT_STMT(ObjCBridgedCastExpr) @@ -16266,20 +16270,20 @@ MX_END_VISIT_STMT(ObjCBridgedCastExpr) MX_BEGIN_VISIT_STMT(CallExpr) MX_ENTER_VISIT_CallExpr MX_VISIT_BASE(CallExpr, Expr) - MX_VISIT_ENTITY_LIST(CallExpr, arguments, 15, MX_APPLY_METHOD, Arguments, Expr, NthStmt) - MX_VISIT_ENUM(CallExpr, adl_call_kind, 89, MX_APPLY_METHOD, ADLCallKind, CallExprADLCallKind, NthStmt) - MX_VISIT_INT(CallExpr, builtin_callee, 26, MX_APPLY_METHOD, BuiltinCallee, uint32_t, NthStmt) - MX_VISIT_ENTITY(CallExpr, call_return_type, 38, MX_APPLY_METHOD, CallReturnType, Type, NthStmt) - MX_VISIT_ENTITY(CallExpr, callee, 39, MX_APPLY_METHOD, Callee, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CallExpr, callee_declaration, 40, MX_APPLY_METHOD, CalleeDeclaration, Decl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CallExpr, direct_callee, 41, MX_APPLY_METHOD, DirectCallee, FunctionDecl, NthStmt) - MX_VISIT_ENTITY(CallExpr, r_paren_token, 42, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_BOOL(CallExpr, has_stored_fp_features, 84, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) - MX_VISIT_BOOL(CallExpr, has_unused_result_attribute, 85, MX_APPLY_METHOD, HasUnusedResultAttribute, bool, NthStmt) - MX_VISIT_BOOL(CallExpr, is_builtin_assume_false, 86, MX_APPLY_METHOD, IsBuiltinAssumeFalse, bool, NthStmt) - MX_VISIT_BOOL(CallExpr, is_call_to_std_move, 87, MX_APPLY_METHOD, IsCallToStdMove, bool, NthStmt) - MX_VISIT_BOOL(CallExpr, is_unevaluated_builtin_call, 88, MX_APPLY_METHOD, IsUnevaluatedBuiltinCall, bool, NthStmt) - MX_VISIT_BOOL(CallExpr, uses_adl, 90, MX_APPLY_METHOD, UsesADL, bool, NthStmt) + MX_VISIT_ENTITY_LIST(CallExpr, arguments, 16, MX_APPLY_METHOD, Arguments, Expr, NthStmt) + MX_VISIT_ENUM(CallExpr, adl_call_kind, 90, MX_APPLY_METHOD, ADLCallKind, CallExprADLCallKind, NthStmt) + MX_VISIT_INT(CallExpr, builtin_callee, 27, MX_APPLY_METHOD, BuiltinCallee, uint32_t, NthStmt) + MX_VISIT_ENTITY(CallExpr, call_return_type, 39, MX_APPLY_METHOD, CallReturnType, Type, NthStmt) + MX_VISIT_ENTITY(CallExpr, callee, 40, MX_APPLY_METHOD, Callee, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CallExpr, callee_declaration, 41, MX_APPLY_METHOD, CalleeDeclaration, Decl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CallExpr, direct_callee, 42, MX_APPLY_METHOD, DirectCallee, FunctionDecl, NthStmt) + MX_VISIT_ENTITY(CallExpr, r_paren_token, 43, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_BOOL(CallExpr, has_stored_fp_features, 85, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) + MX_VISIT_BOOL(CallExpr, has_unused_result_attribute, 86, MX_APPLY_METHOD, HasUnusedResultAttribute, bool, NthStmt) + MX_VISIT_BOOL(CallExpr, is_builtin_assume_false, 87, MX_APPLY_METHOD, IsBuiltinAssumeFalse, bool, NthStmt) + MX_VISIT_BOOL(CallExpr, is_call_to_std_move, 88, MX_APPLY_METHOD, IsCallToStdMove, bool, NthStmt) + MX_VISIT_BOOL(CallExpr, is_unevaluated_builtin_call, 89, MX_APPLY_METHOD, IsUnevaluatedBuiltinCall, bool, NthStmt) + MX_VISIT_BOOL(CallExpr, uses_adl, 91, MX_APPLY_METHOD, UsesADL, bool, NthStmt) MX_EXIT_VISIT_CallExpr MX_END_VISIT_STMT(CallExpr) @@ -16293,11 +16297,11 @@ MX_END_VISIT_STMT(CallExpr) MX_BEGIN_VISIT_STMT(CXXOperatorCallExpr) MX_ENTER_VISIT_CXXOperatorCallExpr MX_VISIT_BASE(CXXOperatorCallExpr, CallExpr) - MX_VISIT_ENUM(CXXOperatorCallExpr, operator_, 91, MX_APPLY_METHOD, Operator, OverloadedOperatorKind, NthStmt) - MX_VISIT_ENTITY(CXXOperatorCallExpr, operator_token, 43, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_BOOL(CXXOperatorCallExpr, is_assignment_operation, 92, MX_APPLY_METHOD, IsAssignmentOperation, bool, NthStmt) - MX_VISIT_BOOL(CXXOperatorCallExpr, is_comparison_operation, 93, MX_APPLY_METHOD, IsComparisonOperation, bool, NthStmt) - MX_VISIT_BOOL(CXXOperatorCallExpr, is_infix_binary_operation, 94, MX_APPLY_METHOD, IsInfixBinaryOperation, bool, NthStmt) + MX_VISIT_ENUM(CXXOperatorCallExpr, operator_, 92, MX_APPLY_METHOD, Operator, OverloadedOperatorKind, NthStmt) + MX_VISIT_ENTITY(CXXOperatorCallExpr, operator_token, 44, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_BOOL(CXXOperatorCallExpr, is_assignment_operation, 93, MX_APPLY_METHOD, IsAssignmentOperation, bool, NthStmt) + MX_VISIT_BOOL(CXXOperatorCallExpr, is_comparison_operation, 94, MX_APPLY_METHOD, IsComparisonOperation, bool, NthStmt) + MX_VISIT_BOOL(CXXOperatorCallExpr, is_infix_binary_operation, 95, MX_APPLY_METHOD, IsInfixBinaryOperation, bool, NthStmt) MX_EXIT_VISIT_CXXOperatorCallExpr MX_END_VISIT_STMT(CXXOperatorCallExpr) @@ -16311,10 +16315,10 @@ MX_END_VISIT_STMT(CXXOperatorCallExpr) MX_BEGIN_VISIT_STMT(CXXMemberCallExpr) MX_ENTER_VISIT_CXXMemberCallExpr MX_VISIT_BASE(CXXMemberCallExpr, CallExpr) - MX_VISIT_ENTITY(CXXMemberCallExpr, implicit_object_argument, 43, MX_APPLY_METHOD, ImplicitObjectArgument, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXMemberCallExpr, method_declaration, 44, MX_APPLY_METHOD, MethodDeclaration, CXXMethodDecl, NthStmt) - MX_VISIT_ENTITY(CXXMemberCallExpr, object_type, 45, MX_APPLY_METHOD, ObjectType, Type, NthStmt) - MX_VISIT_ENTITY(CXXMemberCallExpr, record_declaration, 46, MX_APPLY_METHOD, RecordDeclaration, CXXRecordDecl, NthStmt) + MX_VISIT_ENTITY(CXXMemberCallExpr, implicit_object_argument, 44, MX_APPLY_METHOD, ImplicitObjectArgument, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXMemberCallExpr, method_declaration, 45, MX_APPLY_METHOD, MethodDeclaration, CXXMethodDecl, NthStmt) + MX_VISIT_ENTITY(CXXMemberCallExpr, object_type, 46, MX_APPLY_METHOD, ObjectType, Type, NthStmt) + MX_VISIT_ENTITY(CXXMemberCallExpr, record_declaration, 47, MX_APPLY_METHOD, RecordDeclaration, CXXRecordDecl, NthStmt) MX_EXIT_VISIT_CXXMemberCallExpr MX_END_VISIT_STMT(CXXMemberCallExpr) @@ -16328,7 +16332,7 @@ MX_END_VISIT_STMT(CXXMemberCallExpr) MX_BEGIN_VISIT_STMT(CUDAKernelCallExpr) MX_ENTER_VISIT_CUDAKernelCallExpr MX_VISIT_BASE(CUDAKernelCallExpr, CallExpr) - MX_VISIT_ENTITY(CUDAKernelCallExpr, config, 43, MX_APPLY_METHOD, Config, CallExpr, NthStmt) + MX_VISIT_ENTITY(CUDAKernelCallExpr, config, 44, MX_APPLY_METHOD, Config, CallExpr, NthStmt) MX_EXIT_VISIT_CUDAKernelCallExpr MX_END_VISIT_STMT(CUDAKernelCallExpr) @@ -16342,9 +16346,9 @@ MX_END_VISIT_STMT(CUDAKernelCallExpr) MX_BEGIN_VISIT_STMT(UserDefinedLiteral) MX_ENTER_VISIT_UserDefinedLiteral MX_VISIT_BASE(UserDefinedLiteral, CallExpr) - MX_VISIT_OPTIONAL_ENTITY(UserDefinedLiteral, cooked_literal, 43, MX_APPLY_METHOD, CookedLiteral, Expr, NthStmt) - MX_VISIT_ENUM(UserDefinedLiteral, literal_operator_kind, 91, MX_APPLY_METHOD, LiteralOperatorKind, UserDefinedLiteralLiteralOperatorKind, NthStmt) - MX_VISIT_ENTITY(UserDefinedLiteral, ud_suffix_token, 44, MX_APPLY_METHOD, UDSuffixToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(UserDefinedLiteral, cooked_literal, 44, MX_APPLY_METHOD, CookedLiteral, Expr, NthStmt) + MX_VISIT_ENUM(UserDefinedLiteral, literal_operator_kind, 92, MX_APPLY_METHOD, LiteralOperatorKind, UserDefinedLiteralLiteralOperatorKind, NthStmt) + MX_VISIT_ENTITY(UserDefinedLiteral, ud_suffix_token, 45, MX_APPLY_METHOD, UDSuffixToken, Token, NthStmt) MX_EXIT_VISIT_UserDefinedLiteral MX_END_VISIT_STMT(UserDefinedLiteral) @@ -16358,11 +16362,11 @@ MX_END_VISIT_STMT(UserDefinedLiteral) MX_BEGIN_VISIT_STMT(CXXUuidofExpr) MX_ENTER_VISIT_CXXUuidofExpr MX_VISIT_BASE(CXXUuidofExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(CXXUuidofExpr, expression_operand, 38, MX_APPLY_METHOD, ExpressionOperand, Expr, NthStmt) - MX_VISIT_ENTITY(CXXUuidofExpr, guid_declaration, 39, MX_APPLY_METHOD, GuidDeclaration, MSGuidDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXUuidofExpr, type_operand, 40, MX_APPLY_METHOD, TypeOperand, Type, NthStmt) - MX_VISIT_ENTITY(CXXUuidofExpr, type_operand_source_info, 41, MX_APPLY_METHOD, TypeOperandSourceInfo, Type, NthStmt) - MX_VISIT_BOOL(CXXUuidofExpr, is_type_operand, 84, MX_APPLY_METHOD, IsTypeOperand, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXUuidofExpr, expression_operand, 39, MX_APPLY_METHOD, ExpressionOperand, Expr, NthStmt) + MX_VISIT_ENTITY(CXXUuidofExpr, guid_declaration, 40, MX_APPLY_METHOD, GuidDeclaration, MSGuidDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXUuidofExpr, type_operand, 41, MX_APPLY_METHOD, TypeOperand, Type, NthStmt) + MX_VISIT_ENTITY(CXXUuidofExpr, type_operand_source_info, 42, MX_APPLY_METHOD, TypeOperandSourceInfo, Type, NthStmt) + MX_VISIT_BOOL(CXXUuidofExpr, is_type_operand, 85, MX_APPLY_METHOD, IsTypeOperand, bool, NthStmt) MX_EXIT_VISIT_CXXUuidofExpr MX_END_VISIT_STMT(CXXUuidofExpr) @@ -16376,11 +16380,11 @@ MX_END_VISIT_STMT(CXXUuidofExpr) MX_BEGIN_VISIT_STMT(CXXUnresolvedConstructExpr) MX_ENTER_VISIT_CXXUnresolvedConstructExpr MX_VISIT_BASE(CXXUnresolvedConstructExpr, Expr) - MX_VISIT_ENTITY_LIST(CXXUnresolvedConstructExpr, arguments, 15, MX_APPLY_METHOD, Arguments, Expr, NthStmt) - MX_VISIT_ENTITY(CXXUnresolvedConstructExpr, l_paren_token, 38, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXUnresolvedConstructExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXUnresolvedConstructExpr, type_as_written, 40, MX_APPLY_METHOD, TypeAsWritten, Type, NthStmt) - MX_VISIT_BOOL(CXXUnresolvedConstructExpr, is_list_initialization, 84, MX_APPLY_METHOD, IsListInitialization, bool, NthStmt) + MX_VISIT_ENTITY_LIST(CXXUnresolvedConstructExpr, arguments, 16, MX_APPLY_METHOD, Arguments, Expr, NthStmt) + MX_VISIT_ENTITY(CXXUnresolvedConstructExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXUnresolvedConstructExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXUnresolvedConstructExpr, type_as_written, 41, MX_APPLY_METHOD, TypeAsWritten, Type, NthStmt) + MX_VISIT_BOOL(CXXUnresolvedConstructExpr, is_list_initialization, 85, MX_APPLY_METHOD, IsListInitialization, bool, NthStmt) MX_EXIT_VISIT_CXXUnresolvedConstructExpr MX_END_VISIT_STMT(CXXUnresolvedConstructExpr) @@ -16394,12 +16398,12 @@ MX_END_VISIT_STMT(CXXUnresolvedConstructExpr) MX_BEGIN_VISIT_STMT(CXXTypeidExpr) MX_ENTER_VISIT_CXXTypeidExpr MX_VISIT_BASE(CXXTypeidExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(CXXTypeidExpr, expression_operand, 38, MX_APPLY_METHOD, ExpressionOperand, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXTypeidExpr, type_operand, 39, MX_APPLY_METHOD, TypeOperand, Type, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXTypeidExpr, type_operand_source_info, 40, MX_APPLY_METHOD, TypeOperandSourceInfo, Type, NthStmt) - MX_VISIT_OPTIONAL_BOOL(CXXTypeidExpr, is_most_derived, 84, MX_APPLY_METHOD, IsMostDerived, bool, NthStmt) - MX_VISIT_BOOL(CXXTypeidExpr, is_potentially_evaluated, 86, MX_APPLY_METHOD, IsPotentiallyEvaluated, bool, NthStmt) - MX_VISIT_BOOL(CXXTypeidExpr, is_type_operand, 87, MX_APPLY_METHOD, IsTypeOperand, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXTypeidExpr, expression_operand, 39, MX_APPLY_METHOD, ExpressionOperand, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXTypeidExpr, type_operand, 40, MX_APPLY_METHOD, TypeOperand, Type, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXTypeidExpr, type_operand_source_info, 41, MX_APPLY_METHOD, TypeOperandSourceInfo, Type, NthStmt) + MX_VISIT_OPTIONAL_BOOL(CXXTypeidExpr, is_most_derived, 85, MX_APPLY_METHOD, IsMostDerived, bool, NthStmt) + MX_VISIT_BOOL(CXXTypeidExpr, is_potentially_evaluated, 87, MX_APPLY_METHOD, IsPotentiallyEvaluated, bool, NthStmt) + MX_VISIT_BOOL(CXXTypeidExpr, is_type_operand, 88, MX_APPLY_METHOD, IsTypeOperand, bool, NthStmt) MX_EXIT_VISIT_CXXTypeidExpr MX_END_VISIT_STMT(CXXTypeidExpr) @@ -16413,9 +16417,9 @@ MX_END_VISIT_STMT(CXXTypeidExpr) MX_BEGIN_VISIT_STMT(CXXThrowExpr) MX_ENTER_VISIT_CXXThrowExpr MX_VISIT_BASE(CXXThrowExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(CXXThrowExpr, sub_expression, 38, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) - MX_VISIT_ENTITY(CXXThrowExpr, throw_token, 39, MX_APPLY_METHOD, ThrowToken, Token, NthStmt) - MX_VISIT_BOOL(CXXThrowExpr, is_thrown_variable_in_scope, 84, MX_APPLY_METHOD, IsThrownVariableInScope, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXThrowExpr, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CXXThrowExpr, throw_token, 40, MX_APPLY_METHOD, ThrowToken, Token, NthStmt) + MX_VISIT_BOOL(CXXThrowExpr, is_thrown_variable_in_scope, 85, MX_APPLY_METHOD, IsThrownVariableInScope, bool, NthStmt) MX_EXIT_VISIT_CXXThrowExpr MX_END_VISIT_STMT(CXXThrowExpr) @@ -16429,8 +16433,8 @@ MX_END_VISIT_STMT(CXXThrowExpr) MX_BEGIN_VISIT_STMT(CXXThisExpr) MX_ENTER_VISIT_CXXThisExpr MX_VISIT_BASE(CXXThisExpr, Expr) - MX_VISIT_ENTITY(CXXThisExpr, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_BOOL(CXXThisExpr, is_implicit, 84, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) + MX_VISIT_ENTITY(CXXThisExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_BOOL(CXXThisExpr, is_implicit, 85, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) MX_EXIT_VISIT_CXXThisExpr MX_END_VISIT_STMT(CXXThisExpr) @@ -16444,7 +16448,7 @@ MX_END_VISIT_STMT(CXXThisExpr) MX_BEGIN_VISIT_STMT(CXXStdInitializerListExpr) MX_ENTER_VISIT_CXXStdInitializerListExpr MX_VISIT_BASE(CXXStdInitializerListExpr, Expr) - MX_VISIT_ENTITY(CXXStdInitializerListExpr, sub_expression, 38, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CXXStdInitializerListExpr, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) MX_EXIT_VISIT_CXXStdInitializerListExpr MX_END_VISIT_STMT(CXXStdInitializerListExpr) @@ -16458,7 +16462,7 @@ MX_END_VISIT_STMT(CXXStdInitializerListExpr) MX_BEGIN_VISIT_STMT(CXXScalarValueInitExpr) MX_ENTER_VISIT_CXXScalarValueInitExpr MX_VISIT_BASE(CXXScalarValueInitExpr, Expr) - MX_VISIT_ENTITY(CXXScalarValueInitExpr, r_paren_token, 38, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXScalarValueInitExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_CXXScalarValueInitExpr MX_END_VISIT_STMT(CXXScalarValueInitExpr) @@ -16472,16 +16476,16 @@ MX_END_VISIT_STMT(CXXScalarValueInitExpr) MX_BEGIN_VISIT_STMT(CXXRewrittenBinaryOperator) MX_ENTER_VISIT_CXXRewrittenBinaryOperator MX_VISIT_BASE(CXXRewrittenBinaryOperator, Expr) - MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, lhs, 38, MX_APPLY_METHOD, LHS, Expr, NthStmt) - MX_VISIT_ENUM(CXXRewrittenBinaryOperator, opcode, 89, MX_APPLY_METHOD, Opcode, BinaryOperatorKind, NthStmt) - MX_VISIT_TEXT(CXXRewrittenBinaryOperator, opcode_string, 61, MX_APPLY_METHOD, OpcodeString, basic_string_view, NthStmt) - MX_VISIT_ENUM(CXXRewrittenBinaryOperator, operator_, 91, MX_APPLY_METHOD, Operator, BinaryOperatorKind, NthStmt) - MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, operator_token, 39, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, rhs, 40, MX_APPLY_METHOD, RHS, Expr, NthStmt) - MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, semantic_form, 41, MX_APPLY_METHOD, SemanticForm, Expr, NthStmt) - MX_VISIT_BOOL(CXXRewrittenBinaryOperator, is_assignment_operation, 84, MX_APPLY_METHOD, IsAssignmentOperation, bool, NthStmt) - MX_VISIT_BOOL(CXXRewrittenBinaryOperator, is_comparison_operation, 85, MX_APPLY_METHOD, IsComparisonOperation, bool, NthStmt) - MX_VISIT_BOOL(CXXRewrittenBinaryOperator, is_reversed, 86, MX_APPLY_METHOD, IsReversed, bool, NthStmt) + MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, lhs, 39, MX_APPLY_METHOD, LHS, Expr, NthStmt) + MX_VISIT_ENUM(CXXRewrittenBinaryOperator, opcode, 90, MX_APPLY_METHOD, Opcode, BinaryOperatorKind, NthStmt) + MX_VISIT_TEXT(CXXRewrittenBinaryOperator, opcode_string, 62, MX_APPLY_METHOD, OpcodeString, basic_string_view, NthStmt) + MX_VISIT_ENUM(CXXRewrittenBinaryOperator, operator_, 92, MX_APPLY_METHOD, Operator, BinaryOperatorKind, NthStmt) + MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, operator_token, 40, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, rhs, 41, MX_APPLY_METHOD, RHS, Expr, NthStmt) + MX_VISIT_ENTITY(CXXRewrittenBinaryOperator, semantic_form, 42, MX_APPLY_METHOD, SemanticForm, Expr, NthStmt) + MX_VISIT_BOOL(CXXRewrittenBinaryOperator, is_assignment_operation, 85, MX_APPLY_METHOD, IsAssignmentOperation, bool, NthStmt) + MX_VISIT_BOOL(CXXRewrittenBinaryOperator, is_comparison_operation, 86, MX_APPLY_METHOD, IsComparisonOperation, bool, NthStmt) + MX_VISIT_BOOL(CXXRewrittenBinaryOperator, is_reversed, 87, MX_APPLY_METHOD, IsReversed, bool, NthStmt) MX_EXIT_VISIT_CXXRewrittenBinaryOperator MX_END_VISIT_STMT(CXXRewrittenBinaryOperator) @@ -16495,14 +16499,14 @@ MX_END_VISIT_STMT(CXXRewrittenBinaryOperator) MX_BEGIN_VISIT_STMT(CXXPseudoDestructorExpr) MX_ENTER_VISIT_CXXPseudoDestructorExpr MX_VISIT_BASE(CXXPseudoDestructorExpr, Expr) - MX_VISIT_ENTITY(CXXPseudoDestructorExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(CXXPseudoDestructorExpr, colon_colon_token, 39, MX_APPLY_METHOD, ColonColonToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXPseudoDestructorExpr, destroyed_type, 40, MX_APPLY_METHOD, DestroyedType, Type, NthStmt) - MX_VISIT_ENTITY(CXXPseudoDestructorExpr, destroyed_type_token, 41, MX_APPLY_METHOD, DestroyedTypeToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXPseudoDestructorExpr, operator_token, 42, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXPseudoDestructorExpr, tilde_token, 43, MX_APPLY_METHOD, TildeToken, Token, NthStmt) - MX_VISIT_BOOL(CXXPseudoDestructorExpr, has_qualifier, 84, MX_APPLY_METHOD, HasQualifier, bool, NthStmt) - MX_VISIT_BOOL(CXXPseudoDestructorExpr, is_arrow, 85, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_ENTITY(CXXPseudoDestructorExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(CXXPseudoDestructorExpr, colon_colon_token, 40, MX_APPLY_METHOD, ColonColonToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXPseudoDestructorExpr, destroyed_type, 41, MX_APPLY_METHOD, DestroyedType, Type, NthStmt) + MX_VISIT_ENTITY(CXXPseudoDestructorExpr, destroyed_type_token, 42, MX_APPLY_METHOD, DestroyedTypeToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXPseudoDestructorExpr, operator_token, 43, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXPseudoDestructorExpr, tilde_token, 44, MX_APPLY_METHOD, TildeToken, Token, NthStmt) + MX_VISIT_BOOL(CXXPseudoDestructorExpr, has_qualifier, 85, MX_APPLY_METHOD, HasQualifier, bool, NthStmt) + MX_VISIT_BOOL(CXXPseudoDestructorExpr, is_arrow, 86, MX_APPLY_METHOD, IsArrow, bool, NthStmt) MX_EXIT_VISIT_CXXPseudoDestructorExpr MX_END_VISIT_STMT(CXXPseudoDestructorExpr) @@ -16516,9 +16520,9 @@ MX_END_VISIT_STMT(CXXPseudoDestructorExpr) MX_BEGIN_VISIT_STMT(CXXParenListInitExpr) MX_ENTER_VISIT_CXXParenListInitExpr MX_VISIT_BASE(CXXParenListInitExpr, Expr) - MX_VISIT_ENTITY(CXXParenListInitExpr, array_filler, 38, MX_APPLY_METHOD, ArrayFiller, Expr, NthStmt) - MX_VISIT_ENTITY(CXXParenListInitExpr, initializer_token, 39, MX_APPLY_METHOD, InitializerToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXParenListInitExpr, initialized_field_in_union, 40, MX_APPLY_METHOD, InitializedFieldInUnion, FieldDecl, NthStmt) + MX_VISIT_ENTITY(CXXParenListInitExpr, array_filler, 39, MX_APPLY_METHOD, ArrayFiller, Expr, NthStmt) + MX_VISIT_ENTITY(CXXParenListInitExpr, initializer_token, 40, MX_APPLY_METHOD, InitializerToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXParenListInitExpr, initialized_field_in_union, 41, MX_APPLY_METHOD, InitializedFieldInUnion, FieldDecl, NthStmt) MX_EXIT_VISIT_CXXParenListInitExpr MX_END_VISIT_STMT(CXXParenListInitExpr) @@ -16532,7 +16536,7 @@ MX_END_VISIT_STMT(CXXParenListInitExpr) MX_BEGIN_VISIT_STMT(CXXNullPtrLiteralExpr) MX_ENTER_VISIT_CXXNullPtrLiteralExpr MX_VISIT_BASE(CXXNullPtrLiteralExpr, Expr) - MX_VISIT_ENTITY(CXXNullPtrLiteralExpr, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_ENTITY(CXXNullPtrLiteralExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) MX_EXIT_VISIT_CXXNullPtrLiteralExpr MX_END_VISIT_STMT(CXXNullPtrLiteralExpr) @@ -16546,8 +16550,8 @@ MX_END_VISIT_STMT(CXXNullPtrLiteralExpr) MX_BEGIN_VISIT_STMT(CXXNoexceptExpr) MX_ENTER_VISIT_CXXNoexceptExpr MX_VISIT_BASE(CXXNoexceptExpr, Expr) - MX_VISIT_ENTITY(CXXNoexceptExpr, operand, 38, MX_APPLY_METHOD, Operand, Expr, NthStmt) - MX_VISIT_BOOL(CXXNoexceptExpr, value, 84, MX_APPLY_METHOD, Value, bool, NthStmt) + MX_VISIT_ENTITY(CXXNoexceptExpr, operand, 39, MX_APPLY_METHOD, Operand, Expr, NthStmt) + MX_VISIT_BOOL(CXXNoexceptExpr, value, 85, MX_APPLY_METHOD, Value, bool, NthStmt) MX_EXIT_VISIT_CXXNoexceptExpr MX_END_VISIT_STMT(CXXNoexceptExpr) @@ -16561,22 +16565,22 @@ MX_END_VISIT_STMT(CXXNoexceptExpr) MX_BEGIN_VISIT_STMT(CXXNewExpr) MX_ENTER_VISIT_CXXNewExpr MX_VISIT_BASE(CXXNewExpr, Expr) - MX_VISIT_BOOL(CXXNewExpr, does_usual_array_delete_want_size, 84, MX_APPLY_METHOD, DoesUsualArrayDeleteWantSize, bool, NthStmt) - MX_VISIT_ENTITY(CXXNewExpr, allocated_type, 38, MX_APPLY_METHOD, AllocatedType, Type, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, array_size, 39, MX_APPLY_METHOD, ArraySize, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, construct_expression, 40, MX_APPLY_METHOD, ConstructExpression, CXXConstructExpr, NthStmt) - MX_VISIT_TOKEN_RANGE(CXXNewExpr, direct_initializer_range, 41, 42, NthStmt) - MX_VISIT_ENUM(CXXNewExpr, initialization_style, 89, MX_APPLY_METHOD, InitializationStyle, CXXNewInitializationStyle, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, initializer, 43, MX_APPLY_METHOD, Initializer, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, operator_delete, 44, MX_APPLY_METHOD, OperatorDelete, FunctionDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, operator_new, 45, MX_APPLY_METHOD, OperatorNew, FunctionDecl, NthStmt) - MX_VISIT_TOKEN_RANGE(CXXNewExpr, type_id_parentheses, 46, 47, NthStmt) - MX_VISIT_BOOL(CXXNewExpr, has_initializer, 85, MX_APPLY_METHOD, HasInitializer, bool, NthStmt) - MX_VISIT_BOOL(CXXNewExpr, is_array, 86, MX_APPLY_METHOD, IsArray, bool, NthStmt) - MX_VISIT_BOOL(CXXNewExpr, is_global_new, 87, MX_APPLY_METHOD, IsGlobalNew, bool, NthStmt) - MX_VISIT_BOOL(CXXNewExpr, is_parenthesis_type_id, 88, MX_APPLY_METHOD, IsParenthesisTypeId, bool, NthStmt) - MX_VISIT_BOOL(CXXNewExpr, pass_alignment, 90, MX_APPLY_METHOD, PassAlignment, bool, NthStmt) - MX_VISIT_ENTITY_LIST(CXXNewExpr, placement_arguments, 15, MX_APPLY_METHOD, PlacementArguments, Expr, NthStmt) + MX_VISIT_BOOL(CXXNewExpr, does_usual_array_delete_want_size, 85, MX_APPLY_METHOD, DoesUsualArrayDeleteWantSize, bool, NthStmt) + MX_VISIT_ENTITY(CXXNewExpr, allocated_type, 39, MX_APPLY_METHOD, AllocatedType, Type, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, array_size, 40, MX_APPLY_METHOD, ArraySize, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, construct_expression, 41, MX_APPLY_METHOD, ConstructExpression, CXXConstructExpr, NthStmt) + MX_VISIT_TOKEN_RANGE(CXXNewExpr, direct_initializer_range, 42, 43, NthStmt) + MX_VISIT_ENUM(CXXNewExpr, initialization_style, 90, MX_APPLY_METHOD, InitializationStyle, CXXNewInitializationStyle, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, initializer, 44, MX_APPLY_METHOD, Initializer, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, operator_delete, 45, MX_APPLY_METHOD, OperatorDelete, FunctionDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXNewExpr, operator_new, 46, MX_APPLY_METHOD, OperatorNew, FunctionDecl, NthStmt) + MX_VISIT_TOKEN_RANGE(CXXNewExpr, type_id_parentheses, 47, 48, NthStmt) + MX_VISIT_BOOL(CXXNewExpr, has_initializer, 86, MX_APPLY_METHOD, HasInitializer, bool, NthStmt) + MX_VISIT_BOOL(CXXNewExpr, is_array, 87, MX_APPLY_METHOD, IsArray, bool, NthStmt) + MX_VISIT_BOOL(CXXNewExpr, is_global_new, 88, MX_APPLY_METHOD, IsGlobalNew, bool, NthStmt) + MX_VISIT_BOOL(CXXNewExpr, is_parenthesis_type_id, 89, MX_APPLY_METHOD, IsParenthesisTypeId, bool, NthStmt) + MX_VISIT_BOOL(CXXNewExpr, pass_alignment, 91, MX_APPLY_METHOD, PassAlignment, bool, NthStmt) + MX_VISIT_ENTITY_LIST(CXXNewExpr, placement_arguments, 16, MX_APPLY_METHOD, PlacementArguments, Expr, NthStmt) MX_EXIT_VISIT_CXXNewExpr MX_END_VISIT_STMT(CXXNewExpr) @@ -16590,11 +16594,11 @@ MX_END_VISIT_STMT(CXXNewExpr) MX_BEGIN_VISIT_STMT(CXXInheritedCtorInitExpr) MX_ENTER_VISIT_CXXInheritedCtorInitExpr MX_VISIT_BASE(CXXInheritedCtorInitExpr, Expr) - MX_VISIT_BOOL(CXXInheritedCtorInitExpr, constructs_virtual_base, 84, MX_APPLY_METHOD, ConstructsVirtualBase, bool, NthStmt) - MX_VISIT_ENUM(CXXInheritedCtorInitExpr, construction_kind, 89, MX_APPLY_METHOD, ConstructionKind, CXXConstructionKind, NthStmt) - MX_VISIT_ENTITY(CXXInheritedCtorInitExpr, constructor, 38, MX_APPLY_METHOD, Constructor, CXXConstructorDecl, NthStmt) - MX_VISIT_ENTITY(CXXInheritedCtorInitExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_BOOL(CXXInheritedCtorInitExpr, inherited_from_virtual_base, 85, MX_APPLY_METHOD, InheritedFromVirtualBase, bool, NthStmt) + MX_VISIT_BOOL(CXXInheritedCtorInitExpr, constructs_virtual_base, 85, MX_APPLY_METHOD, ConstructsVirtualBase, bool, NthStmt) + MX_VISIT_ENUM(CXXInheritedCtorInitExpr, construction_kind, 90, MX_APPLY_METHOD, ConstructionKind, CXXConstructionKind, NthStmt) + MX_VISIT_ENTITY(CXXInheritedCtorInitExpr, constructor, 39, MX_APPLY_METHOD, Constructor, CXXConstructorDecl, NthStmt) + MX_VISIT_ENTITY(CXXInheritedCtorInitExpr, token, 40, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_BOOL(CXXInheritedCtorInitExpr, inherited_from_virtual_base, 86, MX_APPLY_METHOD, InheritedFromVirtualBase, bool, NthStmt) MX_EXIT_VISIT_CXXInheritedCtorInitExpr MX_END_VISIT_STMT(CXXInheritedCtorInitExpr) @@ -16608,17 +16612,17 @@ MX_END_VISIT_STMT(CXXInheritedCtorInitExpr) MX_BEGIN_VISIT_STMT(CXXFoldExpr) MX_ENTER_VISIT_CXXFoldExpr MX_VISIT_BASE(CXXFoldExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, callee, 38, MX_APPLY_METHOD, Callee, UnresolvedLookupExpr, NthStmt) - MX_VISIT_ENTITY(CXXFoldExpr, ellipsis_token, 39, MX_APPLY_METHOD, EllipsisToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, initializer, 40, MX_APPLY_METHOD, Initializer, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, lhs, 41, MX_APPLY_METHOD, LHS, Expr, NthStmt) - MX_VISIT_ENTITY(CXXFoldExpr, l_paren_token, 42, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENUM(CXXFoldExpr, operator_, 89, MX_APPLY_METHOD, Operator, BinaryOperatorKind, NthStmt) - MX_VISIT_ENTITY(CXXFoldExpr, pattern, 43, MX_APPLY_METHOD, Pattern, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, rhs, 44, MX_APPLY_METHOD, RHS, Expr, NthStmt) - MX_VISIT_ENTITY(CXXFoldExpr, r_paren_token, 45, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_BOOL(CXXFoldExpr, is_left_fold, 84, MX_APPLY_METHOD, IsLeftFold, bool, NthStmt) - MX_VISIT_BOOL(CXXFoldExpr, is_right_fold, 85, MX_APPLY_METHOD, IsRightFold, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, callee, 39, MX_APPLY_METHOD, Callee, UnresolvedLookupExpr, NthStmt) + MX_VISIT_ENTITY(CXXFoldExpr, ellipsis_token, 40, MX_APPLY_METHOD, EllipsisToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, initializer, 41, MX_APPLY_METHOD, Initializer, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, lhs, 42, MX_APPLY_METHOD, LHS, Expr, NthStmt) + MX_VISIT_ENTITY(CXXFoldExpr, l_paren_token, 43, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENUM(CXXFoldExpr, operator_, 90, MX_APPLY_METHOD, Operator, BinaryOperatorKind, NthStmt) + MX_VISIT_ENTITY(CXXFoldExpr, pattern, 44, MX_APPLY_METHOD, Pattern, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXFoldExpr, rhs, 45, MX_APPLY_METHOD, RHS, Expr, NthStmt) + MX_VISIT_ENTITY(CXXFoldExpr, r_paren_token, 46, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_BOOL(CXXFoldExpr, is_left_fold, 85, MX_APPLY_METHOD, IsLeftFold, bool, NthStmt) + MX_VISIT_BOOL(CXXFoldExpr, is_right_fold, 86, MX_APPLY_METHOD, IsRightFold, bool, NthStmt) MX_EXIT_VISIT_CXXFoldExpr MX_END_VISIT_STMT(CXXFoldExpr) @@ -16632,18 +16636,18 @@ MX_END_VISIT_STMT(CXXFoldExpr) MX_BEGIN_VISIT_STMT(CXXDependentScopeMemberExpr) MX_ENTER_VISIT_CXXDependentScopeMemberExpr MX_VISIT_BASE(CXXDependentScopeMemberExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(CXXDependentScopeMemberExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, base_type, 39, MX_APPLY_METHOD, BaseType, Type, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXDependentScopeMemberExpr, first_qualifier_found_in_scope, 40, MX_APPLY_METHOD, FirstQualifierFoundInScope, NamedDecl, NthStmt) - MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, l_angle_token, 41, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, member_token, 42, MX_APPLY_METHOD, MemberToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, operator_token, 43, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, r_angle_token, 44, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, template_keyword_token, 45, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) - MX_VISIT_BOOL(CXXDependentScopeMemberExpr, has_explicit_template_arguments, 84, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) - MX_VISIT_BOOL(CXXDependentScopeMemberExpr, has_template_keyword, 85, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) - MX_VISIT_BOOL(CXXDependentScopeMemberExpr, is_arrow, 86, MX_APPLY_METHOD, IsArrow, bool, NthStmt) - MX_VISIT_BOOL(CXXDependentScopeMemberExpr, is_implicit_access, 87, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXDependentScopeMemberExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, base_type, 40, MX_APPLY_METHOD, BaseType, Type, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXDependentScopeMemberExpr, first_qualifier_found_in_scope, 41, MX_APPLY_METHOD, FirstQualifierFoundInScope, NamedDecl, NthStmt) + MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, l_angle_token, 42, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, member_token, 43, MX_APPLY_METHOD, MemberToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, operator_token, 44, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, r_angle_token, 45, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(CXXDependentScopeMemberExpr, template_keyword_token, 46, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) + MX_VISIT_BOOL(CXXDependentScopeMemberExpr, has_explicit_template_arguments, 85, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) + MX_VISIT_BOOL(CXXDependentScopeMemberExpr, has_template_keyword, 86, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) + MX_VISIT_BOOL(CXXDependentScopeMemberExpr, is_arrow, 87, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_BOOL(CXXDependentScopeMemberExpr, is_implicit_access, 88, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) MX_EXIT_VISIT_CXXDependentScopeMemberExpr MX_END_VISIT_STMT(CXXDependentScopeMemberExpr) @@ -16657,13 +16661,13 @@ MX_END_VISIT_STMT(CXXDependentScopeMemberExpr) MX_BEGIN_VISIT_STMT(CXXDeleteExpr) MX_ENTER_VISIT_CXXDeleteExpr MX_VISIT_BASE(CXXDeleteExpr, Expr) - MX_VISIT_BOOL(CXXDeleteExpr, does_usual_array_delete_want_size, 84, MX_APPLY_METHOD, DoesUsualArrayDeleteWantSize, bool, NthStmt) - MX_VISIT_ENTITY(CXXDeleteExpr, argument, 38, MX_APPLY_METHOD, Argument, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXDeleteExpr, destroyed_type, 39, MX_APPLY_METHOD, DestroyedType, Type, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXDeleteExpr, operator_delete, 40, MX_APPLY_METHOD, OperatorDelete, FunctionDecl, NthStmt) - MX_VISIT_BOOL(CXXDeleteExpr, is_array_form, 85, MX_APPLY_METHOD, IsArrayForm, bool, NthStmt) - MX_VISIT_BOOL(CXXDeleteExpr, is_array_form_as_written, 86, MX_APPLY_METHOD, IsArrayFormAsWritten, bool, NthStmt) - MX_VISIT_BOOL(CXXDeleteExpr, is_global_delete, 87, MX_APPLY_METHOD, IsGlobalDelete, bool, NthStmt) + MX_VISIT_BOOL(CXXDeleteExpr, does_usual_array_delete_want_size, 85, MX_APPLY_METHOD, DoesUsualArrayDeleteWantSize, bool, NthStmt) + MX_VISIT_ENTITY(CXXDeleteExpr, argument, 39, MX_APPLY_METHOD, Argument, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXDeleteExpr, destroyed_type, 40, MX_APPLY_METHOD, DestroyedType, Type, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXDeleteExpr, operator_delete, 41, MX_APPLY_METHOD, OperatorDelete, FunctionDecl, NthStmt) + MX_VISIT_BOOL(CXXDeleteExpr, is_array_form, 86, MX_APPLY_METHOD, IsArrayForm, bool, NthStmt) + MX_VISIT_BOOL(CXXDeleteExpr, is_array_form_as_written, 87, MX_APPLY_METHOD, IsArrayFormAsWritten, bool, NthStmt) + MX_VISIT_BOOL(CXXDeleteExpr, is_global_delete, 88, MX_APPLY_METHOD, IsGlobalDelete, bool, NthStmt) MX_EXIT_VISIT_CXXDeleteExpr MX_END_VISIT_STMT(CXXDeleteExpr) @@ -16677,11 +16681,11 @@ MX_END_VISIT_STMT(CXXDeleteExpr) MX_BEGIN_VISIT_STMT(CXXDefaultInitExpr) MX_ENTER_VISIT_CXXDefaultInitExpr MX_VISIT_BASE(CXXDefaultInitExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(CXXDefaultInitExpr, expression, 38, MX_APPLY_METHOD, Expression, Expr, NthStmt) - MX_VISIT_ENTITY(CXXDefaultInitExpr, field, 39, MX_APPLY_METHOD, Field, FieldDecl, NthStmt) - MX_VISIT_ENTITY(CXXDefaultInitExpr, rewritten_expression, 40, MX_APPLY_METHOD, RewrittenExpression, Expr, NthStmt) - MX_VISIT_ENTITY(CXXDefaultInitExpr, used_token, 41, MX_APPLY_METHOD, UsedToken, Token, NthStmt) - MX_VISIT_BOOL(CXXDefaultInitExpr, has_rewritten_initializer, 84, MX_APPLY_METHOD, HasRewrittenInitializer, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXDefaultInitExpr, expression, 39, MX_APPLY_METHOD, Expression, Expr, NthStmt) + MX_VISIT_ENTITY(CXXDefaultInitExpr, field, 40, MX_APPLY_METHOD, Field, FieldDecl, NthStmt) + MX_VISIT_ENTITY(CXXDefaultInitExpr, rewritten_expression, 41, MX_APPLY_METHOD, RewrittenExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CXXDefaultInitExpr, used_token, 42, MX_APPLY_METHOD, UsedToken, Token, NthStmt) + MX_VISIT_BOOL(CXXDefaultInitExpr, has_rewritten_initializer, 85, MX_APPLY_METHOD, HasRewrittenInitializer, bool, NthStmt) MX_EXIT_VISIT_CXXDefaultInitExpr MX_END_VISIT_STMT(CXXDefaultInitExpr) @@ -16695,11 +16699,11 @@ MX_END_VISIT_STMT(CXXDefaultInitExpr) MX_BEGIN_VISIT_STMT(CXXDefaultArgExpr) MX_ENTER_VISIT_CXXDefaultArgExpr MX_VISIT_BASE(CXXDefaultArgExpr, Expr) - MX_VISIT_ENTITY(CXXDefaultArgExpr, expression, 38, MX_APPLY_METHOD, Expression, Expr, NthStmt) - MX_VISIT_ENTITY(CXXDefaultArgExpr, parameter, 39, MX_APPLY_METHOD, Parameter, ParmVarDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CXXDefaultArgExpr, rewritten_expression, 40, MX_APPLY_METHOD, RewrittenExpression, Expr, NthStmt) - MX_VISIT_ENTITY(CXXDefaultArgExpr, used_token, 41, MX_APPLY_METHOD, UsedToken, Token, NthStmt) - MX_VISIT_BOOL(CXXDefaultArgExpr, has_rewritten_initializer, 84, MX_APPLY_METHOD, HasRewrittenInitializer, bool, NthStmt) + MX_VISIT_ENTITY(CXXDefaultArgExpr, expression, 39, MX_APPLY_METHOD, Expression, Expr, NthStmt) + MX_VISIT_ENTITY(CXXDefaultArgExpr, parameter, 40, MX_APPLY_METHOD, Parameter, ParmVarDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CXXDefaultArgExpr, rewritten_expression, 41, MX_APPLY_METHOD, RewrittenExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CXXDefaultArgExpr, used_token, 42, MX_APPLY_METHOD, UsedToken, Token, NthStmt) + MX_VISIT_BOOL(CXXDefaultArgExpr, has_rewritten_initializer, 85, MX_APPLY_METHOD, HasRewrittenInitializer, bool, NthStmt) MX_EXIT_VISIT_CXXDefaultArgExpr MX_END_VISIT_STMT(CXXDefaultArgExpr) @@ -16713,17 +16717,17 @@ MX_END_VISIT_STMT(CXXDefaultArgExpr) MX_BEGIN_VISIT_STMT(CXXConstructExpr) MX_ENTER_VISIT_CXXConstructExpr MX_VISIT_BASE(CXXConstructExpr, Expr) - MX_VISIT_ENTITY_LIST(CXXConstructExpr, arguments, 15, MX_APPLY_METHOD, Arguments, Expr, NthStmt) - MX_VISIT_ENUM(CXXConstructExpr, construction_kind, 89, MX_APPLY_METHOD, ConstructionKind, CXXConstructionKind, NthStmt) - MX_VISIT_ENTITY(CXXConstructExpr, constructor, 38, MX_APPLY_METHOD, Constructor, CXXConstructorDecl, NthStmt) - MX_VISIT_ENTITY(CXXConstructExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_TOKEN_RANGE(CXXConstructExpr, parenthesis_or_brace_range, 40, 41, NthStmt) - MX_VISIT_BOOL(CXXConstructExpr, had_multiple_candidates, 84, MX_APPLY_METHOD, HadMultipleCandidates, bool, NthStmt) - MX_VISIT_BOOL(CXXConstructExpr, is_elidable, 85, MX_APPLY_METHOD, IsElidable, bool, NthStmt) - MX_VISIT_BOOL(CXXConstructExpr, is_immediate_escalating, 86, MX_APPLY_METHOD, IsImmediateEscalating, bool, NthStmt) - MX_VISIT_BOOL(CXXConstructExpr, is_list_initialization, 87, MX_APPLY_METHOD, IsListInitialization, bool, NthStmt) - MX_VISIT_BOOL(CXXConstructExpr, is_std_initializer_list_initialization, 88, MX_APPLY_METHOD, IsStdInitializerListInitialization, bool, NthStmt) - MX_VISIT_BOOL(CXXConstructExpr, requires_zero_initialization, 90, MX_APPLY_METHOD, RequiresZeroInitialization, bool, NthStmt) + MX_VISIT_ENTITY_LIST(CXXConstructExpr, arguments, 16, MX_APPLY_METHOD, Arguments, Expr, NthStmt) + MX_VISIT_ENUM(CXXConstructExpr, construction_kind, 90, MX_APPLY_METHOD, ConstructionKind, CXXConstructionKind, NthStmt) + MX_VISIT_ENTITY(CXXConstructExpr, constructor, 39, MX_APPLY_METHOD, Constructor, CXXConstructorDecl, NthStmt) + MX_VISIT_ENTITY(CXXConstructExpr, token, 40, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_TOKEN_RANGE(CXXConstructExpr, parenthesis_or_brace_range, 41, 42, NthStmt) + MX_VISIT_BOOL(CXXConstructExpr, had_multiple_candidates, 85, MX_APPLY_METHOD, HadMultipleCandidates, bool, NthStmt) + MX_VISIT_BOOL(CXXConstructExpr, is_elidable, 86, MX_APPLY_METHOD, IsElidable, bool, NthStmt) + MX_VISIT_BOOL(CXXConstructExpr, is_immediate_escalating, 87, MX_APPLY_METHOD, IsImmediateEscalating, bool, NthStmt) + MX_VISIT_BOOL(CXXConstructExpr, is_list_initialization, 88, MX_APPLY_METHOD, IsListInitialization, bool, NthStmt) + MX_VISIT_BOOL(CXXConstructExpr, is_std_initializer_list_initialization, 89, MX_APPLY_METHOD, IsStdInitializerListInitialization, bool, NthStmt) + MX_VISIT_BOOL(CXXConstructExpr, requires_zero_initialization, 91, MX_APPLY_METHOD, RequiresZeroInitialization, bool, NthStmt) MX_EXIT_VISIT_CXXConstructExpr MX_END_VISIT_STMT(CXXConstructExpr) @@ -16750,8 +16754,8 @@ MX_END_VISIT_STMT(CXXTemporaryObjectExpr) MX_BEGIN_VISIT_STMT(CXXBoolLiteralExpr) MX_ENTER_VISIT_CXXBoolLiteralExpr MX_VISIT_BASE(CXXBoolLiteralExpr, Expr) - MX_VISIT_ENTITY(CXXBoolLiteralExpr, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_BOOL(CXXBoolLiteralExpr, value, 84, MX_APPLY_METHOD, Value, bool, NthStmt) + MX_VISIT_ENTITY(CXXBoolLiteralExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_BOOL(CXXBoolLiteralExpr, value, 85, MX_APPLY_METHOD, Value, bool, NthStmt) MX_EXIT_VISIT_CXXBoolLiteralExpr MX_END_VISIT_STMT(CXXBoolLiteralExpr) @@ -16765,7 +16769,7 @@ MX_END_VISIT_STMT(CXXBoolLiteralExpr) MX_BEGIN_VISIT_STMT(CXXBindTemporaryExpr) MX_ENTER_VISIT_CXXBindTemporaryExpr MX_VISIT_BASE(CXXBindTemporaryExpr, Expr) - MX_VISIT_ENTITY(CXXBindTemporaryExpr, sub_expression, 38, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(CXXBindTemporaryExpr, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) MX_EXIT_VISIT_CXXBindTemporaryExpr MX_END_VISIT_STMT(CXXBindTemporaryExpr) @@ -16779,10 +16783,10 @@ MX_END_VISIT_STMT(CXXBindTemporaryExpr) MX_BEGIN_VISIT_STMT(BlockExpr) MX_ENTER_VISIT_BlockExpr MX_VISIT_BASE(BlockExpr, Expr) - MX_VISIT_ENTITY(BlockExpr, block_declaration, 38, MX_APPLY_METHOD, BlockDeclaration, BlockDecl, NthStmt) - MX_VISIT_ENTITY(BlockExpr, body, 39, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(BlockExpr, caret_token, 40, MX_APPLY_METHOD, CaretToken, Token, NthStmt) - MX_VISIT_ENTITY(BlockExpr, function_type, 41, MX_APPLY_METHOD, FunctionType, FunctionProtoType, NthStmt) + MX_VISIT_ENTITY(BlockExpr, block_declaration, 39, MX_APPLY_METHOD, BlockDeclaration, BlockDecl, NthStmt) + MX_VISIT_ENTITY(BlockExpr, body, 40, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(BlockExpr, caret_token, 41, MX_APPLY_METHOD, CaretToken, Token, NthStmt) + MX_VISIT_ENTITY(BlockExpr, function_type, 42, MX_APPLY_METHOD, FunctionType, FunctionProtoType, NthStmt) MX_EXIT_VISIT_BlockExpr MX_END_VISIT_STMT(BlockExpr) @@ -16796,25 +16800,25 @@ MX_END_VISIT_STMT(BlockExpr) MX_BEGIN_VISIT_STMT(BinaryOperator) MX_ENTER_VISIT_BinaryOperator MX_VISIT_BASE(BinaryOperator, Expr) - MX_VISIT_ENTITY(BinaryOperator, lhs, 38, MX_APPLY_METHOD, LHS, Expr, NthStmt) - MX_VISIT_ENUM(BinaryOperator, opcode, 89, MX_APPLY_METHOD, Opcode, BinaryOperatorKind, NthStmt) - MX_VISIT_TEXT(BinaryOperator, opcode_string, 61, MX_APPLY_METHOD, OpcodeString, basic_string_view, NthStmt) - MX_VISIT_ENTITY(BinaryOperator, operator_token, 39, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(BinaryOperator, rhs, 40, MX_APPLY_METHOD, RHS, Expr, NthStmt) - MX_VISIT_BOOL(BinaryOperator, has_stored_fp_features, 84, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_additive_operation, 85, MX_APPLY_METHOD, IsAdditiveOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_assignment_operation, 86, MX_APPLY_METHOD, IsAssignmentOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_bitwise_operation, 87, MX_APPLY_METHOD, IsBitwiseOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_comma_operation, 88, MX_APPLY_METHOD, IsCommaOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_comparison_operation, 90, MX_APPLY_METHOD, IsComparisonOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_compound_assignment_operation, 92, MX_APPLY_METHOD, IsCompoundAssignmentOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_equality_operation, 93, MX_APPLY_METHOD, IsEqualityOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_logical_operation, 94, MX_APPLY_METHOD, IsLogicalOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_multiplicative_operation, 95, MX_APPLY_METHOD, IsMultiplicativeOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_pointer_memory_operation, 96, MX_APPLY_METHOD, IsPointerMemoryOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_relational_operation, 97, MX_APPLY_METHOD, IsRelationalOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_shift_assign_operation, 98, MX_APPLY_METHOD, IsShiftAssignOperation, bool, NthStmt) - MX_VISIT_BOOL(BinaryOperator, is_shift_operation, 99, MX_APPLY_METHOD, IsShiftOperation, bool, NthStmt) + MX_VISIT_ENTITY(BinaryOperator, lhs, 39, MX_APPLY_METHOD, LHS, Expr, NthStmt) + MX_VISIT_ENUM(BinaryOperator, opcode, 90, MX_APPLY_METHOD, Opcode, BinaryOperatorKind, NthStmt) + MX_VISIT_TEXT(BinaryOperator, opcode_string, 62, MX_APPLY_METHOD, OpcodeString, basic_string_view, NthStmt) + MX_VISIT_ENTITY(BinaryOperator, operator_token, 40, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(BinaryOperator, rhs, 41, MX_APPLY_METHOD, RHS, Expr, NthStmt) + MX_VISIT_BOOL(BinaryOperator, has_stored_fp_features, 85, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_additive_operation, 86, MX_APPLY_METHOD, IsAdditiveOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_assignment_operation, 87, MX_APPLY_METHOD, IsAssignmentOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_bitwise_operation, 88, MX_APPLY_METHOD, IsBitwiseOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_comma_operation, 89, MX_APPLY_METHOD, IsCommaOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_comparison_operation, 91, MX_APPLY_METHOD, IsComparisonOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_compound_assignment_operation, 93, MX_APPLY_METHOD, IsCompoundAssignmentOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_equality_operation, 94, MX_APPLY_METHOD, IsEqualityOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_logical_operation, 95, MX_APPLY_METHOD, IsLogicalOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_multiplicative_operation, 96, MX_APPLY_METHOD, IsMultiplicativeOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_pointer_memory_operation, 97, MX_APPLY_METHOD, IsPointerMemoryOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_relational_operation, 98, MX_APPLY_METHOD, IsRelationalOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_shift_assign_operation, 99, MX_APPLY_METHOD, IsShiftAssignOperation, bool, NthStmt) + MX_VISIT_BOOL(BinaryOperator, is_shift_operation, 100, MX_APPLY_METHOD, IsShiftOperation, bool, NthStmt) MX_EXIT_VISIT_BinaryOperator MX_END_VISIT_STMT(BinaryOperator) @@ -16828,8 +16832,8 @@ MX_END_VISIT_STMT(BinaryOperator) MX_BEGIN_VISIT_STMT(CompoundAssignOperator) MX_ENTER_VISIT_CompoundAssignOperator MX_VISIT_BASE(CompoundAssignOperator, BinaryOperator) - MX_VISIT_ENTITY(CompoundAssignOperator, computation_lhs_type, 41, MX_APPLY_METHOD, ComputationLHSType, Type, NthStmt) - MX_VISIT_ENTITY(CompoundAssignOperator, computation_result_type, 42, MX_APPLY_METHOD, ComputationResultType, Type, NthStmt) + MX_VISIT_ENTITY(CompoundAssignOperator, computation_lhs_type, 42, MX_APPLY_METHOD, ComputationLHSType, Type, NthStmt) + MX_VISIT_ENTITY(CompoundAssignOperator, computation_result_type, 43, MX_APPLY_METHOD, ComputationResultType, Type, NthStmt) MX_EXIT_VISIT_CompoundAssignOperator MX_END_VISIT_STMT(CompoundAssignOperator) @@ -16843,22 +16847,22 @@ MX_END_VISIT_STMT(CompoundAssignOperator) MX_BEGIN_VISIT_STMT(AtomicExpr) MX_ENTER_VISIT_AtomicExpr MX_VISIT_BASE(AtomicExpr, Expr) - MX_VISIT_ENTITY(AtomicExpr, builtin_token, 38, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) - MX_VISIT_ENUM(AtomicExpr, operation, 89, MX_APPLY_METHOD, Operation, AtomicExprAtomicOp, NthStmt) - MX_VISIT_TEXT(AtomicExpr, operation_as_string, 61, MX_APPLY_METHOD, OperationAsString, basic_string_view, NthStmt) - MX_VISIT_ENTITY(AtomicExpr, order, 39, MX_APPLY_METHOD, Order, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, order_fail, 40, MX_APPLY_METHOD, OrderFail, Expr, NthStmt) - MX_VISIT_ENTITY(AtomicExpr, pointer, 41, MX_APPLY_METHOD, Pointer, Expr, NthStmt) - MX_VISIT_ENTITY(AtomicExpr, r_paren_token, 42, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, scope, 43, MX_APPLY_METHOD, Scope, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, value1, 44, MX_APPLY_METHOD, Value1, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, value2, 45, MX_APPLY_METHOD, Value2, Expr, NthStmt) - MX_VISIT_ENTITY(AtomicExpr, value_type, 46, MX_APPLY_METHOD, ValueType, Type, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, weak, 47, MX_APPLY_METHOD, Weak, Expr, NthStmt) - MX_VISIT_BOOL(AtomicExpr, is_cmp_x_chg, 84, MX_APPLY_METHOD, IsCmpXChg, bool, NthStmt) - MX_VISIT_BOOL(AtomicExpr, is_open_cl, 85, MX_APPLY_METHOD, IsOpenCL, bool, NthStmt) - MX_VISIT_BOOL(AtomicExpr, is_volatile, 86, MX_APPLY_METHOD, IsVolatile, bool, NthStmt) - MX_VISIT_ENTITY_LIST(AtomicExpr, sub_expressions, 15, MX_APPLY_METHOD, SubExpressions, Expr, NthStmt) + MX_VISIT_ENTITY(AtomicExpr, builtin_token, 39, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) + MX_VISIT_ENUM(AtomicExpr, operation, 90, MX_APPLY_METHOD, Operation, AtomicExprAtomicOp, NthStmt) + MX_VISIT_TEXT(AtomicExpr, operation_as_string, 62, MX_APPLY_METHOD, OperationAsString, basic_string_view, NthStmt) + MX_VISIT_ENTITY(AtomicExpr, order, 40, MX_APPLY_METHOD, Order, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, order_fail, 41, MX_APPLY_METHOD, OrderFail, Expr, NthStmt) + MX_VISIT_ENTITY(AtomicExpr, pointer, 42, MX_APPLY_METHOD, Pointer, Expr, NthStmt) + MX_VISIT_ENTITY(AtomicExpr, r_paren_token, 43, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, scope, 44, MX_APPLY_METHOD, Scope, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, value1, 45, MX_APPLY_METHOD, Value1, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, value2, 46, MX_APPLY_METHOD, Value2, Expr, NthStmt) + MX_VISIT_ENTITY(AtomicExpr, value_type, 47, MX_APPLY_METHOD, ValueType, Type, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(AtomicExpr, weak, 48, MX_APPLY_METHOD, Weak, Expr, NthStmt) + MX_VISIT_BOOL(AtomicExpr, is_cmp_x_chg, 85, MX_APPLY_METHOD, IsCmpXChg, bool, NthStmt) + MX_VISIT_BOOL(AtomicExpr, is_open_cl, 86, MX_APPLY_METHOD, IsOpenCL, bool, NthStmt) + MX_VISIT_BOOL(AtomicExpr, is_volatile, 87, MX_APPLY_METHOD, IsVolatile, bool, NthStmt) + MX_VISIT_ENTITY_LIST(AtomicExpr, sub_expressions, 16, MX_APPLY_METHOD, SubExpressions, Expr, NthStmt) MX_EXIT_VISIT_AtomicExpr MX_END_VISIT_STMT(AtomicExpr) @@ -16872,9 +16876,9 @@ MX_END_VISIT_STMT(AtomicExpr) MX_BEGIN_VISIT_STMT(AsTypeExpr) MX_ENTER_VISIT_AsTypeExpr MX_VISIT_BASE(AsTypeExpr, Expr) - MX_VISIT_ENTITY(AsTypeExpr, builtin_token, 38, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) - MX_VISIT_ENTITY(AsTypeExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(AsTypeExpr, src_expression, 40, MX_APPLY_METHOD, SrcExpression, Expr, NthStmt) + MX_VISIT_ENTITY(AsTypeExpr, builtin_token, 39, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) + MX_VISIT_ENTITY(AsTypeExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(AsTypeExpr, src_expression, 41, MX_APPLY_METHOD, SrcExpression, Expr, NthStmt) MX_EXIT_VISIT_AsTypeExpr MX_END_VISIT_STMT(AsTypeExpr) @@ -16888,10 +16892,10 @@ MX_END_VISIT_STMT(AsTypeExpr) MX_BEGIN_VISIT_STMT(ArrayTypeTraitExpr) MX_ENTER_VISIT_ArrayTypeTraitExpr MX_VISIT_BASE(ArrayTypeTraitExpr, Expr) - MX_VISIT_ENTITY(ArrayTypeTraitExpr, dimension_expression, 38, MX_APPLY_METHOD, DimensionExpression, Expr, NthStmt) - MX_VISIT_ENTITY(ArrayTypeTraitExpr, queried_type, 39, MX_APPLY_METHOD, QueriedType, Type, NthStmt) - MX_VISIT_ENUM(ArrayTypeTraitExpr, trait, 89, MX_APPLY_METHOD, Trait, ArrayTypeTrait, NthStmt) - MX_VISIT_INT(ArrayTypeTraitExpr, value, 40, MX_APPLY_METHOD, Value, uint64_t, NthStmt) + MX_VISIT_ENTITY(ArrayTypeTraitExpr, dimension_expression, 39, MX_APPLY_METHOD, DimensionExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ArrayTypeTraitExpr, queried_type, 40, MX_APPLY_METHOD, QueriedType, Type, NthStmt) + MX_VISIT_ENUM(ArrayTypeTraitExpr, trait, 90, MX_APPLY_METHOD, Trait, ArrayTypeTrait, NthStmt) + MX_VISIT_INT(ArrayTypeTraitExpr, value, 41, MX_APPLY_METHOD, Value, uint64_t, NthStmt) MX_EXIT_VISIT_ArrayTypeTraitExpr MX_END_VISIT_STMT(ArrayTypeTraitExpr) @@ -16905,11 +16909,11 @@ MX_END_VISIT_STMT(ArrayTypeTraitExpr) MX_BEGIN_VISIT_STMT(ArraySubscriptExpr) MX_ENTER_VISIT_ArraySubscriptExpr MX_VISIT_BASE(ArraySubscriptExpr, Expr) - MX_VISIT_ENTITY(ArraySubscriptExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(ArraySubscriptExpr, index, 39, MX_APPLY_METHOD, Index, Expr, NthStmt) - MX_VISIT_ENTITY(ArraySubscriptExpr, lhs, 40, MX_APPLY_METHOD, LHS, Expr, NthStmt) - MX_VISIT_ENTITY(ArraySubscriptExpr, r_bracket_token, 41, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) - MX_VISIT_ENTITY(ArraySubscriptExpr, rhs, 42, MX_APPLY_METHOD, RHS, Expr, NthStmt) + MX_VISIT_ENTITY(ArraySubscriptExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(ArraySubscriptExpr, index, 40, MX_APPLY_METHOD, Index, Expr, NthStmt) + MX_VISIT_ENTITY(ArraySubscriptExpr, lhs, 41, MX_APPLY_METHOD, LHS, Expr, NthStmt) + MX_VISIT_ENTITY(ArraySubscriptExpr, r_bracket_token, 42, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) + MX_VISIT_ENTITY(ArraySubscriptExpr, rhs, 43, MX_APPLY_METHOD, RHS, Expr, NthStmt) MX_EXIT_VISIT_ArraySubscriptExpr MX_END_VISIT_STMT(ArraySubscriptExpr) @@ -16923,8 +16927,8 @@ MX_END_VISIT_STMT(ArraySubscriptExpr) MX_BEGIN_VISIT_STMT(ArrayInitLoopExpr) MX_ENTER_VISIT_ArrayInitLoopExpr MX_VISIT_BASE(ArrayInitLoopExpr, Expr) - MX_VISIT_ENTITY(ArrayInitLoopExpr, common_expression, 38, MX_APPLY_METHOD, CommonExpression, OpaqueValueExpr, NthStmt) - MX_VISIT_ENTITY(ArrayInitLoopExpr, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ArrayInitLoopExpr, common_expression, 39, MX_APPLY_METHOD, CommonExpression, OpaqueValueExpr, NthStmt) + MX_VISIT_ENTITY(ArrayInitLoopExpr, sub_expression, 40, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) MX_EXIT_VISIT_ArrayInitLoopExpr MX_END_VISIT_STMT(ArrayInitLoopExpr) @@ -16951,9 +16955,9 @@ MX_END_VISIT_STMT(ArrayInitIndexExpr) MX_BEGIN_VISIT_STMT(AddrLabelExpr) MX_ENTER_VISIT_AddrLabelExpr MX_VISIT_BASE(AddrLabelExpr, Expr) - MX_VISIT_ENTITY(AddrLabelExpr, amp_amp_token, 38, MX_APPLY_METHOD, AmpAmpToken, Token, NthStmt) - MX_VISIT_ENTITY(AddrLabelExpr, label, 39, MX_APPLY_METHOD, Label, LabelDecl, NthStmt) - MX_VISIT_ENTITY(AddrLabelExpr, label_token, 40, MX_APPLY_METHOD, LabelToken, Token, NthStmt) + MX_VISIT_ENTITY(AddrLabelExpr, amp_amp_token, 39, MX_APPLY_METHOD, AmpAmpToken, Token, NthStmt) + MX_VISIT_ENTITY(AddrLabelExpr, label, 40, MX_APPLY_METHOD, Label, LabelDecl, NthStmt) + MX_VISIT_ENTITY(AddrLabelExpr, label_token, 41, MX_APPLY_METHOD, LabelToken, Token, NthStmt) MX_EXIT_VISIT_AddrLabelExpr MX_END_VISIT_STMT(AddrLabelExpr) @@ -16967,11 +16971,11 @@ MX_END_VISIT_STMT(AddrLabelExpr) MX_BEGIN_VISIT_ABSTRACT_STMT(AbstractConditionalOperator) MX_ENTER_VISIT_AbstractConditionalOperator MX_VISIT_BASE(AbstractConditionalOperator, Expr) - MX_VISIT_ENTITY(AbstractConditionalOperator, colon_token, 38, MX_APPLY_METHOD, ColonToken, Token, NthStmt) - MX_VISIT_ENTITY(AbstractConditionalOperator, condition, 39, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_ENTITY(AbstractConditionalOperator, false_expression, 40, MX_APPLY_METHOD, FalseExpression, Expr, NthStmt) - MX_VISIT_ENTITY(AbstractConditionalOperator, question_token, 41, MX_APPLY_METHOD, QuestionToken, Token, NthStmt) - MX_VISIT_ENTITY(AbstractConditionalOperator, true_expression, 42, MX_APPLY_METHOD, TrueExpression, Expr, NthStmt) + MX_VISIT_ENTITY(AbstractConditionalOperator, colon_token, 39, MX_APPLY_METHOD, ColonToken, Token, NthStmt) + MX_VISIT_ENTITY(AbstractConditionalOperator, condition, 40, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_ENTITY(AbstractConditionalOperator, false_expression, 41, MX_APPLY_METHOD, FalseExpression, Expr, NthStmt) + MX_VISIT_ENTITY(AbstractConditionalOperator, question_token, 42, MX_APPLY_METHOD, QuestionToken, Token, NthStmt) + MX_VISIT_ENTITY(AbstractConditionalOperator, true_expression, 43, MX_APPLY_METHOD, TrueExpression, Expr, NthStmt) MX_EXIT_VISIT_AbstractConditionalOperator MX_END_VISIT_STMT(AbstractConditionalOperator) @@ -16985,8 +16989,8 @@ MX_END_VISIT_STMT(AbstractConditionalOperator) MX_BEGIN_VISIT_STMT(ConditionalOperator) MX_ENTER_VISIT_ConditionalOperator MX_VISIT_BASE(ConditionalOperator, AbstractConditionalOperator) - MX_VISIT_ENTITY(ConditionalOperator, lhs, 43, MX_APPLY_METHOD, LHS, Expr, NthStmt) - MX_VISIT_ENTITY(ConditionalOperator, rhs, 44, MX_APPLY_METHOD, RHS, Expr, NthStmt) + MX_VISIT_ENTITY(ConditionalOperator, lhs, 44, MX_APPLY_METHOD, LHS, Expr, NthStmt) + MX_VISIT_ENTITY(ConditionalOperator, rhs, 45, MX_APPLY_METHOD, RHS, Expr, NthStmt) MX_EXIT_VISIT_ConditionalOperator MX_END_VISIT_STMT(ConditionalOperator) @@ -17000,8 +17004,8 @@ MX_END_VISIT_STMT(ConditionalOperator) MX_BEGIN_VISIT_STMT(BinaryConditionalOperator) MX_ENTER_VISIT_BinaryConditionalOperator MX_VISIT_BASE(BinaryConditionalOperator, AbstractConditionalOperator) - MX_VISIT_ENTITY(BinaryConditionalOperator, common, 43, MX_APPLY_METHOD, Common, Expr, NthStmt) - MX_VISIT_ENTITY(BinaryConditionalOperator, opaque_value, 44, MX_APPLY_METHOD, OpaqueValue, OpaqueValueExpr, NthStmt) + MX_VISIT_ENTITY(BinaryConditionalOperator, common, 44, MX_APPLY_METHOD, Common, Expr, NthStmt) + MX_VISIT_ENTITY(BinaryConditionalOperator, opaque_value, 45, MX_APPLY_METHOD, OpaqueValue, OpaqueValueExpr, NthStmt) MX_EXIT_VISIT_BinaryConditionalOperator MX_END_VISIT_STMT(BinaryConditionalOperator) @@ -17015,10 +17019,10 @@ MX_END_VISIT_STMT(BinaryConditionalOperator) MX_BEGIN_VISIT_STMT(VAArgExpr) MX_ENTER_VISIT_VAArgExpr MX_VISIT_BASE(VAArgExpr, Expr) - MX_VISIT_ENTITY(VAArgExpr, builtin_token, 38, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) - MX_VISIT_ENTITY(VAArgExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(VAArgExpr, sub_expression, 40, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) - MX_VISIT_BOOL(VAArgExpr, is_microsoft_abi, 84, MX_APPLY_METHOD, IsMicrosoftABI, bool, NthStmt) + MX_VISIT_ENTITY(VAArgExpr, builtin_token, 39, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) + MX_VISIT_ENTITY(VAArgExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(VAArgExpr, sub_expression, 41, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_BOOL(VAArgExpr, is_microsoft_abi, 85, MX_APPLY_METHOD, IsMicrosoftABI, bool, NthStmt) MX_EXIT_VISIT_VAArgExpr MX_END_VISIT_STMT(VAArgExpr) @@ -17032,17 +17036,17 @@ MX_END_VISIT_STMT(VAArgExpr) MX_BEGIN_VISIT_STMT(UnaryOperator) MX_ENTER_VISIT_UnaryOperator MX_VISIT_BASE(UnaryOperator, Expr) - MX_VISIT_BOOL(UnaryOperator, can_overflow, 84, MX_APPLY_METHOD, CanOverflow, bool, NthStmt) - MX_VISIT_ENUM(UnaryOperator, opcode, 89, MX_APPLY_METHOD, Opcode, UnaryOperatorKind, NthStmt) - MX_VISIT_ENTITY(UnaryOperator, operator_token, 38, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(UnaryOperator, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) - MX_VISIT_BOOL(UnaryOperator, has_stored_fp_features, 85, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) - MX_VISIT_BOOL(UnaryOperator, is_arithmetic_operation, 86, MX_APPLY_METHOD, IsArithmeticOperation, bool, NthStmt) - MX_VISIT_BOOL(UnaryOperator, is_decrement_operation, 87, MX_APPLY_METHOD, IsDecrementOperation, bool, NthStmt) - MX_VISIT_BOOL(UnaryOperator, is_increment_decrement_operation, 88, MX_APPLY_METHOD, IsIncrementDecrementOperation, bool, NthStmt) - MX_VISIT_BOOL(UnaryOperator, is_increment_operation, 90, MX_APPLY_METHOD, IsIncrementOperation, bool, NthStmt) - MX_VISIT_BOOL(UnaryOperator, is_postfix, 92, MX_APPLY_METHOD, IsPostfix, bool, NthStmt) - MX_VISIT_BOOL(UnaryOperator, is_prefix, 93, MX_APPLY_METHOD, IsPrefix, bool, NthStmt) + MX_VISIT_BOOL(UnaryOperator, can_overflow, 85, MX_APPLY_METHOD, CanOverflow, bool, NthStmt) + MX_VISIT_ENUM(UnaryOperator, opcode, 90, MX_APPLY_METHOD, Opcode, UnaryOperatorKind, NthStmt) + MX_VISIT_ENTITY(UnaryOperator, operator_token, 39, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(UnaryOperator, sub_expression, 40, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_BOOL(UnaryOperator, has_stored_fp_features, 86, MX_APPLY_METHOD, HasStoredFPFeatures, bool, NthStmt) + MX_VISIT_BOOL(UnaryOperator, is_arithmetic_operation, 87, MX_APPLY_METHOD, IsArithmeticOperation, bool, NthStmt) + MX_VISIT_BOOL(UnaryOperator, is_decrement_operation, 88, MX_APPLY_METHOD, IsDecrementOperation, bool, NthStmt) + MX_VISIT_BOOL(UnaryOperator, is_increment_decrement_operation, 89, MX_APPLY_METHOD, IsIncrementDecrementOperation, bool, NthStmt) + MX_VISIT_BOOL(UnaryOperator, is_increment_operation, 91, MX_APPLY_METHOD, IsIncrementOperation, bool, NthStmt) + MX_VISIT_BOOL(UnaryOperator, is_postfix, 93, MX_APPLY_METHOD, IsPostfix, bool, NthStmt) + MX_VISIT_BOOL(UnaryOperator, is_prefix, 94, MX_APPLY_METHOD, IsPrefix, bool, NthStmt) MX_EXIT_VISIT_UnaryOperator MX_END_VISIT_STMT(UnaryOperator) @@ -17056,13 +17060,13 @@ MX_END_VISIT_STMT(UnaryOperator) MX_BEGIN_VISIT_STMT(UnaryExprOrTypeTraitExpr) MX_ENTER_VISIT_UnaryExprOrTypeTraitExpr MX_VISIT_BASE(UnaryExprOrTypeTraitExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(UnaryExprOrTypeTraitExpr, argument_expression, 38, MX_APPLY_METHOD, ArgumentExpression, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(UnaryExprOrTypeTraitExpr, argument_type, 39, MX_APPLY_METHOD, ArgumentType, Type, NthStmt) - MX_VISIT_ENUM(UnaryExprOrTypeTraitExpr, keyword_kind, 89, MX_APPLY_METHOD, KeywordKind, UnaryExprOrTypeTrait, NthStmt) - MX_VISIT_ENTITY(UnaryExprOrTypeTraitExpr, operator_token, 40, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(UnaryExprOrTypeTraitExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(UnaryExprOrTypeTraitExpr, type_of_argument, 42, MX_APPLY_METHOD, TypeOfArgument, Type, NthStmt) - MX_VISIT_BOOL(UnaryExprOrTypeTraitExpr, is_argument_type, 84, MX_APPLY_METHOD, IsArgumentType, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(UnaryExprOrTypeTraitExpr, argument_expression, 39, MX_APPLY_METHOD, ArgumentExpression, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(UnaryExprOrTypeTraitExpr, argument_type, 40, MX_APPLY_METHOD, ArgumentType, Type, NthStmt) + MX_VISIT_ENUM(UnaryExprOrTypeTraitExpr, keyword_kind, 90, MX_APPLY_METHOD, KeywordKind, UnaryExprOrTypeTrait, NthStmt) + MX_VISIT_ENTITY(UnaryExprOrTypeTraitExpr, operator_token, 41, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(UnaryExprOrTypeTraitExpr, r_paren_token, 42, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(UnaryExprOrTypeTraitExpr, type_of_argument, 43, MX_APPLY_METHOD, TypeOfArgument, Type, NthStmt) + MX_VISIT_BOOL(UnaryExprOrTypeTraitExpr, is_argument_type, 85, MX_APPLY_METHOD, IsArgumentType, bool, NthStmt) MX_EXIT_VISIT_UnaryExprOrTypeTraitExpr MX_END_VISIT_STMT(UnaryExprOrTypeTraitExpr) @@ -17089,9 +17093,9 @@ MX_END_VISIT_STMT(TypoExpr) MX_BEGIN_VISIT_STMT(TypeTraitExpr) MX_ENTER_VISIT_TypeTraitExpr MX_VISIT_BASE(TypeTraitExpr, Expr) - MX_VISIT_ENUM(TypeTraitExpr, trait, 89, MX_APPLY_METHOD, Trait, TypeTrait, NthStmt) - MX_VISIT_OPTIONAL_BOOL(TypeTraitExpr, value, 84, MX_APPLY_METHOD, Value, bool, NthStmt) - MX_VISIT_ENTITY_LIST(TypeTraitExpr, arguments, 15, MX_APPLY_METHOD, Arguments, Type, NthStmt) + MX_VISIT_ENUM(TypeTraitExpr, trait, 90, MX_APPLY_METHOD, Trait, TypeTrait, NthStmt) + MX_VISIT_OPTIONAL_BOOL(TypeTraitExpr, value, 85, MX_APPLY_METHOD, Value, bool, NthStmt) + MX_VISIT_ENTITY_LIST(TypeTraitExpr, arguments, 16, MX_APPLY_METHOD, Arguments, Type, NthStmt) MX_EXIT_VISIT_TypeTraitExpr MX_END_VISIT_STMT(TypeTraitExpr) @@ -17105,10 +17109,10 @@ MX_END_VISIT_STMT(TypeTraitExpr) MX_BEGIN_VISIT_STMT(SubstNonTypeTemplateParmPackExpr) MX_ENTER_VISIT_SubstNonTypeTemplateParmPackExpr MX_VISIT_BASE(SubstNonTypeTemplateParmPackExpr, Expr) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmPackExpr, associated_declaration, 38, MX_APPLY_METHOD, AssociatedDeclaration, Decl, NthStmt) - MX_VISIT_INT(SubstNonTypeTemplateParmPackExpr, index, 26, MX_APPLY_METHOD, Index, uint32_t, NthStmt) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmPackExpr, parameter_pack, 39, MX_APPLY_METHOD, ParameterPack, NonTypeTemplateParmDecl, NthStmt) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmPackExpr, parameter_pack_token, 40, MX_APPLY_METHOD, ParameterPackToken, Token, NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmPackExpr, associated_declaration, 39, MX_APPLY_METHOD, AssociatedDeclaration, Decl, NthStmt) + MX_VISIT_INT(SubstNonTypeTemplateParmPackExpr, index, 27, MX_APPLY_METHOD, Index, uint32_t, NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmPackExpr, parameter_pack, 40, MX_APPLY_METHOD, ParameterPack, NonTypeTemplateParmDecl, NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmPackExpr, parameter_pack_token, 41, MX_APPLY_METHOD, ParameterPackToken, Token, NthStmt) MX_EXIT_VISIT_SubstNonTypeTemplateParmPackExpr MX_END_VISIT_STMT(SubstNonTypeTemplateParmPackExpr) @@ -17122,14 +17126,14 @@ MX_END_VISIT_STMT(SubstNonTypeTemplateParmPackExpr) MX_BEGIN_VISIT_STMT(SubstNonTypeTemplateParmExpr) MX_ENTER_VISIT_SubstNonTypeTemplateParmExpr MX_VISIT_BASE(SubstNonTypeTemplateParmExpr, Expr) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, associated_declaration, 38, MX_APPLY_METHOD, AssociatedDeclaration, Decl, NthStmt) - MX_VISIT_INT(SubstNonTypeTemplateParmExpr, index, 26, MX_APPLY_METHOD, Index, uint32_t, NthStmt) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, name_token, 39, MX_APPLY_METHOD, NameToken, Token, NthStmt) - MX_VISIT_OPTIONAL_INT(SubstNonTypeTemplateParmExpr, pack_index, 100, MX_APPLY_METHOD, PackIndex, , NthStmt) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, parameter, 40, MX_APPLY_METHOD, Parameter, NonTypeTemplateParmDecl, NthStmt) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, parameter_type, 41, MX_APPLY_METHOD, ParameterType, Type, NthStmt) - MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, replacement, 42, MX_APPLY_METHOD, Replacement, Expr, NthStmt) - MX_VISIT_BOOL(SubstNonTypeTemplateParmExpr, is_reference_parameter, 85, MX_APPLY_METHOD, IsReferenceParameter, bool, NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, associated_declaration, 39, MX_APPLY_METHOD, AssociatedDeclaration, Decl, NthStmt) + MX_VISIT_INT(SubstNonTypeTemplateParmExpr, index, 27, MX_APPLY_METHOD, Index, uint32_t, NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, name_token, 40, MX_APPLY_METHOD, NameToken, Token, NthStmt) + MX_VISIT_OPTIONAL_INT(SubstNonTypeTemplateParmExpr, pack_index, 101, MX_APPLY_METHOD, PackIndex, , NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, parameter, 41, MX_APPLY_METHOD, Parameter, NonTypeTemplateParmDecl, NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, parameter_type, 42, MX_APPLY_METHOD, ParameterType, Type, NthStmt) + MX_VISIT_ENTITY(SubstNonTypeTemplateParmExpr, replacement, 43, MX_APPLY_METHOD, Replacement, Expr, NthStmt) + MX_VISIT_BOOL(SubstNonTypeTemplateParmExpr, is_reference_parameter, 86, MX_APPLY_METHOD, IsReferenceParameter, bool, NthStmt) MX_EXIT_VISIT_SubstNonTypeTemplateParmExpr MX_END_VISIT_STMT(SubstNonTypeTemplateParmExpr) @@ -17143,22 +17147,22 @@ MX_END_VISIT_STMT(SubstNonTypeTemplateParmExpr) MX_BEGIN_VISIT_STMT(StringLiteral) MX_ENTER_VISIT_StringLiteral MX_VISIT_BASE(StringLiteral, Expr) - MX_VISIT_OPTIONAL_BOOL(StringLiteral, contains_non_ascii, 84, MX_APPLY_METHOD, ContainsNonAscii, bool, NthStmt) - MX_VISIT_OPTIONAL_BOOL(StringLiteral, contains_non_ascii_or_null, 86, MX_APPLY_METHOD, ContainsNonAsciiOrNull, bool, NthStmt) - MX_VISIT_INT(StringLiteral, byte_length, 26, MX_APPLY_METHOD, ByteLength, uint32_t, NthStmt) - MX_VISIT_TEXT(StringLiteral, bytes, 61, MX_APPLY_METHOD, Bytes, basic_string_view, NthStmt) - MX_VISIT_INT(StringLiteral, character_byte_width, 100, MX_APPLY_METHOD, CharacterByteWidth, uint32_t, NthStmt) - MX_VISIT_ENUM(StringLiteral, literal_kind, 89, MX_APPLY_METHOD, LiteralKind, StringLiteralKind, NthStmt) - MX_VISIT_INT(StringLiteral, length, 101, MX_APPLY_METHOD, Length, uint32_t, NthStmt) - MX_VISIT_INT(StringLiteral, num_concatenated, 102, MX_APPLY_METHOD, NumConcatenated, uint32_t, NthStmt) - MX_VISIT_OPTIONAL_TEXT(StringLiteral, string, 66, MX_APPLY_METHOD, String, basic_string_view, NthStmt) - MX_VISIT_BOOL(StringLiteral, is_ordinary, 90, MX_APPLY_METHOD, IsOrdinary, bool, NthStmt) - MX_VISIT_BOOL(StringLiteral, is_pascal, 92, MX_APPLY_METHOD, IsPascal, bool, NthStmt) - MX_VISIT_BOOL(StringLiteral, is_utf16, 93, MX_APPLY_METHOD, IsUTF16, bool, NthStmt) - MX_VISIT_BOOL(StringLiteral, is_utf32, 94, MX_APPLY_METHOD, IsUTF32, bool, NthStmt) - MX_VISIT_BOOL(StringLiteral, is_utf8, 95, MX_APPLY_METHOD, IsUTF8, bool, NthStmt) - MX_VISIT_BOOL(StringLiteral, is_unevaluated, 96, MX_APPLY_METHOD, IsUnevaluated, bool, NthStmt) - MX_VISIT_BOOL(StringLiteral, is_wide, 97, MX_APPLY_METHOD, IsWide, bool, NthStmt) + MX_VISIT_OPTIONAL_BOOL(StringLiteral, contains_non_ascii, 85, MX_APPLY_METHOD, ContainsNonAscii, bool, NthStmt) + MX_VISIT_OPTIONAL_BOOL(StringLiteral, contains_non_ascii_or_null, 87, MX_APPLY_METHOD, ContainsNonAsciiOrNull, bool, NthStmt) + MX_VISIT_INT(StringLiteral, byte_length, 27, MX_APPLY_METHOD, ByteLength, uint32_t, NthStmt) + MX_VISIT_TEXT(StringLiteral, bytes, 62, MX_APPLY_METHOD, Bytes, basic_string_view, NthStmt) + MX_VISIT_INT(StringLiteral, character_byte_width, 101, MX_APPLY_METHOD, CharacterByteWidth, uint32_t, NthStmt) + MX_VISIT_ENUM(StringLiteral, literal_kind, 90, MX_APPLY_METHOD, LiteralKind, StringLiteralKind, NthStmt) + MX_VISIT_INT(StringLiteral, length, 102, MX_APPLY_METHOD, Length, uint32_t, NthStmt) + MX_VISIT_INT(StringLiteral, num_concatenated, 103, MX_APPLY_METHOD, NumConcatenated, uint32_t, NthStmt) + MX_VISIT_OPTIONAL_TEXT(StringLiteral, string, 67, MX_APPLY_METHOD, String, basic_string_view, NthStmt) + MX_VISIT_BOOL(StringLiteral, is_ordinary, 91, MX_APPLY_METHOD, IsOrdinary, bool, NthStmt) + MX_VISIT_BOOL(StringLiteral, is_pascal, 93, MX_APPLY_METHOD, IsPascal, bool, NthStmt) + MX_VISIT_BOOL(StringLiteral, is_utf16, 94, MX_APPLY_METHOD, IsUTF16, bool, NthStmt) + MX_VISIT_BOOL(StringLiteral, is_utf32, 95, MX_APPLY_METHOD, IsUTF32, bool, NthStmt) + MX_VISIT_BOOL(StringLiteral, is_utf8, 96, MX_APPLY_METHOD, IsUTF8, bool, NthStmt) + MX_VISIT_BOOL(StringLiteral, is_unevaluated, 97, MX_APPLY_METHOD, IsUnevaluated, bool, NthStmt) + MX_VISIT_BOOL(StringLiteral, is_wide, 98, MX_APPLY_METHOD, IsWide, bool, NthStmt) MX_EXIT_VISIT_StringLiteral MX_END_VISIT_STMT(StringLiteral) @@ -17172,10 +17176,10 @@ MX_END_VISIT_STMT(StringLiteral) MX_BEGIN_VISIT_STMT(StmtExpr) MX_ENTER_VISIT_StmtExpr MX_VISIT_BASE(StmtExpr, Expr) - MX_VISIT_ENTITY(StmtExpr, l_paren_token, 38, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(StmtExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(StmtExpr, sub_statement, 40, MX_APPLY_METHOD, SubStatement, CompoundStmt, NthStmt) - MX_VISIT_INT(StmtExpr, template_depth, 26, MX_APPLY_METHOD, TemplateDepth, uint32_t, NthStmt) + MX_VISIT_ENTITY(StmtExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(StmtExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(StmtExpr, sub_statement, 41, MX_APPLY_METHOD, SubStatement, CompoundStmt, NthStmt) + MX_VISIT_INT(StmtExpr, template_depth, 27, MX_APPLY_METHOD, TemplateDepth, uint32_t, NthStmt) MX_EXIT_VISIT_StmtExpr MX_END_VISIT_STMT(StmtExpr) @@ -17189,10 +17193,10 @@ MX_END_VISIT_STMT(StmtExpr) MX_BEGIN_VISIT_STMT(SourceLocExpr) MX_ENTER_VISIT_SourceLocExpr MX_VISIT_BASE(SourceLocExpr, Expr) - MX_VISIT_TEXT(SourceLocExpr, builtin_string, 61, MX_APPLY_METHOD, BuiltinString, basic_string_view, NthStmt) - MX_VISIT_ENUM(SourceLocExpr, identifier_kind, 89, MX_APPLY_METHOD, IdentifierKind, SourceLocIdentKind, NthStmt) - MX_VISIT_ENTITY(SourceLocExpr, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_BOOL(SourceLocExpr, is_int_type, 84, MX_APPLY_METHOD, IsIntType, bool, NthStmt) + MX_VISIT_TEXT(SourceLocExpr, builtin_string, 62, MX_APPLY_METHOD, BuiltinString, basic_string_view, NthStmt) + MX_VISIT_ENUM(SourceLocExpr, identifier_kind, 90, MX_APPLY_METHOD, IdentifierKind, SourceLocIdentKind, NthStmt) + MX_VISIT_ENTITY(SourceLocExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_BOOL(SourceLocExpr, is_int_type, 85, MX_APPLY_METHOD, IsIntType, bool, NthStmt) MX_EXIT_VISIT_SourceLocExpr MX_END_VISIT_STMT(SourceLocExpr) @@ -17206,13 +17210,13 @@ MX_END_VISIT_STMT(SourceLocExpr) MX_BEGIN_VISIT_STMT(SizeOfPackExpr) MX_ENTER_VISIT_SizeOfPackExpr MX_VISIT_BASE(SizeOfPackExpr, Expr) - MX_VISIT_ENTITY(SizeOfPackExpr, operator_token, 38, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(SizeOfPackExpr, pack, 39, MX_APPLY_METHOD, Pack, NamedDecl, NthStmt) - MX_VISIT_OPTIONAL_INT(SizeOfPackExpr, pack_length, 26, MX_APPLY_METHOD, PackLength, , NthStmt) - MX_VISIT_ENTITY(SizeOfPackExpr, pack_token, 40, MX_APPLY_METHOD, PackToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY_LIST(SizeOfPackExpr, partial_arguments, 15, MX_APPLY_METHOD, PartialArguments, TemplateArgument, NthStmt) - MX_VISIT_ENTITY(SizeOfPackExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_BOOL(SizeOfPackExpr, is_partially_substituted, 86, MX_APPLY_METHOD, IsPartiallySubstituted, bool, NthStmt) + MX_VISIT_ENTITY(SizeOfPackExpr, operator_token, 39, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(SizeOfPackExpr, pack, 40, MX_APPLY_METHOD, Pack, NamedDecl, NthStmt) + MX_VISIT_OPTIONAL_INT(SizeOfPackExpr, pack_length, 27, MX_APPLY_METHOD, PackLength, , NthStmt) + MX_VISIT_ENTITY(SizeOfPackExpr, pack_token, 41, MX_APPLY_METHOD, PackToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY_LIST(SizeOfPackExpr, partial_arguments, 16, MX_APPLY_METHOD, PartialArguments, TemplateArgument, NthStmt) + MX_VISIT_ENTITY(SizeOfPackExpr, r_paren_token, 42, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_BOOL(SizeOfPackExpr, is_partially_substituted, 87, MX_APPLY_METHOD, IsPartiallySubstituted, bool, NthStmt) MX_EXIT_VISIT_SizeOfPackExpr MX_END_VISIT_STMT(SizeOfPackExpr) @@ -17226,8 +17230,8 @@ MX_END_VISIT_STMT(SizeOfPackExpr) MX_BEGIN_VISIT_STMT(ShuffleVectorExpr) MX_ENTER_VISIT_ShuffleVectorExpr MX_VISIT_BASE(ShuffleVectorExpr, Expr) - MX_VISIT_ENTITY(ShuffleVectorExpr, builtin_token, 38, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) - MX_VISIT_ENTITY(ShuffleVectorExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ShuffleVectorExpr, builtin_token, 39, MX_APPLY_METHOD, BuiltinToken, Token, NthStmt) + MX_VISIT_ENTITY(ShuffleVectorExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_ShuffleVectorExpr MX_END_VISIT_STMT(ShuffleVectorExpr) @@ -17241,10 +17245,10 @@ MX_END_VISIT_STMT(ShuffleVectorExpr) MX_BEGIN_VISIT_STMT(SYCLUniqueStableNameExpr) MX_ENTER_VISIT_SYCLUniqueStableNameExpr MX_VISIT_BASE(SYCLUniqueStableNameExpr, Expr) - MX_VISIT_TEXT(SYCLUniqueStableNameExpr, compute_name, 61, MX_APPLY_METHOD, ComputeName, basic_string, NthStmt) - MX_VISIT_ENTITY(SYCLUniqueStableNameExpr, l_paren_token, 38, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(SYCLUniqueStableNameExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_ENTITY(SYCLUniqueStableNameExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_TEXT(SYCLUniqueStableNameExpr, compute_name, 62, MX_APPLY_METHOD, ComputeName, basic_string, NthStmt) + MX_VISIT_ENTITY(SYCLUniqueStableNameExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(SYCLUniqueStableNameExpr, token, 40, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_ENTITY(SYCLUniqueStableNameExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_SYCLUniqueStableNameExpr MX_END_VISIT_STMT(SYCLUniqueStableNameExpr) @@ -17258,12 +17262,12 @@ MX_END_VISIT_STMT(SYCLUniqueStableNameExpr) MX_BEGIN_VISIT_STMT(RequiresExpr) MX_ENTER_VISIT_RequiresExpr MX_VISIT_BASE(RequiresExpr, Expr) - MX_VISIT_ENTITY(RequiresExpr, body, 38, MX_APPLY_METHOD, Body, RequiresExprBodyDecl, NthStmt) - MX_VISIT_ENTITY(RequiresExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY_LIST(RequiresExpr, local_parameters, 15, MX_APPLY_METHOD, LocalParameters, ParmVarDecl, NthStmt) - MX_VISIT_ENTITY(RequiresExpr, r_brace_token, 40, MX_APPLY_METHOD, RBraceToken, Token, NthStmt) - MX_VISIT_ENTITY(RequiresExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(RequiresExpr, requires_keyword_token, 42, MX_APPLY_METHOD, RequiresKeywordToken, Token, NthStmt) + MX_VISIT_ENTITY(RequiresExpr, body, 39, MX_APPLY_METHOD, Body, RequiresExprBodyDecl, NthStmt) + MX_VISIT_ENTITY(RequiresExpr, l_paren_token, 40, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY_LIST(RequiresExpr, local_parameters, 16, MX_APPLY_METHOD, LocalParameters, ParmVarDecl, NthStmt) + MX_VISIT_ENTITY(RequiresExpr, r_brace_token, 41, MX_APPLY_METHOD, RBraceToken, Token, NthStmt) + MX_VISIT_ENTITY(RequiresExpr, r_paren_token, 42, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(RequiresExpr, requires_keyword_token, 43, MX_APPLY_METHOD, RequiresKeywordToken, Token, NthStmt) MX_EXIT_VISIT_RequiresExpr MX_END_VISIT_STMT(RequiresExpr) @@ -17277,7 +17281,7 @@ MX_END_VISIT_STMT(RequiresExpr) MX_BEGIN_VISIT_STMT(RecoveryExpr) MX_ENTER_VISIT_RecoveryExpr MX_VISIT_BASE(RecoveryExpr, Expr) - MX_VISIT_ENTITY_LIST(RecoveryExpr, sub_expressions, 15, MX_APPLY_METHOD, SubExpressions, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(RecoveryExpr, sub_expressions, 16, MX_APPLY_METHOD, SubExpressions, Expr, NthStmt) MX_EXIT_VISIT_RecoveryExpr MX_END_VISIT_STMT(RecoveryExpr) @@ -17291,11 +17295,11 @@ MX_END_VISIT_STMT(RecoveryExpr) MX_BEGIN_VISIT_STMT(PseudoObjectExpr) MX_ENTER_VISIT_PseudoObjectExpr MX_VISIT_BASE(PseudoObjectExpr, Expr) - MX_VISIT_ENTITY(PseudoObjectExpr, result_expression, 38, MX_APPLY_METHOD, ResultExpression, Expr, NthStmt) - MX_VISIT_INT(PseudoObjectExpr, result_expression_index, 26, MX_APPLY_METHOD, ResultExpressionIndex, uint32_t, NthStmt) - MX_VISIT_ENTITY(PseudoObjectExpr, syntactic_form, 39, MX_APPLY_METHOD, SyntacticForm, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(PseudoObjectExpr, semantics, 15, MX_APPLY_METHOD, Semantics, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(PseudoObjectExpr, semantic_expressions, 27, MX_APPLY_METHOD, SemanticExpressions, Expr, NthStmt) + MX_VISIT_ENTITY(PseudoObjectExpr, result_expression, 39, MX_APPLY_METHOD, ResultExpression, Expr, NthStmt) + MX_VISIT_INT(PseudoObjectExpr, result_expression_index, 27, MX_APPLY_METHOD, ResultExpressionIndex, uint32_t, NthStmt) + MX_VISIT_ENTITY(PseudoObjectExpr, syntactic_form, 40, MX_APPLY_METHOD, SyntacticForm, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(PseudoObjectExpr, semantics, 16, MX_APPLY_METHOD, Semantics, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(PseudoObjectExpr, semantic_expressions, 28, MX_APPLY_METHOD, SemanticExpressions, Expr, NthStmt) MX_EXIT_VISIT_PseudoObjectExpr MX_END_VISIT_STMT(PseudoObjectExpr) @@ -17309,11 +17313,11 @@ MX_END_VISIT_STMT(PseudoObjectExpr) MX_BEGIN_VISIT_STMT(PredefinedExpr) MX_ENTER_VISIT_PredefinedExpr MX_VISIT_BASE(PredefinedExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(PredefinedExpr, function_name, 38, MX_APPLY_METHOD, FunctionName, StringLiteral, NthStmt) - MX_VISIT_ENUM(PredefinedExpr, identifier_kind, 89, MX_APPLY_METHOD, IdentifierKind, PredefinedIdentKind, NthStmt) - MX_VISIT_TEXT(PredefinedExpr, identifier_kind_name, 61, MX_APPLY_METHOD, IdentifierKindName, basic_string_view, NthStmt) - MX_VISIT_ENTITY(PredefinedExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_BOOL(PredefinedExpr, is_transparent, 84, MX_APPLY_METHOD, IsTransparent, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(PredefinedExpr, function_name, 39, MX_APPLY_METHOD, FunctionName, StringLiteral, NthStmt) + MX_VISIT_ENUM(PredefinedExpr, identifier_kind, 90, MX_APPLY_METHOD, IdentifierKind, PredefinedIdentKind, NthStmt) + MX_VISIT_TEXT(PredefinedExpr, identifier_kind_name, 62, MX_APPLY_METHOD, IdentifierKindName, basic_string_view, NthStmt) + MX_VISIT_ENTITY(PredefinedExpr, token, 40, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_BOOL(PredefinedExpr, is_transparent, 85, MX_APPLY_METHOD, IsTransparent, bool, NthStmt) MX_EXIT_VISIT_PredefinedExpr MX_END_VISIT_STMT(PredefinedExpr) @@ -17327,9 +17331,9 @@ MX_END_VISIT_STMT(PredefinedExpr) MX_BEGIN_VISIT_STMT(ParenListExpr) MX_ENTER_VISIT_ParenListExpr MX_VISIT_BASE(ParenListExpr, Expr) - MX_VISIT_ENTITY(ParenListExpr, l_paren_token, 38, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(ParenListExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY_LIST(ParenListExpr, expressions, 15, MX_APPLY_METHOD, Expressions, Expr, NthStmt) + MX_VISIT_ENTITY(ParenListExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ParenListExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY_LIST(ParenListExpr, expressions, 16, MX_APPLY_METHOD, Expressions, Expr, NthStmt) MX_EXIT_VISIT_ParenListExpr MX_END_VISIT_STMT(ParenListExpr) @@ -17343,9 +17347,9 @@ MX_END_VISIT_STMT(ParenListExpr) MX_BEGIN_VISIT_STMT(ParenExpr) MX_ENTER_VISIT_ParenExpr MX_VISIT_BASE(ParenExpr, Expr) - MX_VISIT_ENTITY(ParenExpr, l_paren_token, 38, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(ParenExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_ENTITY(ParenExpr, sub_expression, 40, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ParenExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ParenExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ParenExpr, sub_expression, 41, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) MX_EXIT_VISIT_ParenExpr MX_END_VISIT_STMT(ParenExpr) @@ -17359,8 +17363,8 @@ MX_END_VISIT_STMT(ParenExpr) MX_BEGIN_VISIT_STMT(PackExpansionExpr) MX_ENTER_VISIT_PackExpansionExpr MX_VISIT_BASE(PackExpansionExpr, Expr) - MX_VISIT_ENTITY(PackExpansionExpr, ellipsis_token, 38, MX_APPLY_METHOD, EllipsisToken, Token, NthStmt) - MX_VISIT_ENTITY(PackExpansionExpr, pattern, 39, MX_APPLY_METHOD, Pattern, Expr, NthStmt) + MX_VISIT_ENTITY(PackExpansionExpr, ellipsis_token, 39, MX_APPLY_METHOD, EllipsisToken, Token, NthStmt) + MX_VISIT_ENTITY(PackExpansionExpr, pattern, 40, MX_APPLY_METHOD, Pattern, Expr, NthStmt) MX_EXIT_VISIT_PackExpansionExpr MX_END_VISIT_STMT(PackExpansionExpr) @@ -17374,14 +17378,14 @@ MX_END_VISIT_STMT(PackExpansionExpr) MX_BEGIN_VISIT_ABSTRACT_STMT(OverloadExpr) MX_ENTER_VISIT_OverloadExpr MX_VISIT_BASE(OverloadExpr, Expr) - MX_VISIT_ENTITY_LIST(OverloadExpr, declarations, 15, MX_APPLY_METHOD, Declarations, NamedDecl, NthStmt) - MX_VISIT_ENTITY(OverloadExpr, l_angle_token, 38, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(OverloadExpr, name_token, 39, MX_APPLY_METHOD, NameToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(OverloadExpr, naming_class, 40, MX_APPLY_METHOD, NamingClass, CXXRecordDecl, NthStmt) - MX_VISIT_ENTITY(OverloadExpr, r_angle_token, 41, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(OverloadExpr, template_keyword_token, 42, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) - MX_VISIT_BOOL(OverloadExpr, has_explicit_template_arguments, 84, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) - MX_VISIT_BOOL(OverloadExpr, has_template_keyword, 85, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) + MX_VISIT_ENTITY_LIST(OverloadExpr, declarations, 16, MX_APPLY_METHOD, Declarations, NamedDecl, NthStmt) + MX_VISIT_ENTITY(OverloadExpr, l_angle_token, 39, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(OverloadExpr, name_token, 40, MX_APPLY_METHOD, NameToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(OverloadExpr, naming_class, 41, MX_APPLY_METHOD, NamingClass, CXXRecordDecl, NthStmt) + MX_VISIT_ENTITY(OverloadExpr, r_angle_token, 42, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(OverloadExpr, template_keyword_token, 43, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) + MX_VISIT_BOOL(OverloadExpr, has_explicit_template_arguments, 85, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) + MX_VISIT_BOOL(OverloadExpr, has_template_keyword, 86, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) MX_EXIT_VISIT_OverloadExpr MX_END_VISIT_STMT(OverloadExpr) @@ -17395,12 +17399,12 @@ MX_END_VISIT_STMT(OverloadExpr) MX_BEGIN_VISIT_STMT(UnresolvedMemberExpr) MX_ENTER_VISIT_UnresolvedMemberExpr MX_VISIT_BASE(UnresolvedMemberExpr, OverloadExpr) - MX_VISIT_ENTITY(UnresolvedMemberExpr, base_type, 43, MX_APPLY_METHOD, BaseType, Type, NthStmt) - MX_VISIT_ENTITY(UnresolvedMemberExpr, member_token, 44, MX_APPLY_METHOD, MemberToken, Token, NthStmt) - MX_VISIT_ENTITY(UnresolvedMemberExpr, operator_token, 45, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_BOOL(UnresolvedMemberExpr, has_unresolved_using, 86, MX_APPLY_METHOD, HasUnresolvedUsing, bool, NthStmt) - MX_VISIT_BOOL(UnresolvedMemberExpr, is_arrow, 87, MX_APPLY_METHOD, IsArrow, bool, NthStmt) - MX_VISIT_BOOL(UnresolvedMemberExpr, is_implicit_access, 88, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) + MX_VISIT_ENTITY(UnresolvedMemberExpr, base_type, 44, MX_APPLY_METHOD, BaseType, Type, NthStmt) + MX_VISIT_ENTITY(UnresolvedMemberExpr, member_token, 45, MX_APPLY_METHOD, MemberToken, Token, NthStmt) + MX_VISIT_ENTITY(UnresolvedMemberExpr, operator_token, 46, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_BOOL(UnresolvedMemberExpr, has_unresolved_using, 87, MX_APPLY_METHOD, HasUnresolvedUsing, bool, NthStmt) + MX_VISIT_BOOL(UnresolvedMemberExpr, is_arrow, 88, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_BOOL(UnresolvedMemberExpr, is_implicit_access, 89, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) MX_EXIT_VISIT_UnresolvedMemberExpr MX_END_VISIT_STMT(UnresolvedMemberExpr) @@ -17414,8 +17418,8 @@ MX_END_VISIT_STMT(UnresolvedMemberExpr) MX_BEGIN_VISIT_STMT(UnresolvedLookupExpr) MX_ENTER_VISIT_UnresolvedLookupExpr MX_VISIT_BASE(UnresolvedLookupExpr, OverloadExpr) - MX_VISIT_BOOL(UnresolvedLookupExpr, is_overloaded, 86, MX_APPLY_METHOD, IsOverloaded, bool, NthStmt) - MX_VISIT_BOOL(UnresolvedLookupExpr, requires_adl, 87, MX_APPLY_METHOD, RequiresADL, bool, NthStmt) + MX_VISIT_BOOL(UnresolvedLookupExpr, is_overloaded, 87, MX_APPLY_METHOD, IsOverloaded, bool, NthStmt) + MX_VISIT_BOOL(UnresolvedLookupExpr, requires_adl, 88, MX_APPLY_METHOD, RequiresADL, bool, NthStmt) MX_EXIT_VISIT_UnresolvedLookupExpr MX_END_VISIT_STMT(UnresolvedLookupExpr) @@ -17429,9 +17433,9 @@ MX_END_VISIT_STMT(UnresolvedLookupExpr) MX_BEGIN_VISIT_STMT(OpaqueValueExpr) MX_ENTER_VISIT_OpaqueValueExpr MX_VISIT_BASE(OpaqueValueExpr, Expr) - MX_VISIT_ENTITY(OpaqueValueExpr, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(OpaqueValueExpr, source_expression, 39, MX_APPLY_METHOD, SourceExpression, Expr, NthStmt) - MX_VISIT_BOOL(OpaqueValueExpr, is_unique, 84, MX_APPLY_METHOD, IsUnique, bool, NthStmt) + MX_VISIT_ENTITY(OpaqueValueExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(OpaqueValueExpr, source_expression, 40, MX_APPLY_METHOD, SourceExpression, Expr, NthStmt) + MX_VISIT_BOOL(OpaqueValueExpr, is_unique, 85, MX_APPLY_METHOD, IsUnique, bool, NthStmt) MX_EXIT_VISIT_OpaqueValueExpr MX_END_VISIT_STMT(OpaqueValueExpr) @@ -17445,8 +17449,8 @@ MX_END_VISIT_STMT(OpaqueValueExpr) MX_BEGIN_VISIT_STMT(OffsetOfExpr) MX_ENTER_VISIT_OffsetOfExpr MX_VISIT_BASE(OffsetOfExpr, Expr) - MX_VISIT_ENTITY(OffsetOfExpr, operator_token, 38, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(OffsetOfExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(OffsetOfExpr, operator_token, 39, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(OffsetOfExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_OffsetOfExpr MX_END_VISIT_STMT(OffsetOfExpr) @@ -17460,11 +17464,11 @@ MX_END_VISIT_STMT(OffsetOfExpr) MX_BEGIN_VISIT_STMT(ObjCSubscriptRefExpr) MX_ENTER_VISIT_ObjCSubscriptRefExpr MX_VISIT_BASE(ObjCSubscriptRefExpr, Expr) - MX_VISIT_ENTITY(ObjCSubscriptRefExpr, at_index_method_declaration, 38, MX_APPLY_METHOD, AtIndexMethodDeclaration, ObjCMethodDecl, NthStmt) - MX_VISIT_ENTITY(ObjCSubscriptRefExpr, base_expression, 39, MX_APPLY_METHOD, BaseExpression, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCSubscriptRefExpr, key_expression, 40, MX_APPLY_METHOD, KeyExpression, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCSubscriptRefExpr, r_bracket_token, 41, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) - MX_VISIT_BOOL(ObjCSubscriptRefExpr, is_array_subscript_reference_expression, 84, MX_APPLY_METHOD, IsArraySubscriptReferenceExpression, bool, NthStmt) + MX_VISIT_ENTITY(ObjCSubscriptRefExpr, at_index_method_declaration, 39, MX_APPLY_METHOD, AtIndexMethodDeclaration, ObjCMethodDecl, NthStmt) + MX_VISIT_ENTITY(ObjCSubscriptRefExpr, base_expression, 40, MX_APPLY_METHOD, BaseExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCSubscriptRefExpr, key_expression, 41, MX_APPLY_METHOD, KeyExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCSubscriptRefExpr, r_bracket_token, 42, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) + MX_VISIT_BOOL(ObjCSubscriptRefExpr, is_array_subscript_reference_expression, 85, MX_APPLY_METHOD, IsArraySubscriptReferenceExpression, bool, NthStmt) MX_EXIT_VISIT_ObjCSubscriptRefExpr MX_END_VISIT_STMT(ObjCSubscriptRefExpr) @@ -17478,8 +17482,8 @@ MX_END_VISIT_STMT(ObjCSubscriptRefExpr) MX_BEGIN_VISIT_STMT(ObjCStringLiteral) MX_ENTER_VISIT_ObjCStringLiteral MX_VISIT_BASE(ObjCStringLiteral, Expr) - MX_VISIT_ENTITY(ObjCStringLiteral, at_token, 38, MX_APPLY_METHOD, AtToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCStringLiteral, string, 39, MX_APPLY_METHOD, String, StringLiteral, NthStmt) + MX_VISIT_ENTITY(ObjCStringLiteral, at_token, 39, MX_APPLY_METHOD, AtToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCStringLiteral, string, 40, MX_APPLY_METHOD, String, StringLiteral, NthStmt) MX_EXIT_VISIT_ObjCStringLiteral MX_END_VISIT_STMT(ObjCStringLiteral) @@ -17493,8 +17497,8 @@ MX_END_VISIT_STMT(ObjCStringLiteral) MX_BEGIN_VISIT_STMT(ObjCSelectorExpr) MX_ENTER_VISIT_ObjCSelectorExpr MX_VISIT_BASE(ObjCSelectorExpr, Expr) - MX_VISIT_ENTITY(ObjCSelectorExpr, at_token, 38, MX_APPLY_METHOD, AtToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCSelectorExpr, r_paren_token, 39, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCSelectorExpr, at_token, 39, MX_APPLY_METHOD, AtToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCSelectorExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_ObjCSelectorExpr MX_END_VISIT_STMT(ObjCSelectorExpr) @@ -17508,10 +17512,10 @@ MX_END_VISIT_STMT(ObjCSelectorExpr) MX_BEGIN_VISIT_STMT(ObjCProtocolExpr) MX_ENTER_VISIT_ObjCProtocolExpr MX_VISIT_BASE(ObjCProtocolExpr, Expr) - MX_VISIT_ENTITY(ObjCProtocolExpr, at_token, 38, MX_APPLY_METHOD, AtToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCProtocolExpr, protocol, 39, MX_APPLY_METHOD, Protocol, ObjCProtocolDecl, NthStmt) - MX_VISIT_ENTITY(ObjCProtocolExpr, protocol_id_token, 40, MX_APPLY_METHOD, ProtocolIdToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCProtocolExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCProtocolExpr, at_token, 39, MX_APPLY_METHOD, AtToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCProtocolExpr, protocol, 40, MX_APPLY_METHOD, Protocol, ObjCProtocolDecl, NthStmt) + MX_VISIT_ENTITY(ObjCProtocolExpr, protocol_id_token, 41, MX_APPLY_METHOD, ProtocolIdToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCProtocolExpr, r_paren_token, 42, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_ObjCProtocolExpr MX_END_VISIT_STMT(ObjCProtocolExpr) @@ -17525,22 +17529,22 @@ MX_END_VISIT_STMT(ObjCProtocolExpr) MX_BEGIN_VISIT_STMT(ObjCPropertyRefExpr) MX_ENTER_VISIT_ObjCPropertyRefExpr MX_VISIT_BASE(ObjCPropertyRefExpr, Expr) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, class_receiver, 39, MX_APPLY_METHOD, ClassReceiver, ObjCInterfaceDecl, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, explicit_property, 40, MX_APPLY_METHOD, ExplicitProperty, ObjCPropertyDecl, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, implicit_property_getter, 41, MX_APPLY_METHOD, ImplicitPropertyGetter, ObjCMethodDecl, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, implicit_property_setter, 42, MX_APPLY_METHOD, ImplicitPropertySetter, ObjCMethodDecl, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, token, 43, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, receiver_token, 44, MX_APPLY_METHOD, ReceiverToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, receiver_type, 45, MX_APPLY_METHOD, ReceiverType, Type, NthStmt) - MX_VISIT_ENTITY(ObjCPropertyRefExpr, super_receiver_type, 46, MX_APPLY_METHOD, SuperReceiverType, Type, NthStmt) - MX_VISIT_BOOL(ObjCPropertyRefExpr, is_class_receiver, 84, MX_APPLY_METHOD, IsClassReceiver, bool, NthStmt) - MX_VISIT_BOOL(ObjCPropertyRefExpr, is_explicit_property, 85, MX_APPLY_METHOD, IsExplicitProperty, bool, NthStmt) - MX_VISIT_BOOL(ObjCPropertyRefExpr, is_implicit_property, 86, MX_APPLY_METHOD, IsImplicitProperty, bool, NthStmt) - MX_VISIT_BOOL(ObjCPropertyRefExpr, is_messaging_getter, 87, MX_APPLY_METHOD, IsMessagingGetter, bool, NthStmt) - MX_VISIT_BOOL(ObjCPropertyRefExpr, is_messaging_setter, 88, MX_APPLY_METHOD, IsMessagingSetter, bool, NthStmt) - MX_VISIT_BOOL(ObjCPropertyRefExpr, is_object_receiver, 90, MX_APPLY_METHOD, IsObjectReceiver, bool, NthStmt) - MX_VISIT_BOOL(ObjCPropertyRefExpr, is_super_receiver, 92, MX_APPLY_METHOD, IsSuperReceiver, bool, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, class_receiver, 40, MX_APPLY_METHOD, ClassReceiver, ObjCInterfaceDecl, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, explicit_property, 41, MX_APPLY_METHOD, ExplicitProperty, ObjCPropertyDecl, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, implicit_property_getter, 42, MX_APPLY_METHOD, ImplicitPropertyGetter, ObjCMethodDecl, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, implicit_property_setter, 43, MX_APPLY_METHOD, ImplicitPropertySetter, ObjCMethodDecl, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, token, 44, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, receiver_token, 45, MX_APPLY_METHOD, ReceiverToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, receiver_type, 46, MX_APPLY_METHOD, ReceiverType, Type, NthStmt) + MX_VISIT_ENTITY(ObjCPropertyRefExpr, super_receiver_type, 47, MX_APPLY_METHOD, SuperReceiverType, Type, NthStmt) + MX_VISIT_BOOL(ObjCPropertyRefExpr, is_class_receiver, 85, MX_APPLY_METHOD, IsClassReceiver, bool, NthStmt) + MX_VISIT_BOOL(ObjCPropertyRefExpr, is_explicit_property, 86, MX_APPLY_METHOD, IsExplicitProperty, bool, NthStmt) + MX_VISIT_BOOL(ObjCPropertyRefExpr, is_implicit_property, 87, MX_APPLY_METHOD, IsImplicitProperty, bool, NthStmt) + MX_VISIT_BOOL(ObjCPropertyRefExpr, is_messaging_getter, 88, MX_APPLY_METHOD, IsMessagingGetter, bool, NthStmt) + MX_VISIT_BOOL(ObjCPropertyRefExpr, is_messaging_setter, 89, MX_APPLY_METHOD, IsMessagingSetter, bool, NthStmt) + MX_VISIT_BOOL(ObjCPropertyRefExpr, is_object_receiver, 91, MX_APPLY_METHOD, IsObjectReceiver, bool, NthStmt) + MX_VISIT_BOOL(ObjCPropertyRefExpr, is_super_receiver, 93, MX_APPLY_METHOD, IsSuperReceiver, bool, NthStmt) MX_EXIT_VISIT_ObjCPropertyRefExpr MX_END_VISIT_STMT(ObjCPropertyRefExpr) @@ -17554,26 +17558,26 @@ MX_END_VISIT_STMT(ObjCPropertyRefExpr) MX_BEGIN_VISIT_STMT(ObjCMessageExpr) MX_ENTER_VISIT_ObjCMessageExpr MX_VISIT_BASE(ObjCMessageExpr, Expr) - MX_VISIT_ENTITY_LIST(ObjCMessageExpr, arguments, 15, MX_APPLY_METHOD, Arguments, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, call_return_type, 38, MX_APPLY_METHOD, CallReturnType, Type, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, class_receiver, 39, MX_APPLY_METHOD, ClassReceiver, Type, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, instance_receiver, 40, MX_APPLY_METHOD, InstanceReceiver, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, left_token, 41, MX_APPLY_METHOD, LeftToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, method_declaration, 42, MX_APPLY_METHOD, MethodDeclaration, ObjCMethodDecl, NthStmt) - MX_VISIT_ENUM(ObjCMessageExpr, method_family, 89, MX_APPLY_METHOD, MethodFamily, ObjCMethodFamily, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, receiver_interface, 43, MX_APPLY_METHOD, ReceiverInterface, ObjCInterfaceDecl, NthStmt) - MX_VISIT_ENUM(ObjCMessageExpr, receiver_kind, 91, MX_APPLY_METHOD, ReceiverKind, ObjCMessageExprReceiverKind, NthStmt) - MX_VISIT_TOKEN_RANGE(ObjCMessageExpr, receiver_range, 44, 45, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, receiver_type, 46, MX_APPLY_METHOD, ReceiverType, Type, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, right_token, 47, MX_APPLY_METHOD, RightToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, selector_start_token, 48, MX_APPLY_METHOD, SelectorStartToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, super_token, 49, MX_APPLY_METHOD, SuperToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCMessageExpr, super_type, 50, MX_APPLY_METHOD, SuperType, Type, NthStmt) - MX_VISIT_BOOL(ObjCMessageExpr, is_class_message, 84, MX_APPLY_METHOD, IsClassMessage, bool, NthStmt) - MX_VISIT_BOOL(ObjCMessageExpr, is_delegate_initializer_call, 85, MX_APPLY_METHOD, IsDelegateInitializerCall, bool, NthStmt) - MX_VISIT_BOOL(ObjCMessageExpr, is_implicit, 86, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) - MX_VISIT_BOOL(ObjCMessageExpr, is_instance_message, 87, MX_APPLY_METHOD, IsInstanceMessage, bool, NthStmt) - MX_VISIT_ENTITY_LIST(ObjCMessageExpr, selector_tokens, 27, MX_APPLY_METHOD, SelectorTokens, Token, NthStmt) + MX_VISIT_ENTITY_LIST(ObjCMessageExpr, arguments, 16, MX_APPLY_METHOD, Arguments, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, call_return_type, 39, MX_APPLY_METHOD, CallReturnType, Type, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, class_receiver, 40, MX_APPLY_METHOD, ClassReceiver, Type, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, instance_receiver, 41, MX_APPLY_METHOD, InstanceReceiver, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, left_token, 42, MX_APPLY_METHOD, LeftToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, method_declaration, 43, MX_APPLY_METHOD, MethodDeclaration, ObjCMethodDecl, NthStmt) + MX_VISIT_ENUM(ObjCMessageExpr, method_family, 90, MX_APPLY_METHOD, MethodFamily, ObjCMethodFamily, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, receiver_interface, 44, MX_APPLY_METHOD, ReceiverInterface, ObjCInterfaceDecl, NthStmt) + MX_VISIT_ENUM(ObjCMessageExpr, receiver_kind, 92, MX_APPLY_METHOD, ReceiverKind, ObjCMessageExprReceiverKind, NthStmt) + MX_VISIT_TOKEN_RANGE(ObjCMessageExpr, receiver_range, 45, 46, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, receiver_type, 47, MX_APPLY_METHOD, ReceiverType, Type, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, right_token, 48, MX_APPLY_METHOD, RightToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, selector_start_token, 49, MX_APPLY_METHOD, SelectorStartToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, super_token, 50, MX_APPLY_METHOD, SuperToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCMessageExpr, super_type, 51, MX_APPLY_METHOD, SuperType, Type, NthStmt) + MX_VISIT_BOOL(ObjCMessageExpr, is_class_message, 85, MX_APPLY_METHOD, IsClassMessage, bool, NthStmt) + MX_VISIT_BOOL(ObjCMessageExpr, is_delegate_initializer_call, 86, MX_APPLY_METHOD, IsDelegateInitializerCall, bool, NthStmt) + MX_VISIT_BOOL(ObjCMessageExpr, is_implicit, 87, MX_APPLY_METHOD, IsImplicit, bool, NthStmt) + MX_VISIT_BOOL(ObjCMessageExpr, is_instance_message, 88, MX_APPLY_METHOD, IsInstanceMessage, bool, NthStmt) + MX_VISIT_ENTITY_LIST(ObjCMessageExpr, selector_tokens, 28, MX_APPLY_METHOD, SelectorTokens, Token, NthStmt) MX_EXIT_VISIT_ObjCMessageExpr MX_END_VISIT_STMT(ObjCMessageExpr) @@ -17587,12 +17591,12 @@ MX_END_VISIT_STMT(ObjCMessageExpr) MX_BEGIN_VISIT_STMT(ObjCIvarRefExpr) MX_ENTER_VISIT_ObjCIvarRefExpr MX_VISIT_BASE(ObjCIvarRefExpr, Expr) - MX_VISIT_ENTITY(ObjCIvarRefExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCIvarRefExpr, declaration, 39, MX_APPLY_METHOD, Declaration, ObjCIvarDecl, NthStmt) - MX_VISIT_ENTITY(ObjCIvarRefExpr, token, 40, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_ENTITY(ObjCIvarRefExpr, operation_token, 41, MX_APPLY_METHOD, OperationToken, Token, NthStmt) - MX_VISIT_BOOL(ObjCIvarRefExpr, is_arrow, 84, MX_APPLY_METHOD, IsArrow, bool, NthStmt) - MX_VISIT_BOOL(ObjCIvarRefExpr, is_free_instance_variable, 85, MX_APPLY_METHOD, IsFreeInstanceVariable, bool, NthStmt) + MX_VISIT_ENTITY(ObjCIvarRefExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCIvarRefExpr, declaration, 40, MX_APPLY_METHOD, Declaration, ObjCIvarDecl, NthStmt) + MX_VISIT_ENTITY(ObjCIvarRefExpr, token, 41, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_ENTITY(ObjCIvarRefExpr, operation_token, 42, MX_APPLY_METHOD, OperationToken, Token, NthStmt) + MX_VISIT_BOOL(ObjCIvarRefExpr, is_arrow, 85, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_BOOL(ObjCIvarRefExpr, is_free_instance_variable, 86, MX_APPLY_METHOD, IsFreeInstanceVariable, bool, NthStmt) MX_EXIT_VISIT_ObjCIvarRefExpr MX_END_VISIT_STMT(ObjCIvarRefExpr) @@ -17606,11 +17610,11 @@ MX_END_VISIT_STMT(ObjCIvarRefExpr) MX_BEGIN_VISIT_STMT(ObjCIsaExpr) MX_ENTER_VISIT_ObjCIsaExpr MX_VISIT_BASE(ObjCIsaExpr, Expr) - MX_VISIT_ENTITY(ObjCIsaExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(ObjCIsaExpr, base_token_end, 39, MX_APPLY_METHOD, BaseTokenEnd, Token, NthStmt) - MX_VISIT_ENTITY(ObjCIsaExpr, isa_member_token, 40, MX_APPLY_METHOD, IsaMemberToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCIsaExpr, operation_token, 41, MX_APPLY_METHOD, OperationToken, Token, NthStmt) - MX_VISIT_BOOL(ObjCIsaExpr, is_arrow, 84, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_ENTITY(ObjCIsaExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCIsaExpr, base_token_end, 40, MX_APPLY_METHOD, BaseTokenEnd, Token, NthStmt) + MX_VISIT_ENTITY(ObjCIsaExpr, isa_member_token, 41, MX_APPLY_METHOD, IsaMemberToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCIsaExpr, operation_token, 42, MX_APPLY_METHOD, OperationToken, Token, NthStmt) + MX_VISIT_BOOL(ObjCIsaExpr, is_arrow, 85, MX_APPLY_METHOD, IsArrow, bool, NthStmt) MX_EXIT_VISIT_ObjCIsaExpr MX_END_VISIT_STMT(ObjCIsaExpr) @@ -17624,8 +17628,8 @@ MX_END_VISIT_STMT(ObjCIsaExpr) MX_BEGIN_VISIT_STMT(ObjCIndirectCopyRestoreExpr) MX_ENTER_VISIT_ObjCIndirectCopyRestoreExpr MX_VISIT_BASE(ObjCIndirectCopyRestoreExpr, Expr) - MX_VISIT_ENTITY(ObjCIndirectCopyRestoreExpr, sub_expression, 38, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) - MX_VISIT_BOOL(ObjCIndirectCopyRestoreExpr, should_copy, 84, MX_APPLY_METHOD, ShouldCopy, bool, NthStmt) + MX_VISIT_ENTITY(ObjCIndirectCopyRestoreExpr, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_BOOL(ObjCIndirectCopyRestoreExpr, should_copy, 85, MX_APPLY_METHOD, ShouldCopy, bool, NthStmt) MX_EXIT_VISIT_ObjCIndirectCopyRestoreExpr MX_END_VISIT_STMT(ObjCIndirectCopyRestoreExpr) @@ -17639,9 +17643,9 @@ MX_END_VISIT_STMT(ObjCIndirectCopyRestoreExpr) MX_BEGIN_VISIT_STMT(ObjCEncodeExpr) MX_ENTER_VISIT_ObjCEncodeExpr MX_VISIT_BASE(ObjCEncodeExpr, Expr) - MX_VISIT_ENTITY(ObjCEncodeExpr, at_token, 38, MX_APPLY_METHOD, AtToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCEncodeExpr, encoded_type, 39, MX_APPLY_METHOD, EncodedType, Type, NthStmt) - MX_VISIT_ENTITY(ObjCEncodeExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCEncodeExpr, at_token, 39, MX_APPLY_METHOD, AtToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCEncodeExpr, encoded_type, 40, MX_APPLY_METHOD, EncodedType, Type, NthStmt) + MX_VISIT_ENTITY(ObjCEncodeExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_ObjCEncodeExpr MX_END_VISIT_STMT(ObjCEncodeExpr) @@ -17655,7 +17659,7 @@ MX_END_VISIT_STMT(ObjCEncodeExpr) MX_BEGIN_VISIT_STMT(ObjCDictionaryLiteral) MX_ENTER_VISIT_ObjCDictionaryLiteral MX_VISIT_BASE(ObjCDictionaryLiteral, Expr) - MX_VISIT_ENTITY(ObjCDictionaryLiteral, dictionary_with_objects_method, 38, MX_APPLY_METHOD, DictionaryWithObjectsMethod, ObjCMethodDecl, NthStmt) + MX_VISIT_ENTITY(ObjCDictionaryLiteral, dictionary_with_objects_method, 39, MX_APPLY_METHOD, DictionaryWithObjectsMethod, ObjCMethodDecl, NthStmt) MX_EXIT_VISIT_ObjCDictionaryLiteral MX_END_VISIT_STMT(ObjCDictionaryLiteral) @@ -17669,10 +17673,10 @@ MX_END_VISIT_STMT(ObjCDictionaryLiteral) MX_BEGIN_VISIT_STMT(ObjCBoxedExpr) MX_ENTER_VISIT_ObjCBoxedExpr MX_VISIT_BASE(ObjCBoxedExpr, Expr) - MX_VISIT_ENTITY(ObjCBoxedExpr, at_token, 38, MX_APPLY_METHOD, AtToken, Token, NthStmt) - MX_VISIT_ENTITY(ObjCBoxedExpr, boxing_method, 39, MX_APPLY_METHOD, BoxingMethod, ObjCMethodDecl, NthStmt) - MX_VISIT_ENTITY(ObjCBoxedExpr, sub_expression, 40, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) - MX_VISIT_BOOL(ObjCBoxedExpr, is_expressible_as_constant_initializer, 84, MX_APPLY_METHOD, IsExpressibleAsConstantInitializer, bool, NthStmt) + MX_VISIT_ENTITY(ObjCBoxedExpr, at_token, 39, MX_APPLY_METHOD, AtToken, Token, NthStmt) + MX_VISIT_ENTITY(ObjCBoxedExpr, boxing_method, 40, MX_APPLY_METHOD, BoxingMethod, ObjCMethodDecl, NthStmt) + MX_VISIT_ENTITY(ObjCBoxedExpr, sub_expression, 41, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_BOOL(ObjCBoxedExpr, is_expressible_as_constant_initializer, 85, MX_APPLY_METHOD, IsExpressibleAsConstantInitializer, bool, NthStmt) MX_EXIT_VISIT_ObjCBoxedExpr MX_END_VISIT_STMT(ObjCBoxedExpr) @@ -17686,8 +17690,8 @@ MX_END_VISIT_STMT(ObjCBoxedExpr) MX_BEGIN_VISIT_STMT(ObjCBoolLiteralExpr) MX_ENTER_VISIT_ObjCBoolLiteralExpr MX_VISIT_BASE(ObjCBoolLiteralExpr, Expr) - MX_VISIT_ENTITY(ObjCBoolLiteralExpr, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_BOOL(ObjCBoolLiteralExpr, value, 84, MX_APPLY_METHOD, Value, bool, NthStmt) + MX_VISIT_ENTITY(ObjCBoolLiteralExpr, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_BOOL(ObjCBoolLiteralExpr, value, 85, MX_APPLY_METHOD, Value, bool, NthStmt) MX_EXIT_VISIT_ObjCBoolLiteralExpr MX_END_VISIT_STMT(ObjCBoolLiteralExpr) @@ -17701,7 +17705,7 @@ MX_END_VISIT_STMT(ObjCBoolLiteralExpr) MX_BEGIN_VISIT_STMT(ObjCAvailabilityCheckExpr) MX_ENTER_VISIT_ObjCAvailabilityCheckExpr MX_VISIT_BASE(ObjCAvailabilityCheckExpr, Expr) - MX_VISIT_BOOL(ObjCAvailabilityCheckExpr, has_version, 84, MX_APPLY_METHOD, HasVersion, bool, NthStmt) + MX_VISIT_BOOL(ObjCAvailabilityCheckExpr, has_version, 85, MX_APPLY_METHOD, HasVersion, bool, NthStmt) MX_EXIT_VISIT_ObjCAvailabilityCheckExpr MX_END_VISIT_STMT(ObjCAvailabilityCheckExpr) @@ -17715,8 +17719,8 @@ MX_END_VISIT_STMT(ObjCAvailabilityCheckExpr) MX_BEGIN_VISIT_STMT(ObjCArrayLiteral) MX_ENTER_VISIT_ObjCArrayLiteral MX_VISIT_BASE(ObjCArrayLiteral, Expr) - MX_VISIT_ENTITY(ObjCArrayLiteral, array_with_objects_method, 38, MX_APPLY_METHOD, ArrayWithObjectsMethod, ObjCMethodDecl, NthStmt) - MX_VISIT_ENTITY_LIST(ObjCArrayLiteral, elements, 15, MX_APPLY_METHOD, Elements, Expr, NthStmt) + MX_VISIT_ENTITY(ObjCArrayLiteral, array_with_objects_method, 39, MX_APPLY_METHOD, ArrayWithObjectsMethod, ObjCMethodDecl, NthStmt) + MX_VISIT_ENTITY_LIST(ObjCArrayLiteral, elements, 16, MX_APPLY_METHOD, Elements, Expr, NthStmt) MX_EXIT_VISIT_ObjCArrayLiteral MX_END_VISIT_STMT(ObjCArrayLiteral) @@ -17730,9 +17734,9 @@ MX_END_VISIT_STMT(ObjCArrayLiteral) MX_BEGIN_VISIT_STMT(OMPIteratorExpr) MX_ENTER_VISIT_OMPIteratorExpr MX_VISIT_BASE(OMPIteratorExpr, Expr) - MX_VISIT_ENTITY(OMPIteratorExpr, iterator_kw_token, 38, MX_APPLY_METHOD, IteratorKwToken, Token, NthStmt) - MX_VISIT_ENTITY(OMPIteratorExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(OMPIteratorExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPIteratorExpr, iterator_kw_token, 39, MX_APPLY_METHOD, IteratorKwToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPIteratorExpr, l_paren_token, 40, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPIteratorExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_OMPIteratorExpr MX_END_VISIT_STMT(OMPIteratorExpr) @@ -17746,10 +17750,10 @@ MX_END_VISIT_STMT(OMPIteratorExpr) MX_BEGIN_VISIT_STMT(OMPArrayShapingExpr) MX_ENTER_VISIT_OMPArrayShapingExpr MX_VISIT_BASE(OMPArrayShapingExpr, Expr) - MX_VISIT_ENTITY(OMPArrayShapingExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY_LIST(OMPArrayShapingExpr, dimensions, 15, MX_APPLY_METHOD, Dimensions, Expr, NthStmt) - MX_VISIT_ENTITY(OMPArrayShapingExpr, l_paren_token, 39, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(OMPArrayShapingExpr, r_paren_token, 40, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPArrayShapingExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY_LIST(OMPArrayShapingExpr, dimensions, 16, MX_APPLY_METHOD, Dimensions, Expr, NthStmt) + MX_VISIT_ENTITY(OMPArrayShapingExpr, l_paren_token, 40, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPArrayShapingExpr, r_paren_token, 41, MX_APPLY_METHOD, RParenToken, Token, NthStmt) MX_EXIT_VISIT_OMPArrayShapingExpr MX_END_VISIT_STMT(OMPArrayShapingExpr) @@ -17763,13 +17767,13 @@ MX_END_VISIT_STMT(OMPArrayShapingExpr) MX_BEGIN_VISIT_STMT(OMPArraySectionExpr) MX_ENTER_VISIT_OMPArraySectionExpr MX_VISIT_BASE(OMPArraySectionExpr, Expr) - MX_VISIT_ENTITY(OMPArraySectionExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(OMPArraySectionExpr, first_colon_token, 39, MX_APPLY_METHOD, FirstColonToken, Token, NthStmt) - MX_VISIT_ENTITY(OMPArraySectionExpr, second_colon_token, 40, MX_APPLY_METHOD, SecondColonToken, Token, NthStmt) - MX_VISIT_ENTITY(OMPArraySectionExpr, length, 41, MX_APPLY_METHOD, Length, Expr, NthStmt) - MX_VISIT_ENTITY(OMPArraySectionExpr, lower_bound, 42, MX_APPLY_METHOD, LowerBound, Expr, NthStmt) - MX_VISIT_ENTITY(OMPArraySectionExpr, r_bracket_token, 43, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) - MX_VISIT_ENTITY(OMPArraySectionExpr, stride, 44, MX_APPLY_METHOD, Stride, Expr, NthStmt) + MX_VISIT_ENTITY(OMPArraySectionExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(OMPArraySectionExpr, first_colon_token, 40, MX_APPLY_METHOD, FirstColonToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPArraySectionExpr, second_colon_token, 41, MX_APPLY_METHOD, SecondColonToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPArraySectionExpr, length, 42, MX_APPLY_METHOD, Length, Expr, NthStmt) + MX_VISIT_ENTITY(OMPArraySectionExpr, lower_bound, 43, MX_APPLY_METHOD, LowerBound, Expr, NthStmt) + MX_VISIT_ENTITY(OMPArraySectionExpr, r_bracket_token, 44, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) + MX_VISIT_ENTITY(OMPArraySectionExpr, stride, 45, MX_APPLY_METHOD, Stride, Expr, NthStmt) MX_EXIT_VISIT_OMPArraySectionExpr MX_END_VISIT_STMT(OMPArraySectionExpr) @@ -17796,20 +17800,20 @@ MX_END_VISIT_STMT(NoInitExpr) MX_BEGIN_VISIT_STMT(MemberExpr) MX_ENTER_VISIT_MemberExpr MX_VISIT_BASE(MemberExpr, Expr) - MX_VISIT_ENTITY(MemberExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(MemberExpr, l_angle_token, 39, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(MemberExpr, member_declaration, 40, MX_APPLY_METHOD, MemberDeclaration, ValueDecl, NthStmt) - MX_VISIT_ENTITY(MemberExpr, member_token, 41, MX_APPLY_METHOD, MemberToken, Token, NthStmt) - MX_VISIT_ENTITY(MemberExpr, operator_token, 42, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) - MX_VISIT_ENTITY(MemberExpr, r_angle_token, 43, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) - MX_VISIT_ENTITY(MemberExpr, template_keyword_token, 44, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) - MX_VISIT_BOOL(MemberExpr, had_multiple_candidates, 84, MX_APPLY_METHOD, HadMultipleCandidates, bool, NthStmt) - MX_VISIT_BOOL(MemberExpr, has_explicit_template_arguments, 85, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) - MX_VISIT_BOOL(MemberExpr, has_qualifier, 86, MX_APPLY_METHOD, HasQualifier, bool, NthStmt) - MX_VISIT_BOOL(MemberExpr, has_template_keyword, 87, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) - MX_VISIT_BOOL(MemberExpr, is_arrow, 88, MX_APPLY_METHOD, IsArrow, bool, NthStmt) - MX_VISIT_BOOL(MemberExpr, is_implicit_access, 90, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) - MX_VISIT_ENUM(MemberExpr, is_non_odr_use, 89, MX_APPLY_METHOD, IsNonOdrUse, NonOdrUseReason, NthStmt) + MX_VISIT_ENTITY(MemberExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(MemberExpr, l_angle_token, 40, MX_APPLY_METHOD, LAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(MemberExpr, member_declaration, 41, MX_APPLY_METHOD, MemberDeclaration, ValueDecl, NthStmt) + MX_VISIT_ENTITY(MemberExpr, member_token, 42, MX_APPLY_METHOD, MemberToken, Token, NthStmt) + MX_VISIT_ENTITY(MemberExpr, operator_token, 43, MX_APPLY_METHOD, OperatorToken, Token, NthStmt) + MX_VISIT_ENTITY(MemberExpr, r_angle_token, 44, MX_APPLY_METHOD, RAngleToken, Token, NthStmt) + MX_VISIT_ENTITY(MemberExpr, template_keyword_token, 45, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthStmt) + MX_VISIT_BOOL(MemberExpr, had_multiple_candidates, 85, MX_APPLY_METHOD, HadMultipleCandidates, bool, NthStmt) + MX_VISIT_BOOL(MemberExpr, has_explicit_template_arguments, 86, MX_APPLY_METHOD, HasExplicitTemplateArguments, bool, NthStmt) + MX_VISIT_BOOL(MemberExpr, has_qualifier, 87, MX_APPLY_METHOD, HasQualifier, bool, NthStmt) + MX_VISIT_BOOL(MemberExpr, has_template_keyword, 88, MX_APPLY_METHOD, HasTemplateKeyword, bool, NthStmt) + MX_VISIT_BOOL(MemberExpr, is_arrow, 89, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_BOOL(MemberExpr, is_implicit_access, 91, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) + MX_VISIT_ENUM(MemberExpr, is_non_odr_use, 90, MX_APPLY_METHOD, IsNonOdrUse, NonOdrUseReason, NthStmt) MX_EXIT_VISIT_MemberExpr MX_END_VISIT_STMT(MemberExpr) @@ -17823,11 +17827,11 @@ MX_END_VISIT_STMT(MemberExpr) MX_BEGIN_VISIT_STMT(MatrixSubscriptExpr) MX_ENTER_VISIT_MatrixSubscriptExpr MX_VISIT_BASE(MatrixSubscriptExpr, Expr) - MX_VISIT_ENTITY(MatrixSubscriptExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(MatrixSubscriptExpr, column_index, 39, MX_APPLY_METHOD, ColumnIndex, Expr, NthStmt) - MX_VISIT_ENTITY(MatrixSubscriptExpr, r_bracket_token, 40, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) - MX_VISIT_ENTITY(MatrixSubscriptExpr, row_index, 41, MX_APPLY_METHOD, RowIndex, Expr, NthStmt) - MX_VISIT_BOOL(MatrixSubscriptExpr, is_incomplete, 84, MX_APPLY_METHOD, IsIncomplete, bool, NthStmt) + MX_VISIT_ENTITY(MatrixSubscriptExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(MatrixSubscriptExpr, column_index, 40, MX_APPLY_METHOD, ColumnIndex, Expr, NthStmt) + MX_VISIT_ENTITY(MatrixSubscriptExpr, r_bracket_token, 41, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) + MX_VISIT_ENTITY(MatrixSubscriptExpr, row_index, 42, MX_APPLY_METHOD, RowIndex, Expr, NthStmt) + MX_VISIT_BOOL(MatrixSubscriptExpr, is_incomplete, 85, MX_APPLY_METHOD, IsIncomplete, bool, NthStmt) MX_EXIT_VISIT_MatrixSubscriptExpr MX_END_VISIT_STMT(MatrixSubscriptExpr) @@ -17841,13 +17845,13 @@ MX_END_VISIT_STMT(MatrixSubscriptExpr) MX_BEGIN_VISIT_STMT(MaterializeTemporaryExpr) MX_ENTER_VISIT_MaterializeTemporaryExpr MX_VISIT_BASE(MaterializeTemporaryExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(MaterializeTemporaryExpr, extending_declaration, 38, MX_APPLY_METHOD, ExtendingDeclaration, ValueDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(MaterializeTemporaryExpr, lifetime_extended_temporary_declaration, 39, MX_APPLY_METHOD, LifetimeExtendedTemporaryDeclaration, LifetimeExtendedTemporaryDecl, NthStmt) - MX_VISIT_INT(MaterializeTemporaryExpr, mangling_number, 26, MX_APPLY_METHOD, ManglingNumber, uint32_t, NthStmt) - MX_VISIT_ENUM(MaterializeTemporaryExpr, storage_duration, 89, MX_APPLY_METHOD, StorageDuration, StorageDuration, NthStmt) - MX_VISIT_ENTITY(MaterializeTemporaryExpr, sub_expression, 40, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) - MX_VISIT_BOOL(MaterializeTemporaryExpr, is_bound_to_lvalue_reference, 84, MX_APPLY_METHOD, IsBoundToLvalueReference, bool, NthStmt) - MX_VISIT_BOOL(MaterializeTemporaryExpr, is_usable_in_constant_expressions, 85, MX_APPLY_METHOD, IsUsableInConstantExpressions, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(MaterializeTemporaryExpr, extending_declaration, 39, MX_APPLY_METHOD, ExtendingDeclaration, ValueDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(MaterializeTemporaryExpr, lifetime_extended_temporary_declaration, 40, MX_APPLY_METHOD, LifetimeExtendedTemporaryDeclaration, LifetimeExtendedTemporaryDecl, NthStmt) + MX_VISIT_INT(MaterializeTemporaryExpr, mangling_number, 27, MX_APPLY_METHOD, ManglingNumber, uint32_t, NthStmt) + MX_VISIT_ENUM(MaterializeTemporaryExpr, storage_duration, 90, MX_APPLY_METHOD, StorageDuration, StorageDuration, NthStmt) + MX_VISIT_ENTITY(MaterializeTemporaryExpr, sub_expression, 41, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_BOOL(MaterializeTemporaryExpr, is_bound_to_lvalue_reference, 85, MX_APPLY_METHOD, IsBoundToLvalueReference, bool, NthStmt) + MX_VISIT_BOOL(MaterializeTemporaryExpr, is_usable_in_constant_expressions, 86, MX_APPLY_METHOD, IsUsableInConstantExpressions, bool, NthStmt) MX_EXIT_VISIT_MaterializeTemporaryExpr MX_END_VISIT_STMT(MaterializeTemporaryExpr) @@ -17861,9 +17865,9 @@ MX_END_VISIT_STMT(MaterializeTemporaryExpr) MX_BEGIN_VISIT_STMT(MSPropertySubscriptExpr) MX_ENTER_VISIT_MSPropertySubscriptExpr MX_VISIT_BASE(MSPropertySubscriptExpr, Expr) - MX_VISIT_ENTITY(MSPropertySubscriptExpr, base, 38, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_ENTITY(MSPropertySubscriptExpr, index, 39, MX_APPLY_METHOD, Index, Expr, NthStmt) - MX_VISIT_ENTITY(MSPropertySubscriptExpr, r_bracket_token, 40, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) + MX_VISIT_ENTITY(MSPropertySubscriptExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_ENTITY(MSPropertySubscriptExpr, index, 40, MX_APPLY_METHOD, Index, Expr, NthStmt) + MX_VISIT_ENTITY(MSPropertySubscriptExpr, r_bracket_token, 41, MX_APPLY_METHOD, RBracketToken, Token, NthStmt) MX_EXIT_VISIT_MSPropertySubscriptExpr MX_END_VISIT_STMT(MSPropertySubscriptExpr) @@ -17877,11 +17881,11 @@ MX_END_VISIT_STMT(MSPropertySubscriptExpr) MX_BEGIN_VISIT_STMT(MSPropertyRefExpr) MX_ENTER_VISIT_MSPropertyRefExpr MX_VISIT_BASE(MSPropertyRefExpr, Expr) - MX_VISIT_ENTITY(MSPropertyRefExpr, base_expression, 38, MX_APPLY_METHOD, BaseExpression, Expr, NthStmt) - MX_VISIT_ENTITY(MSPropertyRefExpr, member_token, 39, MX_APPLY_METHOD, MemberToken, Token, NthStmt) - MX_VISIT_ENTITY(MSPropertyRefExpr, property_declaration, 40, MX_APPLY_METHOD, PropertyDeclaration, MSPropertyDecl, NthStmt) - MX_VISIT_BOOL(MSPropertyRefExpr, is_arrow, 84, MX_APPLY_METHOD, IsArrow, bool, NthStmt) - MX_VISIT_BOOL(MSPropertyRefExpr, is_implicit_access, 85, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) + MX_VISIT_ENTITY(MSPropertyRefExpr, base_expression, 39, MX_APPLY_METHOD, BaseExpression, Expr, NthStmt) + MX_VISIT_ENTITY(MSPropertyRefExpr, member_token, 40, MX_APPLY_METHOD, MemberToken, Token, NthStmt) + MX_VISIT_ENTITY(MSPropertyRefExpr, property_declaration, 41, MX_APPLY_METHOD, PropertyDeclaration, MSPropertyDecl, NthStmt) + MX_VISIT_BOOL(MSPropertyRefExpr, is_arrow, 85, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_BOOL(MSPropertyRefExpr, is_implicit_access, 86, MX_APPLY_METHOD, IsImplicitAccess, bool, NthStmt) MX_EXIT_VISIT_MSPropertyRefExpr MX_END_VISIT_STMT(MSPropertyRefExpr) @@ -17895,21 +17899,21 @@ MX_END_VISIT_STMT(MSPropertyRefExpr) MX_BEGIN_VISIT_STMT(LambdaExpr) MX_ENTER_VISIT_LambdaExpr MX_VISIT_BASE(LambdaExpr, Expr) - MX_VISIT_ENTITY(LambdaExpr, body, 38, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(LambdaExpr, call_operator, 39, MX_APPLY_METHOD, CallOperator, CXXMethodDecl, NthStmt) - MX_VISIT_ENUM(LambdaExpr, capture_default, 89, MX_APPLY_METHOD, CaptureDefault, LambdaCaptureDefault, NthStmt) - MX_VISIT_ENTITY(LambdaExpr, capture_default_token, 40, MX_APPLY_METHOD, CaptureDefaultToken, Token, NthStmt) - MX_VISIT_ENTITY(LambdaExpr, compound_statement_body, 41, MX_APPLY_METHOD, CompoundStatementBody, CompoundStmt, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(LambdaExpr, dependent_call_operator, 42, MX_APPLY_METHOD, DependentCallOperator, FunctionTemplateDecl, NthStmt) - MX_VISIT_ENTITY_LIST(LambdaExpr, explicit_template_parameters, 15, MX_APPLY_METHOD, ExplicitTemplateParameters, NamedDecl, NthStmt) - MX_VISIT_TOKEN_RANGE(LambdaExpr, introducer_range, 43, 44, NthStmt) - MX_VISIT_ENTITY(LambdaExpr, lambda_class, 45, MX_APPLY_METHOD, LambdaClass, CXXRecordDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(LambdaExpr, template_parameter_list, 46, MX_APPLY_METHOD, TemplateParameterList, TemplateParameterList, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(LambdaExpr, trailing_requires_clause, 47, MX_APPLY_METHOD, TrailingRequiresClause, Expr, NthStmt) - MX_VISIT_BOOL(LambdaExpr, has_explicit_parameters, 84, MX_APPLY_METHOD, HasExplicitParameters, bool, NthStmt) - MX_VISIT_BOOL(LambdaExpr, has_explicit_result_type, 85, MX_APPLY_METHOD, HasExplicitResultType, bool, NthStmt) - MX_VISIT_BOOL(LambdaExpr, is_generic_lambda, 86, MX_APPLY_METHOD, IsGenericLambda, bool, NthStmt) - MX_VISIT_BOOL(LambdaExpr, is_mutable, 87, MX_APPLY_METHOD, IsMutable, bool, NthStmt) + MX_VISIT_ENTITY(LambdaExpr, body, 39, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(LambdaExpr, call_operator, 40, MX_APPLY_METHOD, CallOperator, CXXMethodDecl, NthStmt) + MX_VISIT_ENUM(LambdaExpr, capture_default, 90, MX_APPLY_METHOD, CaptureDefault, LambdaCaptureDefault, NthStmt) + MX_VISIT_ENTITY(LambdaExpr, capture_default_token, 41, MX_APPLY_METHOD, CaptureDefaultToken, Token, NthStmt) + MX_VISIT_ENTITY(LambdaExpr, compound_statement_body, 42, MX_APPLY_METHOD, CompoundStatementBody, CompoundStmt, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(LambdaExpr, dependent_call_operator, 43, MX_APPLY_METHOD, DependentCallOperator, FunctionTemplateDecl, NthStmt) + MX_VISIT_ENTITY_LIST(LambdaExpr, explicit_template_parameters, 16, MX_APPLY_METHOD, ExplicitTemplateParameters, NamedDecl, NthStmt) + MX_VISIT_TOKEN_RANGE(LambdaExpr, introducer_range, 44, 45, NthStmt) + MX_VISIT_ENTITY(LambdaExpr, lambda_class, 46, MX_APPLY_METHOD, LambdaClass, CXXRecordDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(LambdaExpr, template_parameter_list, 47, MX_APPLY_METHOD, TemplateParameterList, TemplateParameterList, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(LambdaExpr, trailing_requires_clause, 48, MX_APPLY_METHOD, TrailingRequiresClause, Expr, NthStmt) + MX_VISIT_BOOL(LambdaExpr, has_explicit_parameters, 85, MX_APPLY_METHOD, HasExplicitParameters, bool, NthStmt) + MX_VISIT_BOOL(LambdaExpr, has_explicit_result_type, 86, MX_APPLY_METHOD, HasExplicitResultType, bool, NthStmt) + MX_VISIT_BOOL(LambdaExpr, is_generic_lambda, 87, MX_APPLY_METHOD, IsGenericLambda, bool, NthStmt) + MX_VISIT_BOOL(LambdaExpr, is_mutable, 88, MX_APPLY_METHOD, IsMutable, bool, NthStmt) MX_EXIT_VISIT_LambdaExpr MX_END_VISIT_STMT(LambdaExpr) @@ -17923,7 +17927,7 @@ MX_END_VISIT_STMT(LambdaExpr) MX_BEGIN_VISIT_STMT(IntegerLiteral) MX_ENTER_VISIT_IntegerLiteral MX_VISIT_BASE(IntegerLiteral, Expr) - MX_VISIT_ENTITY(IntegerLiteral, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_ENTITY(IntegerLiteral, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) MX_EXIT_VISIT_IntegerLiteral MX_END_VISIT_STMT(IntegerLiteral) @@ -17937,21 +17941,21 @@ MX_END_VISIT_STMT(IntegerLiteral) MX_BEGIN_VISIT_STMT(InitListExpr) MX_ENTER_VISIT_InitListExpr MX_VISIT_BASE(InitListExpr, Expr) - MX_VISIT_OPTIONAL_ENTITY(InitListExpr, array_filler, 38, MX_APPLY_METHOD, ArrayFiller, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(InitListExpr, initialized_field_in_union, 39, MX_APPLY_METHOD, InitializedFieldInUnion, FieldDecl, NthStmt) - MX_VISIT_ENTITY(InitListExpr, l_brace_token, 40, MX_APPLY_METHOD, LBraceToken, Token, NthStmt) - MX_VISIT_ENTITY(InitListExpr, r_brace_token, 41, MX_APPLY_METHOD, RBraceToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(InitListExpr, semantic_form, 42, MX_APPLY_METHOD, SemanticForm, InitListExpr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(InitListExpr, syntactic_form, 43, MX_APPLY_METHOD, SyntacticForm, InitListExpr, NthStmt) - MX_VISIT_BOOL(InitListExpr, had_array_range_designator, 84, MX_APPLY_METHOD, HadArrayRangeDesignator, bool, NthStmt) - MX_VISIT_BOOL(InitListExpr, has_array_filler, 85, MX_APPLY_METHOD, HasArrayFiller, bool, NthStmt) - MX_VISIT_BOOL(InitListExpr, has_designated_initializer, 86, MX_APPLY_METHOD, HasDesignatedInitializer, bool, NthStmt) - MX_VISIT_ENTITY_LIST(InitListExpr, initializers, 15, MX_APPLY_METHOD, Initializers, Expr, NthStmt) - MX_VISIT_BOOL(InitListExpr, is_explicit, 87, MX_APPLY_METHOD, IsExplicit, bool, NthStmt) - MX_VISIT_BOOL(InitListExpr, is_semantic_form, 88, MX_APPLY_METHOD, IsSemanticForm, bool, NthStmt) - MX_VISIT_BOOL(InitListExpr, is_string_literal_initializer, 90, MX_APPLY_METHOD, IsStringLiteralInitializer, bool, NthStmt) - MX_VISIT_BOOL(InitListExpr, is_syntactic_form, 92, MX_APPLY_METHOD, IsSyntacticForm, bool, NthStmt) - MX_VISIT_OPTIONAL_BOOL(InitListExpr, is_transparent, 93, MX_APPLY_METHOD, IsTransparent, bool, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(InitListExpr, array_filler, 39, MX_APPLY_METHOD, ArrayFiller, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(InitListExpr, initialized_field_in_union, 40, MX_APPLY_METHOD, InitializedFieldInUnion, FieldDecl, NthStmt) + MX_VISIT_ENTITY(InitListExpr, l_brace_token, 41, MX_APPLY_METHOD, LBraceToken, Token, NthStmt) + MX_VISIT_ENTITY(InitListExpr, r_brace_token, 42, MX_APPLY_METHOD, RBraceToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(InitListExpr, semantic_form, 43, MX_APPLY_METHOD, SemanticForm, InitListExpr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(InitListExpr, syntactic_form, 44, MX_APPLY_METHOD, SyntacticForm, InitListExpr, NthStmt) + MX_VISIT_BOOL(InitListExpr, had_array_range_designator, 85, MX_APPLY_METHOD, HadArrayRangeDesignator, bool, NthStmt) + MX_VISIT_BOOL(InitListExpr, has_array_filler, 86, MX_APPLY_METHOD, HasArrayFiller, bool, NthStmt) + MX_VISIT_BOOL(InitListExpr, has_designated_initializer, 87, MX_APPLY_METHOD, HasDesignatedInitializer, bool, NthStmt) + MX_VISIT_ENTITY_LIST(InitListExpr, initializers, 16, MX_APPLY_METHOD, Initializers, Expr, NthStmt) + MX_VISIT_BOOL(InitListExpr, is_explicit, 88, MX_APPLY_METHOD, IsExplicit, bool, NthStmt) + MX_VISIT_BOOL(InitListExpr, is_semantic_form, 89, MX_APPLY_METHOD, IsSemanticForm, bool, NthStmt) + MX_VISIT_BOOL(InitListExpr, is_string_literal_initializer, 91, MX_APPLY_METHOD, IsStringLiteralInitializer, bool, NthStmt) + MX_VISIT_BOOL(InitListExpr, is_syntactic_form, 93, MX_APPLY_METHOD, IsSyntacticForm, bool, NthStmt) + MX_VISIT_OPTIONAL_BOOL(InitListExpr, is_transparent, 94, MX_APPLY_METHOD, IsTransparent, bool, NthStmt) MX_EXIT_VISIT_InitListExpr MX_END_VISIT_STMT(InitListExpr) @@ -17978,7 +17982,7 @@ MX_END_VISIT_STMT(ImplicitValueInitExpr) MX_BEGIN_VISIT_STMT(ImaginaryLiteral) MX_ENTER_VISIT_ImaginaryLiteral MX_VISIT_BASE(ImaginaryLiteral, Expr) - MX_VISIT_ENTITY(ImaginaryLiteral, sub_expression, 38, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(ImaginaryLiteral, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) MX_EXIT_VISIT_ImaginaryLiteral MX_END_VISIT_STMT(ImaginaryLiteral) @@ -17992,17 +17996,17 @@ MX_END_VISIT_STMT(ImaginaryLiteral) MX_BEGIN_VISIT_STMT(GenericSelectionExpr) MX_ENTER_VISIT_GenericSelectionExpr MX_VISIT_BASE(GenericSelectionExpr, Expr) - MX_VISIT_ENTITY_LIST(GenericSelectionExpr, association_expressions, 15, MX_APPLY_METHOD, AssociationExpressions, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(GenericSelectionExpr, controlling_expression, 38, MX_APPLY_METHOD, ControllingExpression, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(GenericSelectionExpr, controlling_type, 39, MX_APPLY_METHOD, ControllingType, Type, NthStmt) - MX_VISIT_ENTITY(GenericSelectionExpr, default_token, 40, MX_APPLY_METHOD, DefaultToken, Token, NthStmt) - MX_VISIT_ENTITY(GenericSelectionExpr, generic_token, 41, MX_APPLY_METHOD, GenericToken, Token, NthStmt) - MX_VISIT_ENTITY(GenericSelectionExpr, r_paren_token, 42, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(GenericSelectionExpr, result_expression, 43, MX_APPLY_METHOD, ResultExpression, Expr, NthStmt) - MX_VISIT_INT(GenericSelectionExpr, result_index, 26, MX_APPLY_METHOD, ResultIndex, uint32_t, NthStmt) - MX_VISIT_BOOL(GenericSelectionExpr, is_expression_predicate, 84, MX_APPLY_METHOD, IsExpressionPredicate, bool, NthStmt) - MX_VISIT_BOOL(GenericSelectionExpr, is_result_dependent, 85, MX_APPLY_METHOD, IsResultDependent, bool, NthStmt) - MX_VISIT_BOOL(GenericSelectionExpr, is_type_predicate, 86, MX_APPLY_METHOD, IsTypePredicate, bool, NthStmt) + MX_VISIT_ENTITY_LIST(GenericSelectionExpr, association_expressions, 16, MX_APPLY_METHOD, AssociationExpressions, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(GenericSelectionExpr, controlling_expression, 39, MX_APPLY_METHOD, ControllingExpression, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(GenericSelectionExpr, controlling_type, 40, MX_APPLY_METHOD, ControllingType, Type, NthStmt) + MX_VISIT_ENTITY(GenericSelectionExpr, default_token, 41, MX_APPLY_METHOD, DefaultToken, Token, NthStmt) + MX_VISIT_ENTITY(GenericSelectionExpr, generic_token, 42, MX_APPLY_METHOD, GenericToken, Token, NthStmt) + MX_VISIT_ENTITY(GenericSelectionExpr, r_paren_token, 43, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(GenericSelectionExpr, result_expression, 44, MX_APPLY_METHOD, ResultExpression, Expr, NthStmt) + MX_VISIT_INT(GenericSelectionExpr, result_index, 27, MX_APPLY_METHOD, ResultIndex, uint32_t, NthStmt) + MX_VISIT_BOOL(GenericSelectionExpr, is_expression_predicate, 85, MX_APPLY_METHOD, IsExpressionPredicate, bool, NthStmt) + MX_VISIT_BOOL(GenericSelectionExpr, is_result_dependent, 86, MX_APPLY_METHOD, IsResultDependent, bool, NthStmt) + MX_VISIT_BOOL(GenericSelectionExpr, is_type_predicate, 87, MX_APPLY_METHOD, IsTypePredicate, bool, NthStmt) MX_EXIT_VISIT_GenericSelectionExpr MX_END_VISIT_STMT(GenericSelectionExpr) @@ -18016,7 +18020,7 @@ MX_END_VISIT_STMT(GenericSelectionExpr) MX_BEGIN_VISIT_STMT(GNUNullExpr) MX_ENTER_VISIT_GNUNullExpr MX_VISIT_BASE(GNUNullExpr, Expr) - MX_VISIT_ENTITY(GNUNullExpr, token_token, 38, MX_APPLY_METHOD, TokenToken, Token, NthStmt) + MX_VISIT_ENTITY(GNUNullExpr, token_token, 39, MX_APPLY_METHOD, TokenToken, Token, NthStmt) MX_EXIT_VISIT_GNUNullExpr MX_END_VISIT_STMT(GNUNullExpr) @@ -18030,9 +18034,9 @@ MX_END_VISIT_STMT(GNUNullExpr) MX_BEGIN_VISIT_STMT(FunctionParmPackExpr) MX_ENTER_VISIT_FunctionParmPackExpr MX_VISIT_BASE(FunctionParmPackExpr, Expr) - MX_VISIT_ENTITY(FunctionParmPackExpr, parameter_pack, 38, MX_APPLY_METHOD, ParameterPack, VarDecl, NthStmt) - MX_VISIT_ENTITY(FunctionParmPackExpr, parameter_pack_token, 39, MX_APPLY_METHOD, ParameterPackToken, Token, NthStmt) - MX_VISIT_ENTITY_LIST(FunctionParmPackExpr, expansions, 15, MX_APPLY_METHOD, Expansions, VarDecl, NthStmt) + MX_VISIT_ENTITY(FunctionParmPackExpr, parameter_pack, 39, MX_APPLY_METHOD, ParameterPack, VarDecl, NthStmt) + MX_VISIT_ENTITY(FunctionParmPackExpr, parameter_pack_token, 40, MX_APPLY_METHOD, ParameterPackToken, Token, NthStmt) + MX_VISIT_ENTITY_LIST(FunctionParmPackExpr, expansions, 16, MX_APPLY_METHOD, Expansions, VarDecl, NthStmt) MX_EXIT_VISIT_FunctionParmPackExpr MX_END_VISIT_STMT(FunctionParmPackExpr) @@ -18046,7 +18050,7 @@ MX_END_VISIT_STMT(FunctionParmPackExpr) MX_BEGIN_VISIT_ABSTRACT_STMT(FullExpr) MX_ENTER_VISIT_FullExpr MX_VISIT_BASE(FullExpr, Expr) - MX_VISIT_ENTITY(FullExpr, sub_expression, 38, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) + MX_VISIT_ENTITY(FullExpr, sub_expression, 39, MX_APPLY_METHOD, SubExpression, Expr, NthStmt) MX_EXIT_VISIT_FullExpr MX_END_VISIT_STMT(FullExpr) @@ -18060,7 +18064,7 @@ MX_END_VISIT_STMT(FullExpr) MX_BEGIN_VISIT_STMT(ExprWithCleanups) MX_ENTER_VISIT_ExprWithCleanups MX_VISIT_BASE(ExprWithCleanups, FullExpr) - MX_VISIT_BOOL(ExprWithCleanups, cleanups_have_side_effects, 84, MX_APPLY_METHOD, CleanupsHaveSideEffects, bool, NthStmt) + MX_VISIT_BOOL(ExprWithCleanups, cleanups_have_side_effects, 85, MX_APPLY_METHOD, CleanupsHaveSideEffects, bool, NthStmt) MX_EXIT_VISIT_ExprWithCleanups MX_END_VISIT_STMT(ExprWithCleanups) @@ -18074,9 +18078,9 @@ MX_END_VISIT_STMT(ExprWithCleanups) MX_BEGIN_VISIT_STMT(ConstantExpr) MX_ENTER_VISIT_ConstantExpr MX_VISIT_BASE(ConstantExpr, FullExpr) - MX_VISIT_ENUM(ConstantExpr, result_storage_kind, 89, MX_APPLY_METHOD, ResultStorageKind, ConstantResultStorageKind, NthStmt) - MX_VISIT_BOOL(ConstantExpr, has_ap_value_result, 84, MX_APPLY_METHOD, HasAPValueResult, bool, NthStmt) - MX_VISIT_BOOL(ConstantExpr, is_immediate_invocation, 85, MX_APPLY_METHOD, IsImmediateInvocation, bool, NthStmt) + MX_VISIT_ENUM(ConstantExpr, result_storage_kind, 90, MX_APPLY_METHOD, ResultStorageKind, ConstantResultStorageKind, NthStmt) + MX_VISIT_BOOL(ConstantExpr, has_ap_value_result, 85, MX_APPLY_METHOD, HasAPValueResult, bool, NthStmt) + MX_VISIT_BOOL(ConstantExpr, is_immediate_invocation, 86, MX_APPLY_METHOD, IsImmediateInvocation, bool, NthStmt) MX_EXIT_VISIT_ConstantExpr MX_END_VISIT_STMT(ConstantExpr) @@ -18090,8 +18094,8 @@ MX_END_VISIT_STMT(ConstantExpr) MX_BEGIN_VISIT_STMT(FloatingLiteral) MX_ENTER_VISIT_FloatingLiteral MX_VISIT_BASE(FloatingLiteral, Expr) - MX_VISIT_ENTITY(FloatingLiteral, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_BOOL(FloatingLiteral, is_exact, 84, MX_APPLY_METHOD, IsExact, bool, NthStmt) + MX_VISIT_ENTITY(FloatingLiteral, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_BOOL(FloatingLiteral, is_exact, 85, MX_APPLY_METHOD, IsExact, bool, NthStmt) MX_EXIT_VISIT_FloatingLiteral MX_END_VISIT_STMT(FloatingLiteral) @@ -18105,8 +18109,8 @@ MX_END_VISIT_STMT(FloatingLiteral) MX_BEGIN_VISIT_STMT(FixedPointLiteral) MX_ENTER_VISIT_FixedPointLiteral MX_VISIT_BASE(FixedPointLiteral, Expr) - MX_VISIT_ENTITY(FixedPointLiteral, token, 38, MX_APPLY_METHOD, Token, Token, NthStmt) - MX_VISIT_INT(FixedPointLiteral, scale, 26, MX_APPLY_METHOD, Scale, uint32_t, NthStmt) + MX_VISIT_ENTITY(FixedPointLiteral, token, 39, MX_APPLY_METHOD, Token, Token, NthStmt) + MX_VISIT_INT(FixedPointLiteral, scale, 27, MX_APPLY_METHOD, Scale, uint32_t, NthStmt) MX_EXIT_VISIT_FixedPointLiteral MX_END_VISIT_STMT(FixedPointLiteral) @@ -18120,10 +18124,10 @@ MX_END_VISIT_STMT(FixedPointLiteral) MX_BEGIN_VISIT_STMT(ExtVectorElementExpr) MX_ENTER_VISIT_ExtVectorElementExpr MX_VISIT_BASE(ExtVectorElementExpr, Expr) - MX_VISIT_BOOL(ExtVectorElementExpr, contains_duplicate_elements, 84, MX_APPLY_METHOD, ContainsDuplicateElements, bool, NthStmt) - MX_VISIT_ENTITY(ExtVectorElementExpr, accessor_token, 38, MX_APPLY_METHOD, AccessorToken, Token, NthStmt) - MX_VISIT_ENTITY(ExtVectorElementExpr, base, 39, MX_APPLY_METHOD, Base, Expr, NthStmt) - MX_VISIT_BOOL(ExtVectorElementExpr, is_arrow, 85, MX_APPLY_METHOD, IsArrow, bool, NthStmt) + MX_VISIT_BOOL(ExtVectorElementExpr, contains_duplicate_elements, 85, MX_APPLY_METHOD, ContainsDuplicateElements, bool, NthStmt) + MX_VISIT_ENTITY(ExtVectorElementExpr, accessor_token, 39, MX_APPLY_METHOD, AccessorToken, Token, NthStmt) + MX_VISIT_ENTITY(ExtVectorElementExpr, base, 40, MX_APPLY_METHOD, Base, Expr, NthStmt) + MX_VISIT_BOOL(ExtVectorElementExpr, is_arrow, 86, MX_APPLY_METHOD, IsArrow, bool, NthStmt) MX_EXIT_VISIT_ExtVectorElementExpr MX_END_VISIT_STMT(ExtVectorElementExpr) @@ -18137,9 +18141,9 @@ MX_END_VISIT_STMT(ExtVectorElementExpr) MX_BEGIN_VISIT_STMT(ExpressionTraitExpr) MX_ENTER_VISIT_ExpressionTraitExpr MX_VISIT_BASE(ExpressionTraitExpr, Expr) - MX_VISIT_ENTITY(ExpressionTraitExpr, queried_expression, 38, MX_APPLY_METHOD, QueriedExpression, Expr, NthStmt) - MX_VISIT_ENUM(ExpressionTraitExpr, trait, 89, MX_APPLY_METHOD, Trait, ExpressionTrait, NthStmt) - MX_VISIT_BOOL(ExpressionTraitExpr, value, 84, MX_APPLY_METHOD, Value, bool, NthStmt) + MX_VISIT_ENTITY(ExpressionTraitExpr, queried_expression, 39, MX_APPLY_METHOD, QueriedExpression, Expr, NthStmt) + MX_VISIT_ENUM(ExpressionTraitExpr, trait, 90, MX_APPLY_METHOD, Trait, ExpressionTrait, NthStmt) + MX_VISIT_BOOL(ExpressionTraitExpr, value, 85, MX_APPLY_METHOD, Value, bool, NthStmt) MX_EXIT_VISIT_ExpressionTraitExpr MX_END_VISIT_STMT(ExpressionTraitExpr) @@ -18153,9 +18157,9 @@ MX_END_VISIT_STMT(ExpressionTraitExpr) MX_BEGIN_VISIT_STMT(AttributedStmt) MX_ENTER_VISIT_AttributedStmt MX_VISIT_BASE(AttributedStmt, ValueStmt) - MX_VISIT_ENTITY(AttributedStmt, attribute_token, 10, MX_APPLY_METHOD, AttributeToken, Token, NthStmt) - MX_VISIT_ENTITY_LIST(AttributedStmt, attributes, 15, MX_APPLY_METHOD, Attributes, Attr, NthStmt) - MX_VISIT_ENTITY(AttributedStmt, sub_statement, 11, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(AttributedStmt, attribute_token, 11, MX_APPLY_METHOD, AttributeToken, Token, NthStmt) + MX_VISIT_ENTITY_LIST(AttributedStmt, attributes, 16, MX_APPLY_METHOD, Attributes, Attr, NthStmt) + MX_VISIT_ENTITY(AttributedStmt, sub_statement, 12, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) MX_EXIT_VISIT_AttributedStmt MX_END_VISIT_STMT(AttributedStmt) @@ -18169,18 +18173,18 @@ MX_END_VISIT_STMT(AttributedStmt) MX_BEGIN_VISIT_STMT(SwitchStmt) MX_ENTER_VISIT_SwitchStmt MX_VISIT_BASE(SwitchStmt, Stmt) - MX_VISIT_ENTITY(SwitchStmt, body, 9, MX_APPLY_METHOD, Body, Stmt, NthStmt) - MX_VISIT_ENTITY(SwitchStmt, condition, 10, MX_APPLY_METHOD, Condition, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, condition_variable, 11, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, condition_variable_declaration_statement, 13, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, initializer, 14, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) - MX_VISIT_ENTITY(SwitchStmt, l_paren_token, 17, MX_APPLY_METHOD, LParenToken, Token, NthStmt) - MX_VISIT_ENTITY(SwitchStmt, r_paren_token, 18, MX_APPLY_METHOD, RParenToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, first_switch_case, 19, MX_APPLY_METHOD, FirstSwitchCase, SwitchCase, NthStmt) - MX_VISIT_ENTITY(SwitchStmt, switch_token, 20, MX_APPLY_METHOD, SwitchToken, Token, NthStmt) - MX_VISIT_BOOL(SwitchStmt, has_initializer_storage, 12, MX_APPLY_METHOD, HasInitializerStorage, bool, NthStmt) - MX_VISIT_BOOL(SwitchStmt, has_variable_storage, 16, MX_APPLY_METHOD, HasVariableStorage, bool, NthStmt) - MX_VISIT_BOOL(SwitchStmt, is_all_enum_cases_covered, 23, MX_APPLY_METHOD, IsAllEnumCasesCovered, bool, NthStmt) + MX_VISIT_ENTITY(SwitchStmt, body, 10, MX_APPLY_METHOD, Body, Stmt, NthStmt) + MX_VISIT_ENTITY(SwitchStmt, condition, 11, MX_APPLY_METHOD, Condition, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, condition_variable, 12, MX_APPLY_METHOD, ConditionVariable, VarDecl, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, condition_variable_declaration_statement, 14, MX_APPLY_METHOD, ConditionVariableDeclarationStatement, DeclStmt, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, initializer, 15, MX_APPLY_METHOD, Initializer, Stmt, NthStmt) + MX_VISIT_ENTITY(SwitchStmt, l_paren_token, 18, MX_APPLY_METHOD, LParenToken, Token, NthStmt) + MX_VISIT_ENTITY(SwitchStmt, r_paren_token, 19, MX_APPLY_METHOD, RParenToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(SwitchStmt, first_switch_case, 20, MX_APPLY_METHOD, FirstSwitchCase, SwitchCase, NthStmt) + MX_VISIT_ENTITY(SwitchStmt, switch_token, 21, MX_APPLY_METHOD, SwitchToken, Token, NthStmt) + MX_VISIT_BOOL(SwitchStmt, has_initializer_storage, 13, MX_APPLY_METHOD, HasInitializerStorage, bool, NthStmt) + MX_VISIT_BOOL(SwitchStmt, has_variable_storage, 17, MX_APPLY_METHOD, HasVariableStorage, bool, NthStmt) + MX_VISIT_BOOL(SwitchStmt, is_all_enum_cases_covered, 24, MX_APPLY_METHOD, IsAllEnumCasesCovered, bool, NthStmt) MX_EXIT_VISIT_SwitchStmt MX_END_VISIT_STMT(SwitchStmt) @@ -18194,10 +18198,10 @@ MX_END_VISIT_STMT(SwitchStmt) MX_BEGIN_VISIT_ABSTRACT_STMT(SwitchCase) MX_ENTER_VISIT_SwitchCase MX_VISIT_BASE(SwitchCase, Stmt) - MX_VISIT_ENTITY(SwitchCase, colon_token, 9, MX_APPLY_METHOD, ColonToken, Token, NthStmt) - MX_VISIT_ENTITY(SwitchCase, keyword_token, 10, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(SwitchCase, next_switch_case, 11, MX_APPLY_METHOD, NextSwitchCase, SwitchCase, NthStmt) - MX_VISIT_ENTITY(SwitchCase, sub_statement, 13, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) + MX_VISIT_ENTITY(SwitchCase, colon_token, 10, MX_APPLY_METHOD, ColonToken, Token, NthStmt) + MX_VISIT_ENTITY(SwitchCase, keyword_token, 11, MX_APPLY_METHOD, KeywordToken, Token, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(SwitchCase, next_switch_case, 12, MX_APPLY_METHOD, NextSwitchCase, SwitchCase, NthStmt) + MX_VISIT_ENTITY(SwitchCase, sub_statement, 14, MX_APPLY_METHOD, SubStatement, Stmt, NthStmt) MX_EXIT_VISIT_SwitchCase MX_END_VISIT_STMT(SwitchCase) @@ -18211,7 +18215,7 @@ MX_END_VISIT_STMT(SwitchCase) MX_BEGIN_VISIT_STMT(DefaultStmt) MX_ENTER_VISIT_DefaultStmt MX_VISIT_BASE(DefaultStmt, SwitchCase) - MX_VISIT_ENTITY(DefaultStmt, default_token, 14, MX_APPLY_METHOD, DefaultToken, Token, NthStmt) + MX_VISIT_ENTITY(DefaultStmt, default_token, 15, MX_APPLY_METHOD, DefaultToken, Token, NthStmt) MX_EXIT_VISIT_DefaultStmt MX_END_VISIT_STMT(DefaultStmt) @@ -18225,11 +18229,11 @@ MX_END_VISIT_STMT(DefaultStmt) MX_BEGIN_VISIT_STMT(CaseStmt) MX_ENTER_VISIT_CaseStmt MX_VISIT_BASE(CaseStmt, SwitchCase) - MX_VISIT_BOOL(CaseStmt, case_statement_is_gnu_range, 12, MX_APPLY_METHOD, CaseStatementIsGNURange, bool, NthStmt) - MX_VISIT_ENTITY(CaseStmt, case_token, 14, MX_APPLY_METHOD, CaseToken, Token, NthStmt) - MX_VISIT_ENTITY(CaseStmt, ellipsis_token, 17, MX_APPLY_METHOD, EllipsisToken, Token, NthStmt) - MX_VISIT_ENTITY(CaseStmt, lhs, 18, MX_APPLY_METHOD, LHS, Expr, NthStmt) - MX_VISIT_OPTIONAL_ENTITY(CaseStmt, rhs, 19, MX_APPLY_METHOD, RHS, Expr, NthStmt) + MX_VISIT_BOOL(CaseStmt, case_statement_is_gnu_range, 13, MX_APPLY_METHOD, CaseStatementIsGNURange, bool, NthStmt) + MX_VISIT_ENTITY(CaseStmt, case_token, 15, MX_APPLY_METHOD, CaseToken, Token, NthStmt) + MX_VISIT_ENTITY(CaseStmt, ellipsis_token, 18, MX_APPLY_METHOD, EllipsisToken, Token, NthStmt) + MX_VISIT_ENTITY(CaseStmt, lhs, 19, MX_APPLY_METHOD, LHS, Expr, NthStmt) + MX_VISIT_OPTIONAL_ENTITY(CaseStmt, rhs, 20, MX_APPLY_METHOD, RHS, Expr, NthStmt) MX_EXIT_VISIT_CaseStmt MX_END_VISIT_STMT(CaseStmt) @@ -18244,42 +18248,43 @@ MX_BEGIN_VISIT_ABSTRACT_DECL(Decl) MX_ENTER_VISIT_Decl MX_VISIT_DECL_LINK(Decl, parent_declaration, 0) MX_VISIT_STMT_LINK(Decl, parent_statement, 1) - MX_VISIT_BOOL(Decl, is_definition, 2, MX_APPLY_FUNC, IsDefinition, bool, NthDecl) - MX_VISIT_ENTITY_LIST(Decl, attributes, 3, MX_APPLY_METHOD, Attributes, Attr, NthDecl) - MX_VISIT_ENUM(Decl, availability, 4, MX_APPLY_METHOD, Availability, AvailabilityResult, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(Decl, defining_attribute, 5, MX_APPLY_METHOD, DefiningAttribute, Attr, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(Decl, external_source_symbol_attribute, 6, MX_APPLY_METHOD, ExternalSourceSymbolAttribute, ExternalSourceSymbolAttr, NthDecl) - MX_VISIT_ENUM(Decl, friend_object_kind, 7, MX_APPLY_METHOD, FriendObjectKind, DeclFriendObjectKind, NthDecl) - MX_VISIT_OPTIONAL_INT(Decl, max_alignment, 8, MX_APPLY_METHOD, MaxAlignment, , NthDecl) - MX_VISIT_ENUM(Decl, module_ownership_kind, 10, MX_APPLY_METHOD, ModuleOwnershipKind, DeclModuleOwnershipKind, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(Decl, non_closure_context, 11, MX_APPLY_METHOD, NonClosureContext, Decl, NthDecl) - MX_VISIT_INT(Decl, owning_module_id, 12, MX_APPLY_METHOD, OwningModuleID, uint32_t, NthDecl) - MX_VISIT_INT(Decl, template_depth, 13, MX_APPLY_METHOD, TemplateDepth, uint32_t, NthDecl) - MX_VISIT_BOOL(Decl, is_deprecated, 14, MX_APPLY_METHOD, IsDeprecated, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_file_context_declaration, 15, MX_APPLY_METHOD, IsFileContextDeclaration, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_function_or_function_template, 16, MX_APPLY_METHOD, IsFunctionOrFunctionTemplate, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_implicit, 17, MX_APPLY_METHOD, IsImplicit, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_in_anonymous_namespace, 18, MX_APPLY_METHOD, IsInAnonymousNamespace, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_in_another_module_unit, 19, MX_APPLY_METHOD, IsInAnotherModuleUnit, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_in_export_declaration_context, 20, MX_APPLY_METHOD, IsInExportDeclarationContext, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_in_std_namespace, 21, MX_APPLY_METHOD, IsInStdNamespace, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_invisible_outside_the_owning_module, 22, MX_APPLY_METHOD, IsInvisibleOutsideTheOwningModule, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_local_extern_declaration, 23, MX_APPLY_METHOD, IsLocalExternDeclaration, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_module_private, 24, MX_APPLY_METHOD, IsModulePrivate, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_out_of_line, 25, MX_APPLY_METHOD, IsOutOfLine, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_parameter_pack, 26, MX_APPLY_METHOD, IsParameterPack, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_template_declaration, 27, MX_APPLY_METHOD, IsTemplateDeclaration, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_template_parameter, 28, MX_APPLY_METHOD, IsTemplateParameter, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_template_parameter_pack, 29, MX_APPLY_METHOD, IsTemplateParameterPack, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_templated, 30, MX_APPLY_METHOD, IsTemplated, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_top_level_declaration_in_obj_c_container, 31, MX_APPLY_METHOD, IsTopLevelDeclarationInObjCContainer, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_unavailable, 32, MX_APPLY_METHOD, IsUnavailable, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_unconditionally_visible, 33, MX_APPLY_METHOD, IsUnconditionallyVisible, bool, NthDecl) - MX_VISIT_BOOL(Decl, is_weak_imported, 34, MX_APPLY_METHOD, IsWeakImported, bool, NthDecl) - MX_VISIT_ENUM(Decl, kind, 35, MX_APPLY_METHOD, Kind, DeclKind, NthDecl) - MX_VISIT_ENUM(Decl, category, 36, MX_APPLY_METHOD, Category, DeclCategory, NthDecl) - MX_VISIT_ENTITY(Decl, token, 37, MX_APPLY_METHOD, Token, Token, NthDecl) - MX_VISIT_TOKEN_RANGE(Decl, tokens, 38, 39, NthDecl) + MX_VISIT_ENTITY_ID(Decl, ir, 2) + MX_VISIT_BOOL(Decl, is_definition, 3, MX_APPLY_FUNC, IsDefinition, bool, NthDecl) + MX_VISIT_ENTITY_LIST(Decl, attributes, 4, MX_APPLY_METHOD, Attributes, Attr, NthDecl) + MX_VISIT_ENUM(Decl, availability, 5, MX_APPLY_METHOD, Availability, AvailabilityResult, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(Decl, defining_attribute, 6, MX_APPLY_METHOD, DefiningAttribute, Attr, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(Decl, external_source_symbol_attribute, 7, MX_APPLY_METHOD, ExternalSourceSymbolAttribute, ExternalSourceSymbolAttr, NthDecl) + MX_VISIT_ENUM(Decl, friend_object_kind, 8, MX_APPLY_METHOD, FriendObjectKind, DeclFriendObjectKind, NthDecl) + MX_VISIT_OPTIONAL_INT(Decl, max_alignment, 9, MX_APPLY_METHOD, MaxAlignment, , NthDecl) + MX_VISIT_ENUM(Decl, module_ownership_kind, 11, MX_APPLY_METHOD, ModuleOwnershipKind, DeclModuleOwnershipKind, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(Decl, non_closure_context, 12, MX_APPLY_METHOD, NonClosureContext, Decl, NthDecl) + MX_VISIT_INT(Decl, owning_module_id, 13, MX_APPLY_METHOD, OwningModuleID, uint32_t, NthDecl) + MX_VISIT_INT(Decl, template_depth, 14, MX_APPLY_METHOD, TemplateDepth, uint32_t, NthDecl) + MX_VISIT_BOOL(Decl, is_deprecated, 15, MX_APPLY_METHOD, IsDeprecated, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_file_context_declaration, 16, MX_APPLY_METHOD, IsFileContextDeclaration, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_function_or_function_template, 17, MX_APPLY_METHOD, IsFunctionOrFunctionTemplate, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_implicit, 18, MX_APPLY_METHOD, IsImplicit, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_in_anonymous_namespace, 19, MX_APPLY_METHOD, IsInAnonymousNamespace, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_in_another_module_unit, 20, MX_APPLY_METHOD, IsInAnotherModuleUnit, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_in_export_declaration_context, 21, MX_APPLY_METHOD, IsInExportDeclarationContext, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_in_std_namespace, 22, MX_APPLY_METHOD, IsInStdNamespace, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_invisible_outside_the_owning_module, 23, MX_APPLY_METHOD, IsInvisibleOutsideTheOwningModule, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_local_extern_declaration, 24, MX_APPLY_METHOD, IsLocalExternDeclaration, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_module_private, 25, MX_APPLY_METHOD, IsModulePrivate, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_out_of_line, 26, MX_APPLY_METHOD, IsOutOfLine, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_parameter_pack, 27, MX_APPLY_METHOD, IsParameterPack, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_template_declaration, 28, MX_APPLY_METHOD, IsTemplateDeclaration, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_template_parameter, 29, MX_APPLY_METHOD, IsTemplateParameter, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_template_parameter_pack, 30, MX_APPLY_METHOD, IsTemplateParameterPack, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_templated, 31, MX_APPLY_METHOD, IsTemplated, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_top_level_declaration_in_obj_c_container, 32, MX_APPLY_METHOD, IsTopLevelDeclarationInObjCContainer, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_unavailable, 33, MX_APPLY_METHOD, IsUnavailable, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_unconditionally_visible, 34, MX_APPLY_METHOD, IsUnconditionallyVisible, bool, NthDecl) + MX_VISIT_BOOL(Decl, is_weak_imported, 35, MX_APPLY_METHOD, IsWeakImported, bool, NthDecl) + MX_VISIT_ENUM(Decl, kind, 36, MX_APPLY_METHOD, Kind, DeclKind, NthDecl) + MX_VISIT_ENUM(Decl, category, 37, MX_APPLY_METHOD, Category, DeclCategory, NthDecl) + MX_VISIT_ENTITY(Decl, token, 38, MX_APPLY_METHOD, Token, Token, NthDecl) + MX_VISIT_TOKEN_RANGE(Decl, tokens, 39, 40, NthDecl) MX_EXIT_VISIT_Decl MX_END_VISIT_DECL(Decl) @@ -18293,11 +18298,11 @@ MX_END_VISIT_DECL(Decl) MX_BEGIN_VISIT_DECL(CapturedDecl) MX_ENTER_VISIT_CapturedDecl MX_VISIT_BASE(CapturedDecl, Decl) - MX_VISIT_ENTITY(CapturedDecl, context_parameter, 40, MX_APPLY_METHOD, ContextParameter, ImplicitParamDecl, NthDecl) - MX_VISIT_INT(CapturedDecl, context_parameter_position, 41, MX_APPLY_METHOD, ContextParameterPosition, uint32_t, NthDecl) - MX_VISIT_BOOL(CapturedDecl, is_nothrow, 42, MX_APPLY_METHOD, IsNothrow, bool, NthDecl) - MX_VISIT_ENTITY_LIST(CapturedDecl, parameters, 43, MX_APPLY_METHOD, Parameters, ImplicitParamDecl, NthDecl) - MX_VISIT_DECL_CONTEXT(CapturedDecl, contained_declarations, 44, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_ENTITY(CapturedDecl, context_parameter, 41, MX_APPLY_METHOD, ContextParameter, ImplicitParamDecl, NthDecl) + MX_VISIT_INT(CapturedDecl, context_parameter_position, 42, MX_APPLY_METHOD, ContextParameterPosition, uint32_t, NthDecl) + MX_VISIT_BOOL(CapturedDecl, is_nothrow, 43, MX_APPLY_METHOD, IsNothrow, bool, NthDecl) + MX_VISIT_ENTITY_LIST(CapturedDecl, parameters, 44, MX_APPLY_METHOD, Parameters, ImplicitParamDecl, NthDecl) + MX_VISIT_DECL_CONTEXT(CapturedDecl, contained_declarations, 45, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_CapturedDecl MX_END_VISIT_DECL(CapturedDecl) @@ -18311,21 +18316,21 @@ MX_END_VISIT_DECL(CapturedDecl) MX_BEGIN_VISIT_DECL(BlockDecl) MX_ENTER_VISIT_BlockDecl MX_VISIT_BASE(BlockDecl, Decl) - MX_VISIT_BOOL(BlockDecl, block_missing_return_type, 42, MX_APPLY_METHOD, BlockMissingReturnType, bool, NthDecl) - MX_VISIT_BOOL(BlockDecl, can_avoid_copy_to_heap, 45, MX_APPLY_METHOD, CanAvoidCopyToHeap, bool, NthDecl) - MX_VISIT_BOOL(BlockDecl, captures_cxx_this, 46, MX_APPLY_METHOD, CapturesCXXThis, bool, NthDecl) - MX_VISIT_BOOL(BlockDecl, does_not_escape, 47, MX_APPLY_METHOD, DoesNotEscape, bool, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(BlockDecl, block_mangling_context_declaration, 40, MX_APPLY_METHOD, BlockManglingContextDeclaration, Decl, NthDecl) - MX_VISIT_INT(BlockDecl, block_mangling_number, 41, MX_APPLY_METHOD, BlockManglingNumber, uint32_t, NthDecl) - MX_VISIT_ENTITY(BlockDecl, caret_token, 48, MX_APPLY_METHOD, CaretToken, Token, NthDecl) - MX_VISIT_ENTITY(BlockDecl, compound_body, 49, MX_APPLY_METHOD, CompoundBody, CompoundStmt, NthDecl) - MX_VISIT_ENTITY(BlockDecl, signature_as_written, 50, MX_APPLY_METHOD, SignatureAsWritten, Type, NthDecl) - MX_VISIT_BOOL(BlockDecl, has_captures, 51, MX_APPLY_METHOD, HasCaptures, bool, NthDecl) - MX_VISIT_BOOL(BlockDecl, is_conversion_from_lambda, 52, MX_APPLY_METHOD, IsConversionFromLambda, bool, NthDecl) - MX_VISIT_BOOL(BlockDecl, is_variadic, 53, MX_APPLY_METHOD, IsVariadic, bool, NthDecl) - MX_VISIT_ENTITY_LIST(BlockDecl, parameters, 43, MX_APPLY_METHOD, Parameters, ParmVarDecl, NthDecl) - MX_VISIT_ENTITY_LIST(BlockDecl, parameter_declarations, 44, MX_APPLY_METHOD, ParameterDeclarations, ParmVarDecl, NthDecl) - MX_VISIT_DECL_CONTEXT(BlockDecl, contained_declarations, 54, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_BOOL(BlockDecl, block_missing_return_type, 43, MX_APPLY_METHOD, BlockMissingReturnType, bool, NthDecl) + MX_VISIT_BOOL(BlockDecl, can_avoid_copy_to_heap, 46, MX_APPLY_METHOD, CanAvoidCopyToHeap, bool, NthDecl) + MX_VISIT_BOOL(BlockDecl, captures_cxx_this, 47, MX_APPLY_METHOD, CapturesCXXThis, bool, NthDecl) + MX_VISIT_BOOL(BlockDecl, does_not_escape, 48, MX_APPLY_METHOD, DoesNotEscape, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(BlockDecl, block_mangling_context_declaration, 41, MX_APPLY_METHOD, BlockManglingContextDeclaration, Decl, NthDecl) + MX_VISIT_INT(BlockDecl, block_mangling_number, 42, MX_APPLY_METHOD, BlockManglingNumber, uint32_t, NthDecl) + MX_VISIT_ENTITY(BlockDecl, caret_token, 49, MX_APPLY_METHOD, CaretToken, Token, NthDecl) + MX_VISIT_ENTITY(BlockDecl, compound_body, 50, MX_APPLY_METHOD, CompoundBody, CompoundStmt, NthDecl) + MX_VISIT_ENTITY(BlockDecl, signature_as_written, 51, MX_APPLY_METHOD, SignatureAsWritten, Type, NthDecl) + MX_VISIT_BOOL(BlockDecl, has_captures, 52, MX_APPLY_METHOD, HasCaptures, bool, NthDecl) + MX_VISIT_BOOL(BlockDecl, is_conversion_from_lambda, 53, MX_APPLY_METHOD, IsConversionFromLambda, bool, NthDecl) + MX_VISIT_BOOL(BlockDecl, is_variadic, 54, MX_APPLY_METHOD, IsVariadic, bool, NthDecl) + MX_VISIT_ENTITY_LIST(BlockDecl, parameters, 44, MX_APPLY_METHOD, Parameters, ParmVarDecl, NthDecl) + MX_VISIT_ENTITY_LIST(BlockDecl, parameter_declarations, 45, MX_APPLY_METHOD, ParameterDeclarations, ParmVarDecl, NthDecl) + MX_VISIT_DECL_CONTEXT(BlockDecl, contained_declarations, 55, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_BlockDecl MX_END_VISIT_DECL(BlockDecl) @@ -18339,8 +18344,8 @@ MX_END_VISIT_DECL(BlockDecl) MX_BEGIN_VISIT_DECL(AccessSpecDecl) MX_ENTER_VISIT_AccessSpecDecl MX_VISIT_BASE(AccessSpecDecl, Decl) - MX_VISIT_ENTITY(AccessSpecDecl, access_specifier_token, 40, MX_APPLY_METHOD, AccessSpecifierToken, Token, NthDecl) - MX_VISIT_ENTITY(AccessSpecDecl, colon_token, 48, MX_APPLY_METHOD, ColonToken, Token, NthDecl) + MX_VISIT_ENTITY(AccessSpecDecl, access_specifier_token, 41, MX_APPLY_METHOD, AccessSpecifierToken, Token, NthDecl) + MX_VISIT_ENTITY(AccessSpecDecl, colon_token, 49, MX_APPLY_METHOD, ColonToken, Token, NthDecl) MX_EXIT_VISIT_AccessSpecDecl MX_END_VISIT_DECL(AccessSpecDecl) @@ -18367,7 +18372,7 @@ MX_END_VISIT_DECL(OMPDeclarativeDirectiveDecl) MX_BEGIN_VISIT_DECL(OMPThreadPrivateDecl) MX_ENTER_VISIT_OMPThreadPrivateDecl MX_VISIT_BASE(OMPThreadPrivateDecl, OMPDeclarativeDirectiveDecl) - MX_VISIT_ENTITY_LIST(OMPThreadPrivateDecl, varlists, 43, MX_APPLY_METHOD, Varlists, Expr, NthDecl) + MX_VISIT_ENTITY_LIST(OMPThreadPrivateDecl, varlists, 44, MX_APPLY_METHOD, Varlists, Expr, NthDecl) MX_EXIT_VISIT_OMPThreadPrivateDecl MX_END_VISIT_DECL(OMPThreadPrivateDecl) @@ -18394,7 +18399,7 @@ MX_END_VISIT_DECL(OMPRequiresDecl) MX_BEGIN_VISIT_DECL(OMPAllocateDecl) MX_ENTER_VISIT_OMPAllocateDecl MX_VISIT_BASE(OMPAllocateDecl, OMPDeclarativeDirectiveDecl) - MX_VISIT_ENTITY_LIST(OMPAllocateDecl, varlists, 43, MX_APPLY_METHOD, Varlists, Expr, NthDecl) + MX_VISIT_ENTITY_LIST(OMPAllocateDecl, varlists, 44, MX_APPLY_METHOD, Varlists, Expr, NthDecl) MX_EXIT_VISIT_OMPAllocateDecl MX_END_VISIT_DECL(OMPAllocateDecl) @@ -18407,7 +18412,7 @@ MX_END_VISIT_DECL(OMPAllocateDecl) MX_BEGIN_VISIT_DECL(TranslationUnitDecl) MX_ENTER_VISIT_TranslationUnitDecl - MX_VISIT_DECL_CONTEXT(TranslationUnitDecl, contained_declarations, 43, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_DECL_CONTEXT(TranslationUnitDecl, contained_declarations, 44, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_TranslationUnitDecl MX_END_VISIT_DECL(TranslationUnitDecl) @@ -18421,8 +18426,8 @@ MX_END_VISIT_DECL(TranslationUnitDecl) MX_BEGIN_VISIT_DECL(TopLevelStmtDecl) MX_ENTER_VISIT_TopLevelStmtDecl MX_VISIT_BASE(TopLevelStmtDecl, Decl) - MX_VISIT_ENTITY(TopLevelStmtDecl, statement, 40, MX_APPLY_METHOD, Statement, Stmt, NthDecl) - MX_VISIT_BOOL(TopLevelStmtDecl, is_semi_missing, 42, MX_APPLY_METHOD, IsSemiMissing, bool, NthDecl) + MX_VISIT_ENTITY(TopLevelStmtDecl, statement, 41, MX_APPLY_METHOD, Statement, Stmt, NthDecl) + MX_VISIT_BOOL(TopLevelStmtDecl, is_semi_missing, 43, MX_APPLY_METHOD, IsSemiMissing, bool, NthDecl) MX_EXIT_VISIT_TopLevelStmtDecl MX_END_VISIT_DECL(TopLevelStmtDecl) @@ -18436,10 +18441,10 @@ MX_END_VISIT_DECL(TopLevelStmtDecl) MX_BEGIN_VISIT_DECL(StaticAssertDecl) MX_ENTER_VISIT_StaticAssertDecl MX_VISIT_BASE(StaticAssertDecl, Decl) - MX_VISIT_ENTITY(StaticAssertDecl, assert_expression, 40, MX_APPLY_METHOD, AssertExpression, Expr, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(StaticAssertDecl, message, 48, MX_APPLY_METHOD, Message, Expr, NthDecl) - MX_VISIT_ENTITY(StaticAssertDecl, r_paren_token, 49, MX_APPLY_METHOD, RParenToken, Token, NthDecl) - MX_VISIT_BOOL(StaticAssertDecl, is_failed, 42, MX_APPLY_METHOD, IsFailed, bool, NthDecl) + MX_VISIT_ENTITY(StaticAssertDecl, assert_expression, 41, MX_APPLY_METHOD, AssertExpression, Expr, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(StaticAssertDecl, message, 49, MX_APPLY_METHOD, Message, Expr, NthDecl) + MX_VISIT_ENTITY(StaticAssertDecl, r_paren_token, 50, MX_APPLY_METHOD, RParenToken, Token, NthDecl) + MX_VISIT_BOOL(StaticAssertDecl, is_failed, 43, MX_APPLY_METHOD, IsFailed, bool, NthDecl) MX_EXIT_VISIT_StaticAssertDecl MX_END_VISIT_DECL(StaticAssertDecl) @@ -18453,7 +18458,7 @@ MX_END_VISIT_DECL(StaticAssertDecl) MX_BEGIN_VISIT_DECL(RequiresExprBodyDecl) MX_ENTER_VISIT_RequiresExprBodyDecl MX_VISIT_BASE(RequiresExprBodyDecl, Decl) - MX_VISIT_DECL_CONTEXT(RequiresExprBodyDecl, contained_declarations, 43, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_DECL_CONTEXT(RequiresExprBodyDecl, contained_declarations, 44, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_RequiresExprBodyDecl MX_END_VISIT_DECL(RequiresExprBodyDecl) @@ -18467,8 +18472,8 @@ MX_END_VISIT_DECL(RequiresExprBodyDecl) MX_BEGIN_VISIT_DECL(PragmaDetectMismatchDecl) MX_ENTER_VISIT_PragmaDetectMismatchDecl MX_VISIT_BASE(PragmaDetectMismatchDecl, Decl) - MX_VISIT_TEXT(PragmaDetectMismatchDecl, name, 55, MX_APPLY_METHOD, Name, basic_string_view, NthDecl) - MX_VISIT_TEXT(PragmaDetectMismatchDecl, value, 56, MX_APPLY_METHOD, Value, basic_string_view, NthDecl) + MX_VISIT_TEXT(PragmaDetectMismatchDecl, name, 56, MX_APPLY_METHOD, Name, basic_string_view, NthDecl) + MX_VISIT_TEXT(PragmaDetectMismatchDecl, value, 57, MX_APPLY_METHOD, Value, basic_string_view, NthDecl) MX_EXIT_VISIT_PragmaDetectMismatchDecl MX_END_VISIT_DECL(PragmaDetectMismatchDecl) @@ -18482,8 +18487,8 @@ MX_END_VISIT_DECL(PragmaDetectMismatchDecl) MX_BEGIN_VISIT_DECL(PragmaCommentDecl) MX_ENTER_VISIT_PragmaCommentDecl MX_VISIT_BASE(PragmaCommentDecl, Decl) - MX_VISIT_TEXT(PragmaCommentDecl, argument, 55, MX_APPLY_METHOD, Argument, basic_string_view, NthDecl) - MX_VISIT_ENUM(PragmaCommentDecl, comment_kind, 57, MX_APPLY_METHOD, CommentKind, PragmaMSCommentKind, NthDecl) + MX_VISIT_TEXT(PragmaCommentDecl, argument, 56, MX_APPLY_METHOD, Argument, basic_string_view, NthDecl) + MX_VISIT_ENUM(PragmaCommentDecl, comment_kind, 58, MX_APPLY_METHOD, CommentKind, PragmaMSCommentKind, NthDecl) MX_EXIT_VISIT_PragmaCommentDecl MX_END_VISIT_DECL(PragmaCommentDecl) @@ -18497,15 +18502,15 @@ MX_END_VISIT_DECL(PragmaCommentDecl) MX_BEGIN_VISIT_DECL(ObjCPropertyImplDecl) MX_ENTER_VISIT_ObjCPropertyImplDecl MX_VISIT_BASE(ObjCPropertyImplDecl, Decl) - MX_VISIT_ENTITY(ObjCPropertyImplDecl, getter_cxx_constructor, 40, MX_APPLY_METHOD, GetterCXXConstructor, Expr, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyImplDecl, getter_method_declaration, 48, MX_APPLY_METHOD, GetterMethodDeclaration, ObjCMethodDecl, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyImplDecl, property_declaration, 49, MX_APPLY_METHOD, PropertyDeclaration, ObjCPropertyDecl, NthDecl) - MX_VISIT_ENUM(ObjCPropertyImplDecl, property_implementation, 57, MX_APPLY_METHOD, PropertyImplementation, ObjCPropertyImplDeclKind, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyImplDecl, property_instance_variable_declaration, 50, MX_APPLY_METHOD, PropertyInstanceVariableDeclaration, ObjCIvarDecl, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyImplDecl, property_instance_variable_declaration_token, 58, MX_APPLY_METHOD, PropertyInstanceVariableDeclarationToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyImplDecl, setter_cxx_assignment, 59, MX_APPLY_METHOD, SetterCXXAssignment, Expr, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyImplDecl, setter_method_declaration, 60, MX_APPLY_METHOD, SetterMethodDeclaration, ObjCMethodDecl, NthDecl) - MX_VISIT_BOOL(ObjCPropertyImplDecl, is_instance_variable_name_specified, 42, MX_APPLY_METHOD, IsInstanceVariableNameSpecified, bool, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyImplDecl, getter_cxx_constructor, 41, MX_APPLY_METHOD, GetterCXXConstructor, Expr, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyImplDecl, getter_method_declaration, 49, MX_APPLY_METHOD, GetterMethodDeclaration, ObjCMethodDecl, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyImplDecl, property_declaration, 50, MX_APPLY_METHOD, PropertyDeclaration, ObjCPropertyDecl, NthDecl) + MX_VISIT_ENUM(ObjCPropertyImplDecl, property_implementation, 58, MX_APPLY_METHOD, PropertyImplementation, ObjCPropertyImplDeclKind, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyImplDecl, property_instance_variable_declaration, 51, MX_APPLY_METHOD, PropertyInstanceVariableDeclaration, ObjCIvarDecl, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyImplDecl, property_instance_variable_declaration_token, 59, MX_APPLY_METHOD, PropertyInstanceVariableDeclarationToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyImplDecl, setter_cxx_assignment, 60, MX_APPLY_METHOD, SetterCXXAssignment, Expr, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyImplDecl, setter_method_declaration, 61, MX_APPLY_METHOD, SetterMethodDeclaration, ObjCMethodDecl, NthDecl) + MX_VISIT_BOOL(ObjCPropertyImplDecl, is_instance_variable_name_specified, 43, MX_APPLY_METHOD, IsInstanceVariableNameSpecified, bool, NthDecl) MX_EXIT_VISIT_ObjCPropertyImplDecl MX_END_VISIT_DECL(ObjCPropertyImplDecl) @@ -18519,19 +18524,19 @@ MX_END_VISIT_DECL(ObjCPropertyImplDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(NamedDecl) MX_ENTER_VISIT_NamedDecl MX_VISIT_BASE(NamedDecl, Decl) - MX_VISIT_ENUM(NamedDecl, formal_linkage, 57, MX_APPLY_METHOD, FormalLinkage, Linkage, NthDecl) - MX_VISIT_TEXT(NamedDecl, name, 55, MX_APPLY_FUNC, Name, basic_string, NthDecl) - MX_VISIT_OPTIONAL_ENUM(NamedDecl, obj_cf_string_formatting_family, 61, MX_APPLY_METHOD, ObjCFStringFormattingFamily, ObjCStringFormatFamily, NthDecl) - MX_VISIT_ENTITY(NamedDecl, underlying_declaration, 40, MX_APPLY_METHOD, UnderlyingDeclaration, NamedDecl, NthDecl) - MX_VISIT_OPTIONAL_ENUM(NamedDecl, visibility, 62, MX_APPLY_METHOD, Visibility, Visibility, NthDecl) - MX_VISIT_BOOL(NamedDecl, has_external_formal_linkage, 46, MX_APPLY_METHOD, HasExternalFormalLinkage, bool, NthDecl) - MX_VISIT_BOOL(NamedDecl, has_linkage, 47, MX_APPLY_METHOD, HasLinkage, bool, NthDecl) - MX_VISIT_BOOL(NamedDecl, has_linkage_been_computed, 51, MX_APPLY_METHOD, HasLinkageBeenComputed, bool, NthDecl) - MX_VISIT_BOOL(NamedDecl, is_cxx_class_member, 52, MX_APPLY_METHOD, IsCXXClassMember, bool, NthDecl) - MX_VISIT_BOOL(NamedDecl, is_cxx_instance_member, 53, MX_APPLY_METHOD, IsCXXInstanceMember, bool, NthDecl) - MX_VISIT_BOOL(NamedDecl, is_externally_declarable, 63, MX_APPLY_METHOD, IsExternallyDeclarable, bool, NthDecl) - MX_VISIT_BOOL(NamedDecl, is_externally_visible, 64, MX_APPLY_METHOD, IsExternallyVisible, bool, NthDecl) - MX_VISIT_BOOL(NamedDecl, is_linkage_valid, 65, MX_APPLY_METHOD, IsLinkageValid, bool, NthDecl) + MX_VISIT_ENUM(NamedDecl, formal_linkage, 58, MX_APPLY_METHOD, FormalLinkage, Linkage, NthDecl) + MX_VISIT_TEXT(NamedDecl, name, 56, MX_APPLY_FUNC, Name, basic_string, NthDecl) + MX_VISIT_OPTIONAL_ENUM(NamedDecl, obj_cf_string_formatting_family, 62, MX_APPLY_METHOD, ObjCFStringFormattingFamily, ObjCStringFormatFamily, NthDecl) + MX_VISIT_ENTITY(NamedDecl, underlying_declaration, 41, MX_APPLY_METHOD, UnderlyingDeclaration, NamedDecl, NthDecl) + MX_VISIT_OPTIONAL_ENUM(NamedDecl, visibility, 63, MX_APPLY_METHOD, Visibility, Visibility, NthDecl) + MX_VISIT_BOOL(NamedDecl, has_external_formal_linkage, 47, MX_APPLY_METHOD, HasExternalFormalLinkage, bool, NthDecl) + MX_VISIT_BOOL(NamedDecl, has_linkage, 48, MX_APPLY_METHOD, HasLinkage, bool, NthDecl) + MX_VISIT_BOOL(NamedDecl, has_linkage_been_computed, 52, MX_APPLY_METHOD, HasLinkageBeenComputed, bool, NthDecl) + MX_VISIT_BOOL(NamedDecl, is_cxx_class_member, 53, MX_APPLY_METHOD, IsCXXClassMember, bool, NthDecl) + MX_VISIT_BOOL(NamedDecl, is_cxx_instance_member, 54, MX_APPLY_METHOD, IsCXXInstanceMember, bool, NthDecl) + MX_VISIT_BOOL(NamedDecl, is_externally_declarable, 64, MX_APPLY_METHOD, IsExternallyDeclarable, bool, NthDecl) + MX_VISIT_BOOL(NamedDecl, is_externally_visible, 65, MX_APPLY_METHOD, IsExternallyVisible, bool, NthDecl) + MX_VISIT_BOOL(NamedDecl, is_linkage_valid, 66, MX_APPLY_METHOD, IsLinkageValid, bool, NthDecl) MX_EXIT_VISIT_NamedDecl MX_END_VISIT_DECL(NamedDecl) @@ -18545,11 +18550,11 @@ MX_END_VISIT_DECL(NamedDecl) MX_BEGIN_VISIT_DECL(LabelDecl) MX_ENTER_VISIT_LabelDecl MX_VISIT_BASE(LabelDecl, NamedDecl) - MX_VISIT_TEXT(LabelDecl, ms_assembly_label, 56, MX_APPLY_METHOD, MSAssemblyLabel, basic_string_view, NthDecl) - MX_VISIT_ENTITY(LabelDecl, statement, 48, MX_APPLY_METHOD, Statement, LabelStmt, NthDecl) - MX_VISIT_BOOL(LabelDecl, is_gnu_local, 66, MX_APPLY_METHOD, IsGnuLocal, bool, NthDecl) - MX_VISIT_BOOL(LabelDecl, is_ms_assembly_label, 67, MX_APPLY_METHOD, IsMSAssemblyLabel, bool, NthDecl) - MX_VISIT_BOOL(LabelDecl, is_resolved_ms_assembly_label, 68, MX_APPLY_METHOD, IsResolvedMSAssemblyLabel, bool, NthDecl) + MX_VISIT_TEXT(LabelDecl, ms_assembly_label, 57, MX_APPLY_METHOD, MSAssemblyLabel, basic_string_view, NthDecl) + MX_VISIT_ENTITY(LabelDecl, statement, 49, MX_APPLY_METHOD, Statement, LabelStmt, NthDecl) + MX_VISIT_BOOL(LabelDecl, is_gnu_local, 67, MX_APPLY_METHOD, IsGnuLocal, bool, NthDecl) + MX_VISIT_BOOL(LabelDecl, is_ms_assembly_label, 68, MX_APPLY_METHOD, IsMSAssemblyLabel, bool, NthDecl) + MX_VISIT_BOOL(LabelDecl, is_resolved_ms_assembly_label, 69, MX_APPLY_METHOD, IsResolvedMSAssemblyLabel, bool, NthDecl) MX_EXIT_VISIT_LabelDecl MX_END_VISIT_DECL(LabelDecl) @@ -18563,10 +18568,10 @@ MX_END_VISIT_DECL(LabelDecl) MX_BEGIN_VISIT_DECL(HLSLBufferDecl) MX_ENTER_VISIT_HLSLBufferDecl MX_VISIT_BASE(HLSLBufferDecl, NamedDecl) - MX_VISIT_ENTITY(HLSLBufferDecl, l_brace_token, 48, MX_APPLY_METHOD, LBraceToken, Token, NthDecl) - MX_VISIT_ENTITY(HLSLBufferDecl, token_start, 49, MX_APPLY_METHOD, TokenStart, Token, NthDecl) - MX_VISIT_ENTITY(HLSLBufferDecl, r_brace_token, 50, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) - MX_VISIT_BOOL(HLSLBufferDecl, is_c_buffer, 66, MX_APPLY_METHOD, IsCBuffer, bool, NthDecl) + MX_VISIT_ENTITY(HLSLBufferDecl, l_brace_token, 49, MX_APPLY_METHOD, LBraceToken, Token, NthDecl) + MX_VISIT_ENTITY(HLSLBufferDecl, token_start, 50, MX_APPLY_METHOD, TokenStart, Token, NthDecl) + MX_VISIT_ENTITY(HLSLBufferDecl, r_brace_token, 51, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) + MX_VISIT_BOOL(HLSLBufferDecl, is_c_buffer, 67, MX_APPLY_METHOD, IsCBuffer, bool, NthDecl) MX_EXIT_VISIT_HLSLBufferDecl MX_END_VISIT_DECL(HLSLBufferDecl) @@ -18580,7 +18585,7 @@ MX_END_VISIT_DECL(HLSLBufferDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(BaseUsingDecl) MX_ENTER_VISIT_BaseUsingDecl MX_VISIT_BASE(BaseUsingDecl, NamedDecl) - MX_VISIT_ENTITY_LIST(BaseUsingDecl, shadows, 43, MX_APPLY_METHOD, Shadows, UsingShadowDecl, NthDecl) + MX_VISIT_ENTITY_LIST(BaseUsingDecl, shadows, 44, MX_APPLY_METHOD, Shadows, UsingShadowDecl, NthDecl) MX_EXIT_VISIT_BaseUsingDecl MX_END_VISIT_DECL(BaseUsingDecl) @@ -18594,10 +18599,10 @@ MX_END_VISIT_DECL(BaseUsingDecl) MX_BEGIN_VISIT_DECL(UsingEnumDecl) MX_ENTER_VISIT_UsingEnumDecl MX_VISIT_BASE(UsingEnumDecl, BaseUsingDecl) - MX_VISIT_ENTITY(UsingEnumDecl, enum_declaration, 48, MX_APPLY_METHOD, EnumDeclaration, EnumDecl, NthDecl) - MX_VISIT_ENTITY(UsingEnumDecl, enum_token, 49, MX_APPLY_METHOD, EnumToken, Token, NthDecl) - MX_VISIT_ENTITY(UsingEnumDecl, enum_type, 50, MX_APPLY_METHOD, EnumType, Type, NthDecl) - MX_VISIT_ENTITY(UsingEnumDecl, using_token, 58, MX_APPLY_METHOD, UsingToken, Token, NthDecl) + MX_VISIT_ENTITY(UsingEnumDecl, enum_declaration, 49, MX_APPLY_METHOD, EnumDeclaration, EnumDecl, NthDecl) + MX_VISIT_ENTITY(UsingEnumDecl, enum_token, 50, MX_APPLY_METHOD, EnumToken, Token, NthDecl) + MX_VISIT_ENTITY(UsingEnumDecl, enum_type, 51, MX_APPLY_METHOD, EnumType, Type, NthDecl) + MX_VISIT_ENTITY(UsingEnumDecl, using_token, 59, MX_APPLY_METHOD, UsingToken, Token, NthDecl) MX_EXIT_VISIT_UsingEnumDecl MX_END_VISIT_DECL(UsingEnumDecl) @@ -18611,9 +18616,9 @@ MX_END_VISIT_DECL(UsingEnumDecl) MX_BEGIN_VISIT_DECL(UsingDecl) MX_ENTER_VISIT_UsingDecl MX_VISIT_BASE(UsingDecl, BaseUsingDecl) - MX_VISIT_ENTITY(UsingDecl, using_token, 48, MX_APPLY_METHOD, UsingToken, Token, NthDecl) - MX_VISIT_BOOL(UsingDecl, has_typename, 66, MX_APPLY_METHOD, HasTypename, bool, NthDecl) - MX_VISIT_BOOL(UsingDecl, is_access_declaration, 67, MX_APPLY_METHOD, IsAccessDeclaration, bool, NthDecl) + MX_VISIT_ENTITY(UsingDecl, using_token, 49, MX_APPLY_METHOD, UsingToken, Token, NthDecl) + MX_VISIT_BOOL(UsingDecl, has_typename, 67, MX_APPLY_METHOD, HasTypename, bool, NthDecl) + MX_VISIT_BOOL(UsingDecl, is_access_declaration, 68, MX_APPLY_METHOD, IsAccessDeclaration, bool, NthDecl) MX_EXIT_VISIT_UsingDecl MX_END_VISIT_DECL(UsingDecl) @@ -18627,10 +18632,10 @@ MX_END_VISIT_DECL(UsingDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(ValueDecl) MX_ENTER_VISIT_ValueDecl MX_VISIT_BASE(ValueDecl, NamedDecl) - MX_VISIT_OPTIONAL_ENTITY(ValueDecl, potentially_decomposed_variable_declaration, 48, MX_APPLY_METHOD, PotentiallyDecomposedVariableDeclaration, VarDecl, NthDecl) - MX_VISIT_ENTITY(ValueDecl, type, 49, MX_APPLY_METHOD, Type, Type, NthDecl) - MX_VISIT_BOOL(ValueDecl, is_initializer_capture, 66, MX_APPLY_METHOD, IsInitializerCapture, bool, NthDecl) - MX_VISIT_BOOL(ValueDecl, is_weak, 67, MX_APPLY_METHOD, IsWeak, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(ValueDecl, potentially_decomposed_variable_declaration, 49, MX_APPLY_METHOD, PotentiallyDecomposedVariableDeclaration, VarDecl, NthDecl) + MX_VISIT_ENTITY(ValueDecl, type, 50, MX_APPLY_METHOD, Type, Type, NthDecl) + MX_VISIT_BOOL(ValueDecl, is_initializer_capture, 67, MX_APPLY_METHOD, IsInitializerCapture, bool, NthDecl) + MX_VISIT_BOOL(ValueDecl, is_weak, 68, MX_APPLY_METHOD, IsWeak, bool, NthDecl) MX_EXIT_VISIT_ValueDecl MX_END_VISIT_DECL(ValueDecl) @@ -18644,10 +18649,10 @@ MX_END_VISIT_DECL(ValueDecl) MX_BEGIN_VISIT_DECL(UnresolvedUsingValueDecl) MX_ENTER_VISIT_UnresolvedUsingValueDecl MX_VISIT_BASE(UnresolvedUsingValueDecl, ValueDecl) - MX_VISIT_ENTITY(UnresolvedUsingValueDecl, ellipsis_token, 50, MX_APPLY_METHOD, EllipsisToken, Token, NthDecl) - MX_VISIT_ENTITY(UnresolvedUsingValueDecl, using_token, 58, MX_APPLY_METHOD, UsingToken, Token, NthDecl) - MX_VISIT_BOOL(UnresolvedUsingValueDecl, is_access_declaration, 68, MX_APPLY_METHOD, IsAccessDeclaration, bool, NthDecl) - MX_VISIT_BOOL(UnresolvedUsingValueDecl, is_pack_expansion, 69, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) + MX_VISIT_ENTITY(UnresolvedUsingValueDecl, ellipsis_token, 51, MX_APPLY_METHOD, EllipsisToken, Token, NthDecl) + MX_VISIT_ENTITY(UnresolvedUsingValueDecl, using_token, 59, MX_APPLY_METHOD, UsingToken, Token, NthDecl) + MX_VISIT_BOOL(UnresolvedUsingValueDecl, is_access_declaration, 69, MX_APPLY_METHOD, IsAccessDeclaration, bool, NthDecl) + MX_VISIT_BOOL(UnresolvedUsingValueDecl, is_pack_expansion, 70, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) MX_EXIT_VISIT_UnresolvedUsingValueDecl MX_END_VISIT_DECL(UnresolvedUsingValueDecl) @@ -18687,14 +18692,14 @@ MX_END_VISIT_DECL(TemplateParamObjectDecl) MX_BEGIN_VISIT_DECL(OMPDeclareReductionDecl) MX_ENTER_VISIT_OMPDeclareReductionDecl MX_VISIT_BASE(OMPDeclareReductionDecl, ValueDecl) - MX_VISIT_ENTITY(OMPDeclareReductionDecl, combiner, 50, MX_APPLY_METHOD, Combiner, Expr, NthDecl) - MX_VISIT_ENTITY(OMPDeclareReductionDecl, combiner_in, 58, MX_APPLY_METHOD, CombinerIn, Expr, NthDecl) - MX_VISIT_ENTITY(OMPDeclareReductionDecl, combiner_out, 59, MX_APPLY_METHOD, CombinerOut, Expr, NthDecl) - MX_VISIT_ENTITY(OMPDeclareReductionDecl, initializer_original, 60, MX_APPLY_METHOD, InitializerOriginal, Expr, NthDecl) - MX_VISIT_ENTITY(OMPDeclareReductionDecl, initializer_private, 70, MX_APPLY_METHOD, InitializerPrivate, Expr, NthDecl) - MX_VISIT_ENTITY(OMPDeclareReductionDecl, initializer, 71, MX_APPLY_METHOD, Initializer, Expr, NthDecl) - MX_VISIT_ENUM(OMPDeclareReductionDecl, initializer_kind, 72, MX_APPLY_METHOD, InitializerKind, OMPDeclareReductionInitKind, NthDecl) - MX_VISIT_DECL_CONTEXT(OMPDeclareReductionDecl, contained_declarations, 43, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_ENTITY(OMPDeclareReductionDecl, combiner, 51, MX_APPLY_METHOD, Combiner, Expr, NthDecl) + MX_VISIT_ENTITY(OMPDeclareReductionDecl, combiner_in, 59, MX_APPLY_METHOD, CombinerIn, Expr, NthDecl) + MX_VISIT_ENTITY(OMPDeclareReductionDecl, combiner_out, 60, MX_APPLY_METHOD, CombinerOut, Expr, NthDecl) + MX_VISIT_ENTITY(OMPDeclareReductionDecl, initializer_original, 61, MX_APPLY_METHOD, InitializerOriginal, Expr, NthDecl) + MX_VISIT_ENTITY(OMPDeclareReductionDecl, initializer_private, 71, MX_APPLY_METHOD, InitializerPrivate, Expr, NthDecl) + MX_VISIT_ENTITY(OMPDeclareReductionDecl, initializer, 72, MX_APPLY_METHOD, Initializer, Expr, NthDecl) + MX_VISIT_ENUM(OMPDeclareReductionDecl, initializer_kind, 73, MX_APPLY_METHOD, InitializerKind, OMPDeclareReductionInitKind, NthDecl) + MX_VISIT_DECL_CONTEXT(OMPDeclareReductionDecl, contained_declarations, 44, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_OMPDeclareReductionDecl MX_END_VISIT_DECL(OMPDeclareReductionDecl) @@ -18721,10 +18726,10 @@ MX_END_VISIT_DECL(MSGuidDecl) MX_BEGIN_VISIT_DECL(IndirectFieldDecl) MX_ENTER_VISIT_IndirectFieldDecl MX_VISIT_BASE(IndirectFieldDecl, ValueDecl) - MX_VISIT_ENTITY_LIST(IndirectFieldDecl, chain, 43, MX_APPLY_METHOD, Chain, NamedDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(IndirectFieldDecl, anonymous_field, 50, MX_APPLY_METHOD, AnonymousField, FieldDecl, NthDecl) - MX_VISIT_INT(IndirectFieldDecl, chaining_size, 41, MX_APPLY_METHOD, ChainingSize, uint32_t, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(IndirectFieldDecl, variable_declaration, 58, MX_APPLY_METHOD, VariableDeclaration, VarDecl, NthDecl) + MX_VISIT_ENTITY_LIST(IndirectFieldDecl, chain, 44, MX_APPLY_METHOD, Chain, NamedDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(IndirectFieldDecl, anonymous_field, 51, MX_APPLY_METHOD, AnonymousField, FieldDecl, NthDecl) + MX_VISIT_INT(IndirectFieldDecl, chaining_size, 42, MX_APPLY_METHOD, ChainingSize, uint32_t, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(IndirectFieldDecl, variable_declaration, 59, MX_APPLY_METHOD, VariableDeclaration, VarDecl, NthDecl) MX_EXIT_VISIT_IndirectFieldDecl MX_END_VISIT_DECL(IndirectFieldDecl) @@ -18738,7 +18743,7 @@ MX_END_VISIT_DECL(IndirectFieldDecl) MX_BEGIN_VISIT_DECL(EnumConstantDecl) MX_ENTER_VISIT_EnumConstantDecl MX_VISIT_BASE(EnumConstantDecl, ValueDecl) - MX_VISIT_OPTIONAL_ENTITY(EnumConstantDecl, initializer_expression, 50, MX_APPLY_METHOD, InitializerExpression, Expr, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(EnumConstantDecl, initializer_expression, 51, MX_APPLY_METHOD, InitializerExpression, Expr, NthDecl) MX_EXIT_VISIT_EnumConstantDecl MX_END_VISIT_DECL(EnumConstantDecl) @@ -18752,12 +18757,12 @@ MX_END_VISIT_DECL(EnumConstantDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(DeclaratorDecl) MX_ENTER_VISIT_DeclaratorDecl MX_VISIT_BASE(DeclaratorDecl, ValueDecl) - MX_VISIT_ENTITY(DeclaratorDecl, first_inner_token, 50, MX_APPLY_METHOD, FirstInnerToken, Token, NthDecl) - MX_VISIT_ENTITY(DeclaratorDecl, first_outer_token, 58, MX_APPLY_METHOD, FirstOuterToken, Token, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(DeclaratorDecl, trailing_requires_clause, 59, MX_APPLY_METHOD, TrailingRequiresClause, Expr, NthDecl) - MX_VISIT_ENTITY(DeclaratorDecl, type_spec_end_token, 60, MX_APPLY_METHOD, TypeSpecEndToken, Token, NthDecl) - MX_VISIT_ENTITY(DeclaratorDecl, type_spec_start_token, 70, MX_APPLY_METHOD, TypeSpecStartToken, Token, NthDecl) - MX_VISIT_ENTITY_LIST(DeclaratorDecl, template_parameter_lists, 43, MX_APPLY_METHOD, TemplateParameterLists, TemplateParameterList, NthDecl) + MX_VISIT_ENTITY(DeclaratorDecl, first_inner_token, 51, MX_APPLY_METHOD, FirstInnerToken, Token, NthDecl) + MX_VISIT_ENTITY(DeclaratorDecl, first_outer_token, 59, MX_APPLY_METHOD, FirstOuterToken, Token, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(DeclaratorDecl, trailing_requires_clause, 60, MX_APPLY_METHOD, TrailingRequiresClause, Expr, NthDecl) + MX_VISIT_ENTITY(DeclaratorDecl, type_spec_end_token, 61, MX_APPLY_METHOD, TypeSpecEndToken, Token, NthDecl) + MX_VISIT_ENTITY(DeclaratorDecl, type_spec_start_token, 71, MX_APPLY_METHOD, TypeSpecStartToken, Token, NthDecl) + MX_VISIT_ENTITY_LIST(DeclaratorDecl, template_parameter_lists, 44, MX_APPLY_METHOD, TemplateParameterLists, TemplateParameterList, NthDecl) MX_EXIT_VISIT_DeclaratorDecl MX_END_VISIT_DECL(DeclaratorDecl) @@ -18771,49 +18776,49 @@ MX_END_VISIT_DECL(DeclaratorDecl) MX_BEGIN_VISIT_DECL(VarDecl) MX_ENTER_VISIT_VarDecl MX_VISIT_BASE(VarDecl, DeclaratorDecl) - MX_VISIT_OPTIONAL_ENTITY(VarDecl, acting_definition, 71, MX_APPLY_METHOD, ActingDefinition, VarDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(VarDecl, described_variable_template, 73, MX_APPLY_METHOD, DescribedVariableTemplate, VarTemplateDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(VarDecl, initializer, 74, MX_APPLY_METHOD, Initializer, Expr, NthDecl) - MX_VISIT_ENUM(VarDecl, initializer_style, 72, MX_APPLY_METHOD, InitializerStyle, VarDeclInitializationStyle, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(VarDecl, initializing_declaration, 75, MX_APPLY_METHOD, InitializingDeclaration, VarDecl, NthDecl) - MX_VISIT_ENUM(VarDecl, language_linkage, 76, MX_APPLY_METHOD, LanguageLinkage, LanguageLinkage, NthDecl) - MX_VISIT_ENUM(VarDecl, storage_class, 77, MX_APPLY_METHOD, StorageClass, StorageClass, NthDecl) - MX_VISIT_ENUM(VarDecl, storage_duration, 78, MX_APPLY_METHOD, StorageDuration, StorageDuration, NthDecl) - MX_VISIT_ENUM(VarDecl, tls_kind, 79, MX_APPLY_METHOD, TLSKind, VarDeclTLSKind, NthDecl) - MX_VISIT_ENUM(VarDecl, tsc_spec, 80, MX_APPLY_METHOD, TSCSpec, ThreadStorageClassSpecifier, NthDecl) - MX_VISIT_BOOL(VarDecl, has_constant_initialization, 68, MX_APPLY_METHOD, HasConstantInitialization, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, has_dependent_alignment, 69, MX_APPLY_METHOD, HasDependentAlignment, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, has_external_storage, 81, MX_APPLY_METHOD, HasExternalStorage, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(VarDecl, has_flexible_array_initializer, 82, MX_APPLY_METHOD, HasFlexibleArrayInitializer, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, has_global_storage, 84, MX_APPLY_METHOD, HasGlobalStorage, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, has_initializer, 85, MX_APPLY_METHOD, HasInitializer, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, has_local_storage, 86, MX_APPLY_METHOD, HasLocalStorage, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_arc_pseudo_strong, 87, MX_APPLY_METHOD, IsARCPseudoStrong, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_cxx_for_range_declaration, 88, MX_APPLY_METHOD, IsCXXForRangeDeclaration, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_constexpr, 89, MX_APPLY_METHOD, IsConstexpr, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_direct_initializer, 90, MX_APPLY_METHOD, IsDirectInitializer, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_escaping_byref, 91, MX_APPLY_METHOD, IsEscapingByref, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_exception_variable, 92, MX_APPLY_METHOD, IsExceptionVariable, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_extern_c, 93, MX_APPLY_METHOD, IsExternC, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_file_variable_declaration, 94, MX_APPLY_METHOD, IsFileVariableDeclaration, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_function_or_method_variable_declaration, 95, MX_APPLY_METHOD, IsFunctionOrMethodVariableDeclaration, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_in_extern_c_context, 96, MX_APPLY_METHOD, IsInExternCContext, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_in_extern_cxx_context, 97, MX_APPLY_METHOD, IsInExternCXXContext, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_inline, 98, MX_APPLY_METHOD, IsInline, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_inline_specified, 99, MX_APPLY_METHOD, IsInlineSpecified, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_known_to_be_defined, 100, MX_APPLY_METHOD, IsKnownToBeDefined, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_local_variable_declaration, 101, MX_APPLY_METHOD, IsLocalVariableDeclaration, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_local_variable_declaration_or_parm, 102, MX_APPLY_METHOD, IsLocalVariableDeclarationOrParm, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_nrvo_variable, 103, MX_APPLY_METHOD, IsNRVOVariable, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_no_destroy, 104, MX_APPLY_METHOD, IsNoDestroy, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_non_escaping_byref, 105, MX_APPLY_METHOD, IsNonEscapingByref, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_obj_c_for_declaration, 106, MX_APPLY_METHOD, IsObjCForDeclaration, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_previous_declaration_in_same_block_scope, 107, MX_APPLY_METHOD, IsPreviousDeclarationInSameBlockScope, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_static_data_member, 108, MX_APPLY_METHOD, IsStaticDataMember, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_static_local, 109, MX_APPLY_METHOD, IsStaticLocal, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_this_declaration_a_demoted_definition, 110, MX_APPLY_METHOD, IsThisDeclarationADemotedDefinition, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, is_usable_in_constant_expressions, 111, MX_APPLY_METHOD, IsUsableInConstantExpressions, bool, NthDecl) - MX_VISIT_BOOL(VarDecl, might_be_usable_in_constant_expressions, 112, MX_APPLY_METHOD, MightBeUsableInConstantExpressions, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(VarDecl, acting_definition, 72, MX_APPLY_METHOD, ActingDefinition, VarDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(VarDecl, described_variable_template, 74, MX_APPLY_METHOD, DescribedVariableTemplate, VarTemplateDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(VarDecl, initializer, 75, MX_APPLY_METHOD, Initializer, Expr, NthDecl) + MX_VISIT_ENUM(VarDecl, initializer_style, 73, MX_APPLY_METHOD, InitializerStyle, VarDeclInitializationStyle, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(VarDecl, initializing_declaration, 76, MX_APPLY_METHOD, InitializingDeclaration, VarDecl, NthDecl) + MX_VISIT_ENUM(VarDecl, language_linkage, 77, MX_APPLY_METHOD, LanguageLinkage, LanguageLinkage, NthDecl) + MX_VISIT_ENUM(VarDecl, storage_class, 78, MX_APPLY_METHOD, StorageClass, StorageClass, NthDecl) + MX_VISIT_ENUM(VarDecl, storage_duration, 79, MX_APPLY_METHOD, StorageDuration, StorageDuration, NthDecl) + MX_VISIT_ENUM(VarDecl, tls_kind, 80, MX_APPLY_METHOD, TLSKind, VarDeclTLSKind, NthDecl) + MX_VISIT_ENUM(VarDecl, tsc_spec, 81, MX_APPLY_METHOD, TSCSpec, ThreadStorageClassSpecifier, NthDecl) + MX_VISIT_BOOL(VarDecl, has_constant_initialization, 69, MX_APPLY_METHOD, HasConstantInitialization, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, has_dependent_alignment, 70, MX_APPLY_METHOD, HasDependentAlignment, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, has_external_storage, 82, MX_APPLY_METHOD, HasExternalStorage, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(VarDecl, has_flexible_array_initializer, 83, MX_APPLY_METHOD, HasFlexibleArrayInitializer, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, has_global_storage, 85, MX_APPLY_METHOD, HasGlobalStorage, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, has_initializer, 86, MX_APPLY_METHOD, HasInitializer, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, has_local_storage, 87, MX_APPLY_METHOD, HasLocalStorage, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_arc_pseudo_strong, 88, MX_APPLY_METHOD, IsARCPseudoStrong, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_cxx_for_range_declaration, 89, MX_APPLY_METHOD, IsCXXForRangeDeclaration, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_constexpr, 90, MX_APPLY_METHOD, IsConstexpr, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_direct_initializer, 91, MX_APPLY_METHOD, IsDirectInitializer, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_escaping_byref, 92, MX_APPLY_METHOD, IsEscapingByref, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_exception_variable, 93, MX_APPLY_METHOD, IsExceptionVariable, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_extern_c, 94, MX_APPLY_METHOD, IsExternC, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_file_variable_declaration, 95, MX_APPLY_METHOD, IsFileVariableDeclaration, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_function_or_method_variable_declaration, 96, MX_APPLY_METHOD, IsFunctionOrMethodVariableDeclaration, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_in_extern_c_context, 97, MX_APPLY_METHOD, IsInExternCContext, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_in_extern_cxx_context, 98, MX_APPLY_METHOD, IsInExternCXXContext, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_inline, 99, MX_APPLY_METHOD, IsInline, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_inline_specified, 100, MX_APPLY_METHOD, IsInlineSpecified, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_known_to_be_defined, 101, MX_APPLY_METHOD, IsKnownToBeDefined, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_local_variable_declaration, 102, MX_APPLY_METHOD, IsLocalVariableDeclaration, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_local_variable_declaration_or_parm, 103, MX_APPLY_METHOD, IsLocalVariableDeclarationOrParm, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_nrvo_variable, 104, MX_APPLY_METHOD, IsNRVOVariable, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_no_destroy, 105, MX_APPLY_METHOD, IsNoDestroy, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_non_escaping_byref, 106, MX_APPLY_METHOD, IsNonEscapingByref, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_obj_c_for_declaration, 107, MX_APPLY_METHOD, IsObjCForDeclaration, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_previous_declaration_in_same_block_scope, 108, MX_APPLY_METHOD, IsPreviousDeclarationInSameBlockScope, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_static_data_member, 109, MX_APPLY_METHOD, IsStaticDataMember, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_static_local, 110, MX_APPLY_METHOD, IsStaticLocal, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_this_declaration_a_demoted_definition, 111, MX_APPLY_METHOD, IsThisDeclarationADemotedDefinition, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, is_usable_in_constant_expressions, 112, MX_APPLY_METHOD, IsUsableInConstantExpressions, bool, NthDecl) + MX_VISIT_BOOL(VarDecl, might_be_usable_in_constant_expressions, 113, MX_APPLY_METHOD, MightBeUsableInConstantExpressions, bool, NthDecl) MX_EXIT_VISIT_VarDecl MX_END_VISIT_DECL(VarDecl) @@ -18827,22 +18832,22 @@ MX_END_VISIT_DECL(VarDecl) MX_BEGIN_VISIT_DECL(ParmVarDecl) MX_ENTER_VISIT_ParmVarDecl MX_VISIT_BASE(ParmVarDecl, VarDecl) - MX_VISIT_OPTIONAL_ENTITY(ParmVarDecl, default_argument, 113, MX_APPLY_METHOD, DefaultArgument, Expr, NthDecl) - MX_VISIT_TOKEN_RANGE(ParmVarDecl, default_argument_range, 114, 115, NthDecl) - MX_VISIT_ENTITY(ParmVarDecl, explicit_object_parameter_this_token, 116, MX_APPLY_METHOD, ExplicitObjectParameterThisToken, Token, NthDecl) - MX_VISIT_INT(ParmVarDecl, depth, 41, MX_APPLY_METHOD, FunctionScopeDepth, uint32_t, NthDecl) - MX_VISIT_INT(ParmVarDecl, index, 117, MX_APPLY_METHOD, FunctionScopeIndex, uint32_t, NthDecl) - MX_VISIT_ENUM(ParmVarDecl, obj_c_decl_qualifier, 118, MX_APPLY_METHOD, ObjCDeclQualifier, DeclObjCDeclQualifier, NthDecl) - MX_VISIT_ENTITY(ParmVarDecl, original_type, 119, MX_APPLY_METHOD, OriginalType, Type, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(ParmVarDecl, uninstantiated_default_argument, 120, MX_APPLY_METHOD, UninstantiatedDefaultArgument, Expr, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, has_default_argument, 121, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, has_inherited_default_argument, 122, MX_APPLY_METHOD, HasInheritedDefaultArgument, bool, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, has_uninstantiated_default_argument, 123, MX_APPLY_METHOD, HasUninstantiatedDefaultArgument, bool, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, has_unparsed_default_argument, 124, MX_APPLY_METHOD, HasUnparsedDefaultArgument, bool, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, is_destroyed_in_callee, 125, MX_APPLY_METHOD, IsDestroyedInCallee, bool, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, is_explicit_object_parameter, 126, MX_APPLY_METHOD, IsExplicitObjectParameter, bool, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, is_knr_promoted, 127, MX_APPLY_METHOD, IsKNRPromoted, bool, NthDecl) - MX_VISIT_BOOL(ParmVarDecl, is_obj_c_method_parameter, 128, MX_APPLY_METHOD, IsObjCMethodParameter, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(ParmVarDecl, default_argument, 114, MX_APPLY_METHOD, DefaultArgument, Expr, NthDecl) + MX_VISIT_TOKEN_RANGE(ParmVarDecl, default_argument_range, 115, 116, NthDecl) + MX_VISIT_ENTITY(ParmVarDecl, explicit_object_parameter_this_token, 117, MX_APPLY_METHOD, ExplicitObjectParameterThisToken, Token, NthDecl) + MX_VISIT_INT(ParmVarDecl, depth, 42, MX_APPLY_METHOD, FunctionScopeDepth, uint32_t, NthDecl) + MX_VISIT_INT(ParmVarDecl, index, 118, MX_APPLY_METHOD, FunctionScopeIndex, uint32_t, NthDecl) + MX_VISIT_ENUM(ParmVarDecl, obj_c_decl_qualifier, 119, MX_APPLY_METHOD, ObjCDeclQualifier, DeclObjCDeclQualifier, NthDecl) + MX_VISIT_ENTITY(ParmVarDecl, original_type, 120, MX_APPLY_METHOD, OriginalType, Type, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(ParmVarDecl, uninstantiated_default_argument, 121, MX_APPLY_METHOD, UninstantiatedDefaultArgument, Expr, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, has_default_argument, 122, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, has_inherited_default_argument, 123, MX_APPLY_METHOD, HasInheritedDefaultArgument, bool, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, has_uninstantiated_default_argument, 124, MX_APPLY_METHOD, HasUninstantiatedDefaultArgument, bool, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, has_unparsed_default_argument, 125, MX_APPLY_METHOD, HasUnparsedDefaultArgument, bool, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, is_destroyed_in_callee, 126, MX_APPLY_METHOD, IsDestroyedInCallee, bool, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, is_explicit_object_parameter, 127, MX_APPLY_METHOD, IsExplicitObjectParameter, bool, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, is_knr_promoted, 128, MX_APPLY_METHOD, IsKNRPromoted, bool, NthDecl) + MX_VISIT_BOOL(ParmVarDecl, is_obj_c_method_parameter, 129, MX_APPLY_METHOD, IsObjCMethodParameter, bool, NthDecl) MX_EXIT_VISIT_ParmVarDecl MX_END_VISIT_DECL(ParmVarDecl) @@ -18869,7 +18874,7 @@ MX_END_VISIT_DECL(OMPCapturedExprDecl) MX_BEGIN_VISIT_DECL(ImplicitParamDecl) MX_ENTER_VISIT_ImplicitParamDecl MX_VISIT_BASE(ImplicitParamDecl, VarDecl) - MX_VISIT_ENUM(ImplicitParamDecl, parameter_kind, 118, MX_APPLY_METHOD, ParameterKind, ImplicitParamKind, NthDecl) + MX_VISIT_ENUM(ImplicitParamDecl, parameter_kind, 119, MX_APPLY_METHOD, ParameterKind, ImplicitParamKind, NthDecl) MX_EXIT_VISIT_ImplicitParamDecl MX_END_VISIT_DECL(ImplicitParamDecl) @@ -18883,7 +18888,7 @@ MX_END_VISIT_DECL(ImplicitParamDecl) MX_BEGIN_VISIT_DECL(DecompositionDecl) MX_ENTER_VISIT_DecompositionDecl MX_VISIT_BASE(DecompositionDecl, VarDecl) - MX_VISIT_ENTITY_LIST(DecompositionDecl, bindings, 44, MX_APPLY_METHOD, Bindings, BindingDecl, NthDecl) + MX_VISIT_ENTITY_LIST(DecompositionDecl, bindings, 45, MX_APPLY_METHOD, Bindings, BindingDecl, NthDecl) MX_EXIT_VISIT_DecompositionDecl MX_END_VISIT_DECL(DecompositionDecl) @@ -18897,14 +18902,14 @@ MX_END_VISIT_DECL(DecompositionDecl) MX_BEGIN_VISIT_DECL(VarTemplateSpecializationDecl) MX_ENTER_VISIT_VarTemplateSpecializationDecl MX_VISIT_BASE(VarTemplateSpecializationDecl, VarDecl) - MX_VISIT_ENTITY(VarTemplateSpecializationDecl, extern_token, 113, MX_APPLY_METHOD, ExternToken, Token, NthDecl) - MX_VISIT_ENUM(VarTemplateSpecializationDecl, specialization_kind, 118, MX_APPLY_METHOD, SpecializationKind, TemplateSpecializationKind, NthDecl) - MX_VISIT_ENTITY(VarTemplateSpecializationDecl, specialized_template, 114, MX_APPLY_METHOD, SpecializedTemplate, VarTemplateDecl, NthDecl) - MX_VISIT_ENTITY_LIST(VarTemplateSpecializationDecl, template_arguments, 44, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) - MX_VISIT_ENTITY(VarTemplateSpecializationDecl, template_keyword_token, 115, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthDecl) - MX_VISIT_BOOL(VarTemplateSpecializationDecl, is_class_scope_explicit_specialization, 121, MX_APPLY_METHOD, IsClassScopeExplicitSpecialization, bool, NthDecl) - MX_VISIT_BOOL(VarTemplateSpecializationDecl, is_explicit_instantiation_or_specialization, 122, MX_APPLY_METHOD, IsExplicitInstantiationOrSpecialization, bool, NthDecl) - MX_VISIT_BOOL(VarTemplateSpecializationDecl, is_explicit_specialization, 123, MX_APPLY_METHOD, IsExplicitSpecialization, bool, NthDecl) + MX_VISIT_ENTITY(VarTemplateSpecializationDecl, extern_token, 114, MX_APPLY_METHOD, ExternToken, Token, NthDecl) + MX_VISIT_ENUM(VarTemplateSpecializationDecl, specialization_kind, 119, MX_APPLY_METHOD, SpecializationKind, TemplateSpecializationKind, NthDecl) + MX_VISIT_ENTITY(VarTemplateSpecializationDecl, specialized_template, 115, MX_APPLY_METHOD, SpecializedTemplate, VarTemplateDecl, NthDecl) + MX_VISIT_ENTITY_LIST(VarTemplateSpecializationDecl, template_arguments, 45, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) + MX_VISIT_ENTITY(VarTemplateSpecializationDecl, template_keyword_token, 116, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthDecl) + MX_VISIT_BOOL(VarTemplateSpecializationDecl, is_class_scope_explicit_specialization, 122, MX_APPLY_METHOD, IsClassScopeExplicitSpecialization, bool, NthDecl) + MX_VISIT_BOOL(VarTemplateSpecializationDecl, is_explicit_instantiation_or_specialization, 123, MX_APPLY_METHOD, IsExplicitInstantiationOrSpecialization, bool, NthDecl) + MX_VISIT_BOOL(VarTemplateSpecializationDecl, is_explicit_specialization, 124, MX_APPLY_METHOD, IsExplicitSpecialization, bool, NthDecl) MX_EXIT_VISIT_VarTemplateSpecializationDecl MX_END_VISIT_DECL(VarTemplateSpecializationDecl) @@ -18918,8 +18923,8 @@ MX_END_VISIT_DECL(VarTemplateSpecializationDecl) MX_BEGIN_VISIT_DECL(VarTemplatePartialSpecializationDecl) MX_ENTER_VISIT_VarTemplatePartialSpecializationDecl MX_VISIT_BASE(VarTemplatePartialSpecializationDecl, VarTemplateSpecializationDecl) - MX_VISIT_ENTITY(VarTemplatePartialSpecializationDecl, template_parameters, 116, MX_APPLY_METHOD, TemplateParameters, TemplateParameterList, NthDecl) - MX_VISIT_BOOL(VarTemplatePartialSpecializationDecl, has_associated_constraints, 124, MX_APPLY_METHOD, HasAssociatedConstraints, bool, NthDecl) + MX_VISIT_ENTITY(VarTemplatePartialSpecializationDecl, template_parameters, 117, MX_APPLY_METHOD, TemplateParameters, TemplateParameterList, NthDecl) + MX_VISIT_BOOL(VarTemplatePartialSpecializationDecl, has_associated_constraints, 125, MX_APPLY_METHOD, HasAssociatedConstraints, bool, NthDecl) MX_EXIT_VISIT_VarTemplatePartialSpecializationDecl MX_END_VISIT_DECL(VarTemplatePartialSpecializationDecl) @@ -18933,15 +18938,15 @@ MX_END_VISIT_DECL(VarTemplatePartialSpecializationDecl) MX_BEGIN_VISIT_DECL(NonTypeTemplateParmDecl) MX_ENTER_VISIT_NonTypeTemplateParmDecl MX_VISIT_BASE(NonTypeTemplateParmDecl, DeclaratorDecl) - MX_VISIT_BOOL(NonTypeTemplateParmDecl, default_argument_was_inherited, 68, MX_APPLY_METHOD, DefaultArgumentWasInherited, bool, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(NonTypeTemplateParmDecl, default_argument, 71, MX_APPLY_METHOD, DefaultArgument, Expr, NthDecl) - MX_VISIT_ENTITY(NonTypeTemplateParmDecl, default_argument_token, 73, MX_APPLY_METHOD, DefaultArgumentToken, Token, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(NonTypeTemplateParmDecl, placeholder_type_constraint, 74, MX_APPLY_METHOD, PlaceholderTypeConstraint, Expr, NthDecl) - MX_VISIT_BOOL(NonTypeTemplateParmDecl, has_default_argument, 69, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) - MX_VISIT_BOOL(NonTypeTemplateParmDecl, has_placeholder_type_constraint, 81, MX_APPLY_METHOD, HasPlaceholderTypeConstraint, bool, NthDecl) - MX_VISIT_BOOL(NonTypeTemplateParmDecl, is_expanded_parameter_pack, 82, MX_APPLY_METHOD, IsExpandedParameterPack, bool, NthDecl) - MX_VISIT_BOOL(NonTypeTemplateParmDecl, is_pack_expansion, 83, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) - MX_VISIT_ENTITY_LIST(NonTypeTemplateParmDecl, expansion_types, 44, MX_APPLY_METHOD, ExpansionTypes, Type, NthDecl) + MX_VISIT_BOOL(NonTypeTemplateParmDecl, default_argument_was_inherited, 69, MX_APPLY_METHOD, DefaultArgumentWasInherited, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(NonTypeTemplateParmDecl, default_argument, 72, MX_APPLY_METHOD, DefaultArgument, Expr, NthDecl) + MX_VISIT_ENTITY(NonTypeTemplateParmDecl, default_argument_token, 74, MX_APPLY_METHOD, DefaultArgumentToken, Token, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(NonTypeTemplateParmDecl, placeholder_type_constraint, 75, MX_APPLY_METHOD, PlaceholderTypeConstraint, Expr, NthDecl) + MX_VISIT_BOOL(NonTypeTemplateParmDecl, has_default_argument, 70, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) + MX_VISIT_BOOL(NonTypeTemplateParmDecl, has_placeholder_type_constraint, 82, MX_APPLY_METHOD, HasPlaceholderTypeConstraint, bool, NthDecl) + MX_VISIT_BOOL(NonTypeTemplateParmDecl, is_expanded_parameter_pack, 83, MX_APPLY_METHOD, IsExpandedParameterPack, bool, NthDecl) + MX_VISIT_BOOL(NonTypeTemplateParmDecl, is_pack_expansion, 84, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) + MX_VISIT_ENTITY_LIST(NonTypeTemplateParmDecl, expansion_types, 45, MX_APPLY_METHOD, ExpansionTypes, Type, NthDecl) MX_EXIT_VISIT_NonTypeTemplateParmDecl MX_END_VISIT_DECL(NonTypeTemplateParmDecl) @@ -18955,8 +18960,8 @@ MX_END_VISIT_DECL(NonTypeTemplateParmDecl) MX_BEGIN_VISIT_DECL(MSPropertyDecl) MX_ENTER_VISIT_MSPropertyDecl MX_VISIT_BASE(MSPropertyDecl, DeclaratorDecl) - MX_VISIT_BOOL(MSPropertyDecl, has_getter, 68, MX_APPLY_METHOD, HasGetter, bool, NthDecl) - MX_VISIT_BOOL(MSPropertyDecl, has_setter, 69, MX_APPLY_METHOD, HasSetter, bool, NthDecl) + MX_VISIT_BOOL(MSPropertyDecl, has_getter, 69, MX_APPLY_METHOD, HasGetter, bool, NthDecl) + MX_VISIT_BOOL(MSPropertyDecl, has_setter, 70, MX_APPLY_METHOD, HasSetter, bool, NthDecl) MX_EXIT_VISIT_MSPropertyDecl MX_END_VISIT_DECL(MSPropertyDecl) @@ -18970,88 +18975,88 @@ MX_END_VISIT_DECL(MSPropertyDecl) MX_BEGIN_VISIT_DECL(FunctionDecl) MX_ENTER_VISIT_FunctionDecl MX_VISIT_BASE(FunctionDecl, DeclaratorDecl) - MX_VISIT_BOOL(FunctionDecl, body_contains_immediate_escalating_expressions, 68, MX_APPLY_METHOD, BodyContainsImmediateEscalatingExpressions, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, friend_constraint_refers_to_enclosing_template, 69, MX_APPLY_METHOD, FriendConstraintRefersToEnclosingTemplate, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, uses_fp_intrin, 81, MX_APPLY_METHOD, UsesFPIntrin, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(FunctionDecl, does_declaration_force_externally_visible_definition, 82, MX_APPLY_METHOD, DoesDeclarationForceExternallyVisibleDefinition, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, does_this_declaration_have_a_body, 84, MX_APPLY_METHOD, DoesThisDeclarationHaveABody, bool, NthDecl) - MX_VISIT_INT(FunctionDecl, builtin_id, 41, MX_APPLY_METHOD, BuiltinID, uint32_t, NthDecl) - MX_VISIT_ENTITY(FunctionDecl, call_result_type, 71, MX_APPLY_METHOD, CallResultType, Type, NthDecl) - MX_VISIT_ENUM(FunctionDecl, constexpr_kind, 72, MX_APPLY_METHOD, ConstexprKind, ConstexprSpecKind, NthDecl) - MX_VISIT_ENTITY(FunctionDecl, declared_return_type, 73, MX_APPLY_METHOD, DeclaredReturnType, Type, NthDecl) - MX_VISIT_ENTITY(FunctionDecl, default_token, 74, MX_APPLY_METHOD, DefaultToken, Token, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(FunctionDecl, described_function_template, 75, MX_APPLY_METHOD, DescribedFunctionTemplate, FunctionTemplateDecl, NthDecl) - MX_VISIT_ENTITY(FunctionDecl, ellipsis_token, 113, MX_APPLY_METHOD, EllipsisToken, Token, NthDecl) - MX_VISIT_TOKEN_RANGE(FunctionDecl, exception_spec_tokens, 114, 115, NthDecl) - MX_VISIT_ENUM(FunctionDecl, exception_spec_type, 76, MX_APPLY_METHOD, ExceptionSpecType, ExceptionSpecificationType, NthDecl) - MX_VISIT_ENUM(FunctionDecl, language_linkage, 77, MX_APPLY_METHOD, LanguageLinkage, LanguageLinkage, NthDecl) - MX_VISIT_INT(FunctionDecl, memory_function_kind, 117, MX_APPLY_METHOD, MemoryFunctionKind, uint32_t, NthDecl) - MX_VISIT_INT(FunctionDecl, min_required_arguments, 129, MX_APPLY_METHOD, MinRequiredArguments, uint32_t, NthDecl) - MX_VISIT_INT(FunctionDecl, min_required_explicit_arguments, 130, MX_APPLY_METHOD, MinRequiredExplicitArguments, uint32_t, NthDecl) - MX_VISIT_ENUM(FunctionDecl, multi_version_kind, 78, MX_APPLY_METHOD, MultiVersionKind, MultiVersionKind, NthDecl) - MX_VISIT_ENUM(FunctionDecl, overloaded_operator, 79, MX_APPLY_METHOD, OverloadedOperator, OverloadedOperatorKind, NthDecl) - MX_VISIT_TOKEN_RANGE(FunctionDecl, parameters_tokens, 116, 119, NthDecl) - MX_VISIT_ENTITY(FunctionDecl, return_type, 120, MX_APPLY_METHOD, ReturnType, Type, NthDecl) - MX_VISIT_ENUM(FunctionDecl, storage_class, 80, MX_APPLY_METHOD, StorageClass, StorageClass, NthDecl) - MX_VISIT_ENUM(FunctionDecl, templated_kind, 118, MX_APPLY_METHOD, TemplatedKind, FunctionDeclTemplatedKind, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_cxx_explicit_function_object_parameter, 85, MX_APPLY_METHOD, HasCXXExplicitFunctionObjectParameter, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_implicit_return_zero, 86, MX_APPLY_METHOD, HasImplicitReturnZero, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_inherited_prototype, 87, MX_APPLY_METHOD, HasInheritedPrototype, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_one_parameter_or_default_arguments, 88, MX_APPLY_METHOD, HasOneParameterOrDefaultArguments, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_prototype, 89, MX_APPLY_METHOD, HasPrototype, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_skipped_body, 90, MX_APPLY_METHOD, HasSkippedBody, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_trivial_body, 91, MX_APPLY_METHOD, HasTrivialBody, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, has_written_prototype, 92, MX_APPLY_METHOD, HasWrittenPrototype, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, instantiation_is_pending, 93, MX_APPLY_METHOD, InstantiationIsPending, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_cpu_dispatch_multi_version, 94, MX_APPLY_METHOD, IsCPUDispatchMultiVersion, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_cpu_specific_multi_version, 95, MX_APPLY_METHOD, IsCPUSpecificMultiVersion, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_consteval, 96, MX_APPLY_METHOD, IsConsteval, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_constexpr, 97, MX_APPLY_METHOD, IsConstexpr, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_constexpr_specified, 98, MX_APPLY_METHOD, IsConstexprSpecified, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_defaulted, 99, MX_APPLY_METHOD, IsDefaulted, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_deleted, 100, MX_APPLY_METHOD, IsDeleted, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_deleted_as_written, 101, MX_APPLY_METHOD, IsDeletedAsWritten, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_destroying_operator_delete, 102, MX_APPLY_METHOD, IsDestroyingOperatorDelete, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_explicitly_defaulted, 103, MX_APPLY_METHOD, IsExplicitlyDefaulted, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_extern_c, 104, MX_APPLY_METHOD, IsExternC, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_function_template_specialization, 105, MX_APPLY_METHOD, IsFunctionTemplateSpecialization, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_global, 106, MX_APPLY_METHOD, IsGlobal, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_immediate_escalating, 107, MX_APPLY_METHOD, IsImmediateEscalating, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_immediate_function, 108, MX_APPLY_METHOD, IsImmediateFunction, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_implicitly_instantiable, 109, MX_APPLY_METHOD, IsImplicitlyInstantiable, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_in_extern_c_context, 110, MX_APPLY_METHOD, IsInExternCContext, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_in_extern_cxx_context, 111, MX_APPLY_METHOD, IsInExternCXXContext, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_ineligible_or_not_selected, 112, MX_APPLY_METHOD, IsIneligibleOrNotSelected, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_inline_builtin_declaration, 121, MX_APPLY_METHOD, IsInlineBuiltinDeclaration, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(FunctionDecl, is_inline_definition_externally_visible, 122, MX_APPLY_METHOD, IsInlineDefinitionExternallyVisible, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_inline_specified, 124, MX_APPLY_METHOD, IsInlineSpecified, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_inlined, 125, MX_APPLY_METHOD, IsInlined, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_late_template_parsed, 126, MX_APPLY_METHOD, IsLateTemplateParsed, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(FunctionDecl, is_ms_extern_inline, 127, MX_APPLY_METHOD, IsMSExternInline, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_msvcrt_entry_point, 131, MX_APPLY_METHOD, IsMSVCRTEntryPoint, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_main, 132, MX_APPLY_METHOD, IsMain, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_member_like_constrained_friend, 133, MX_APPLY_METHOD, IsMemberLikeConstrainedFriend, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_multi_version, 134, MX_APPLY_METHOD, IsMultiVersion, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_no_return, 135, MX_APPLY_METHOD, IsNoReturn, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_overloaded_operator, 136, MX_APPLY_METHOD, IsOverloadedOperator, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_pure_virtual, 137, MX_APPLY_METHOD, IsPureVirtual, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_replaceable_global_allocation_function, 138, MX_APPLY_METHOD, IsReplaceableGlobalAllocationFunction, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(FunctionDecl, is_reserved_global_placement_operator, 139, MX_APPLY_METHOD, IsReservedGlobalPlacementOperator, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_static, 141, MX_APPLY_METHOD, IsStatic, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_target_clones_multi_version, 142, MX_APPLY_METHOD, IsTargetClonesMultiVersion, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_target_multi_version, 143, MX_APPLY_METHOD, IsTargetMultiVersion, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_template_instantiation, 144, MX_APPLY_METHOD, IsTemplateInstantiation, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_this_declaration_a_definition, 145, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_trivial, 146, MX_APPLY_METHOD, IsTrivial, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_trivial_for_call, 147, MX_APPLY_METHOD, IsTrivialForCall, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_user_provided, 148, MX_APPLY_METHOD, IsUserProvided, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_variadic, 149, MX_APPLY_METHOD, IsVariadic, bool, NthDecl) - MX_VISIT_BOOL(FunctionDecl, is_virtual_as_written, 150, MX_APPLY_METHOD, IsVirtualAsWritten, bool, NthDecl) - MX_VISIT_ENTITY_LIST(FunctionDecl, parameters, 44, MX_APPLY_METHOD, Parameters, ParmVarDecl, NthDecl) - MX_VISIT_BOOL(FunctionDecl, uses_seh_try, 151, MX_APPLY_METHOD, UsesSEHTry, bool, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(FunctionDecl, body, 152, MX_APPLY_METHOD, Body, Stmt, NthDecl) - MX_VISIT_ENTITY_LIST(FunctionDecl, template_arguments, 54, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) - MX_VISIT_DECL_CONTEXT(FunctionDecl, contained_declarations, 153, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_BOOL(FunctionDecl, body_contains_immediate_escalating_expressions, 69, MX_APPLY_METHOD, BodyContainsImmediateEscalatingExpressions, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, friend_constraint_refers_to_enclosing_template, 70, MX_APPLY_METHOD, FriendConstraintRefersToEnclosingTemplate, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, uses_fp_intrin, 82, MX_APPLY_METHOD, UsesFPIntrin, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(FunctionDecl, does_declaration_force_externally_visible_definition, 83, MX_APPLY_METHOD, DoesDeclarationForceExternallyVisibleDefinition, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, does_this_declaration_have_a_body, 85, MX_APPLY_METHOD, DoesThisDeclarationHaveABody, bool, NthDecl) + MX_VISIT_INT(FunctionDecl, builtin_id, 42, MX_APPLY_METHOD, BuiltinID, uint32_t, NthDecl) + MX_VISIT_ENTITY(FunctionDecl, call_result_type, 72, MX_APPLY_METHOD, CallResultType, Type, NthDecl) + MX_VISIT_ENUM(FunctionDecl, constexpr_kind, 73, MX_APPLY_METHOD, ConstexprKind, ConstexprSpecKind, NthDecl) + MX_VISIT_ENTITY(FunctionDecl, declared_return_type, 74, MX_APPLY_METHOD, DeclaredReturnType, Type, NthDecl) + MX_VISIT_ENTITY(FunctionDecl, default_token, 75, MX_APPLY_METHOD, DefaultToken, Token, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(FunctionDecl, described_function_template, 76, MX_APPLY_METHOD, DescribedFunctionTemplate, FunctionTemplateDecl, NthDecl) + MX_VISIT_ENTITY(FunctionDecl, ellipsis_token, 114, MX_APPLY_METHOD, EllipsisToken, Token, NthDecl) + MX_VISIT_TOKEN_RANGE(FunctionDecl, exception_spec_tokens, 115, 116, NthDecl) + MX_VISIT_ENUM(FunctionDecl, exception_spec_type, 77, MX_APPLY_METHOD, ExceptionSpecType, ExceptionSpecificationType, NthDecl) + MX_VISIT_ENUM(FunctionDecl, language_linkage, 78, MX_APPLY_METHOD, LanguageLinkage, LanguageLinkage, NthDecl) + MX_VISIT_INT(FunctionDecl, memory_function_kind, 118, MX_APPLY_METHOD, MemoryFunctionKind, uint32_t, NthDecl) + MX_VISIT_INT(FunctionDecl, min_required_arguments, 130, MX_APPLY_METHOD, MinRequiredArguments, uint32_t, NthDecl) + MX_VISIT_INT(FunctionDecl, min_required_explicit_arguments, 131, MX_APPLY_METHOD, MinRequiredExplicitArguments, uint32_t, NthDecl) + MX_VISIT_ENUM(FunctionDecl, multi_version_kind, 79, MX_APPLY_METHOD, MultiVersionKind, MultiVersionKind, NthDecl) + MX_VISIT_ENUM(FunctionDecl, overloaded_operator, 80, MX_APPLY_METHOD, OverloadedOperator, OverloadedOperatorKind, NthDecl) + MX_VISIT_TOKEN_RANGE(FunctionDecl, parameters_tokens, 117, 120, NthDecl) + MX_VISIT_ENTITY(FunctionDecl, return_type, 121, MX_APPLY_METHOD, ReturnType, Type, NthDecl) + MX_VISIT_ENUM(FunctionDecl, storage_class, 81, MX_APPLY_METHOD, StorageClass, StorageClass, NthDecl) + MX_VISIT_ENUM(FunctionDecl, templated_kind, 119, MX_APPLY_METHOD, TemplatedKind, FunctionDeclTemplatedKind, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_cxx_explicit_function_object_parameter, 86, MX_APPLY_METHOD, HasCXXExplicitFunctionObjectParameter, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_implicit_return_zero, 87, MX_APPLY_METHOD, HasImplicitReturnZero, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_inherited_prototype, 88, MX_APPLY_METHOD, HasInheritedPrototype, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_one_parameter_or_default_arguments, 89, MX_APPLY_METHOD, HasOneParameterOrDefaultArguments, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_prototype, 90, MX_APPLY_METHOD, HasPrototype, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_skipped_body, 91, MX_APPLY_METHOD, HasSkippedBody, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_trivial_body, 92, MX_APPLY_METHOD, HasTrivialBody, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, has_written_prototype, 93, MX_APPLY_METHOD, HasWrittenPrototype, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, instantiation_is_pending, 94, MX_APPLY_METHOD, InstantiationIsPending, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_cpu_dispatch_multi_version, 95, MX_APPLY_METHOD, IsCPUDispatchMultiVersion, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_cpu_specific_multi_version, 96, MX_APPLY_METHOD, IsCPUSpecificMultiVersion, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_consteval, 97, MX_APPLY_METHOD, IsConsteval, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_constexpr, 98, MX_APPLY_METHOD, IsConstexpr, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_constexpr_specified, 99, MX_APPLY_METHOD, IsConstexprSpecified, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_defaulted, 100, MX_APPLY_METHOD, IsDefaulted, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_deleted, 101, MX_APPLY_METHOD, IsDeleted, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_deleted_as_written, 102, MX_APPLY_METHOD, IsDeletedAsWritten, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_destroying_operator_delete, 103, MX_APPLY_METHOD, IsDestroyingOperatorDelete, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_explicitly_defaulted, 104, MX_APPLY_METHOD, IsExplicitlyDefaulted, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_extern_c, 105, MX_APPLY_METHOD, IsExternC, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_function_template_specialization, 106, MX_APPLY_METHOD, IsFunctionTemplateSpecialization, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_global, 107, MX_APPLY_METHOD, IsGlobal, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_immediate_escalating, 108, MX_APPLY_METHOD, IsImmediateEscalating, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_immediate_function, 109, MX_APPLY_METHOD, IsImmediateFunction, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_implicitly_instantiable, 110, MX_APPLY_METHOD, IsImplicitlyInstantiable, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_in_extern_c_context, 111, MX_APPLY_METHOD, IsInExternCContext, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_in_extern_cxx_context, 112, MX_APPLY_METHOD, IsInExternCXXContext, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_ineligible_or_not_selected, 113, MX_APPLY_METHOD, IsIneligibleOrNotSelected, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_inline_builtin_declaration, 122, MX_APPLY_METHOD, IsInlineBuiltinDeclaration, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(FunctionDecl, is_inline_definition_externally_visible, 123, MX_APPLY_METHOD, IsInlineDefinitionExternallyVisible, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_inline_specified, 125, MX_APPLY_METHOD, IsInlineSpecified, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_inlined, 126, MX_APPLY_METHOD, IsInlined, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_late_template_parsed, 127, MX_APPLY_METHOD, IsLateTemplateParsed, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(FunctionDecl, is_ms_extern_inline, 128, MX_APPLY_METHOD, IsMSExternInline, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_msvcrt_entry_point, 132, MX_APPLY_METHOD, IsMSVCRTEntryPoint, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_main, 133, MX_APPLY_METHOD, IsMain, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_member_like_constrained_friend, 134, MX_APPLY_METHOD, IsMemberLikeConstrainedFriend, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_multi_version, 135, MX_APPLY_METHOD, IsMultiVersion, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_no_return, 136, MX_APPLY_METHOD, IsNoReturn, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_overloaded_operator, 137, MX_APPLY_METHOD, IsOverloadedOperator, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_pure_virtual, 138, MX_APPLY_METHOD, IsPureVirtual, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_replaceable_global_allocation_function, 139, MX_APPLY_METHOD, IsReplaceableGlobalAllocationFunction, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(FunctionDecl, is_reserved_global_placement_operator, 140, MX_APPLY_METHOD, IsReservedGlobalPlacementOperator, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_static, 142, MX_APPLY_METHOD, IsStatic, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_target_clones_multi_version, 143, MX_APPLY_METHOD, IsTargetClonesMultiVersion, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_target_multi_version, 144, MX_APPLY_METHOD, IsTargetMultiVersion, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_template_instantiation, 145, MX_APPLY_METHOD, IsTemplateInstantiation, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_this_declaration_a_definition, 146, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_trivial, 147, MX_APPLY_METHOD, IsTrivial, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_trivial_for_call, 148, MX_APPLY_METHOD, IsTrivialForCall, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_user_provided, 149, MX_APPLY_METHOD, IsUserProvided, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_variadic, 150, MX_APPLY_METHOD, IsVariadic, bool, NthDecl) + MX_VISIT_BOOL(FunctionDecl, is_virtual_as_written, 151, MX_APPLY_METHOD, IsVirtualAsWritten, bool, NthDecl) + MX_VISIT_ENTITY_LIST(FunctionDecl, parameters, 45, MX_APPLY_METHOD, Parameters, ParmVarDecl, NthDecl) + MX_VISIT_BOOL(FunctionDecl, uses_seh_try, 152, MX_APPLY_METHOD, UsesSEHTry, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(FunctionDecl, body, 153, MX_APPLY_METHOD, Body, Stmt, NthDecl) + MX_VISIT_ENTITY_LIST(FunctionDecl, template_arguments, 55, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) + MX_VISIT_DECL_CONTEXT(FunctionDecl, contained_declarations, 154, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_FunctionDecl MX_END_VISIT_DECL(FunctionDecl) @@ -19065,22 +19070,22 @@ MX_END_VISIT_DECL(FunctionDecl) MX_BEGIN_VISIT_DECL(CXXMethodDecl) MX_ENTER_VISIT_CXXMethodDecl MX_VISIT_BASE(CXXMethodDecl, FunctionDecl) - MX_VISIT_ENTITY(CXXMethodDecl, function_object_parameter_reference_type, 154, MX_APPLY_METHOD, FunctionObjectParameterReferenceType, Type, NthDecl) - MX_VISIT_ENTITY(CXXMethodDecl, function_object_parameter_type, 155, MX_APPLY_METHOD, FunctionObjectParameterType, Type, NthDecl) - MX_VISIT_ENUM(CXXMethodDecl, reference_qualifier, 156, MX_APPLY_METHOD, ReferenceQualifier, RefQualifierKind, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXMethodDecl, this_type, 157, MX_APPLY_METHOD, ThisType, Type, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, has_inline_body, 158, MX_APPLY_METHOD, HasInlineBody, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_const, 159, MX_APPLY_METHOD, IsConst, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_copy_assignment_operator, 160, MX_APPLY_METHOD, IsCopyAssignmentOperator, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_explicit_object_member_function, 161, MX_APPLY_METHOD, IsExplicitObjectMemberFunction, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_implicit_object_member_function, 162, MX_APPLY_METHOD, IsImplicitObjectMemberFunction, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_instance, 163, MX_APPLY_METHOD, IsInstance, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_lambda_static_invoker, 164, MX_APPLY_METHOD, IsLambdaStaticInvoker, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_move_assignment_operator, 165, MX_APPLY_METHOD, IsMoveAssignmentOperator, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_virtual, 166, MX_APPLY_METHOD, IsVirtual, bool, NthDecl) - MX_VISIT_BOOL(CXXMethodDecl, is_volatile, 167, MX_APPLY_METHOD, IsVolatile, bool, NthDecl) - MX_VISIT_ENTITY_LIST(CXXMethodDecl, overridden_methods, 168, MX_APPLY_METHOD, OverriddenMethods, CXXMethodDecl, NthDecl) - MX_VISIT_INT(CXXMethodDecl, size_overridden_methods, 169, MX_APPLY_METHOD, SizeOverriddenMethods, uint32_t, NthDecl) + MX_VISIT_ENTITY(CXXMethodDecl, function_object_parameter_reference_type, 155, MX_APPLY_METHOD, FunctionObjectParameterReferenceType, Type, NthDecl) + MX_VISIT_ENTITY(CXXMethodDecl, function_object_parameter_type, 156, MX_APPLY_METHOD, FunctionObjectParameterType, Type, NthDecl) + MX_VISIT_ENUM(CXXMethodDecl, reference_qualifier, 157, MX_APPLY_METHOD, ReferenceQualifier, RefQualifierKind, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXMethodDecl, this_type, 158, MX_APPLY_METHOD, ThisType, Type, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, has_inline_body, 159, MX_APPLY_METHOD, HasInlineBody, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_const, 160, MX_APPLY_METHOD, IsConst, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_copy_assignment_operator, 161, MX_APPLY_METHOD, IsCopyAssignmentOperator, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_explicit_object_member_function, 162, MX_APPLY_METHOD, IsExplicitObjectMemberFunction, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_implicit_object_member_function, 163, MX_APPLY_METHOD, IsImplicitObjectMemberFunction, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_instance, 164, MX_APPLY_METHOD, IsInstance, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_lambda_static_invoker, 165, MX_APPLY_METHOD, IsLambdaStaticInvoker, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_move_assignment_operator, 166, MX_APPLY_METHOD, IsMoveAssignmentOperator, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_virtual, 167, MX_APPLY_METHOD, IsVirtual, bool, NthDecl) + MX_VISIT_BOOL(CXXMethodDecl, is_volatile, 168, MX_APPLY_METHOD, IsVolatile, bool, NthDecl) + MX_VISIT_ENTITY_LIST(CXXMethodDecl, overridden_methods, 169, MX_APPLY_METHOD, OverriddenMethods, CXXMethodDecl, NthDecl) + MX_VISIT_INT(CXXMethodDecl, size_overridden_methods, 170, MX_APPLY_METHOD, SizeOverriddenMethods, uint32_t, NthDecl) MX_EXIT_VISIT_CXXMethodDecl MX_END_VISIT_DECL(CXXMethodDecl) @@ -19094,8 +19099,8 @@ MX_END_VISIT_DECL(CXXMethodDecl) MX_BEGIN_VISIT_DECL(CXXDestructorDecl) MX_ENTER_VISIT_CXXDestructorDecl MX_VISIT_BASE(CXXDestructorDecl, CXXMethodDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXDestructorDecl, operator_delete, 170, MX_APPLY_METHOD, OperatorDelete, FunctionDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXDestructorDecl, operator_delete_this_argument, 171, MX_APPLY_METHOD, OperatorDeleteThisArgument, Expr, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXDestructorDecl, operator_delete, 171, MX_APPLY_METHOD, OperatorDelete, FunctionDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXDestructorDecl, operator_delete_this_argument, 172, MX_APPLY_METHOD, OperatorDeleteThisArgument, Expr, NthDecl) MX_EXIT_VISIT_CXXDestructorDecl MX_END_VISIT_DECL(CXXDestructorDecl) @@ -19109,9 +19114,9 @@ MX_END_VISIT_DECL(CXXDestructorDecl) MX_BEGIN_VISIT_DECL(CXXConversionDecl) MX_ENTER_VISIT_CXXConversionDecl MX_VISIT_BASE(CXXConversionDecl, CXXMethodDecl) - MX_VISIT_ENTITY(CXXConversionDecl, conversion_type, 170, MX_APPLY_METHOD, ConversionType, Type, NthDecl) - MX_VISIT_BOOL(CXXConversionDecl, is_explicit, 172, MX_APPLY_METHOD, IsExplicit, bool, NthDecl) - MX_VISIT_BOOL(CXXConversionDecl, is_lambda_to_block_pointer_conversion, 173, MX_APPLY_METHOD, IsLambdaToBlockPointerConversion, bool, NthDecl) + MX_VISIT_ENTITY(CXXConversionDecl, conversion_type, 171, MX_APPLY_METHOD, ConversionType, Type, NthDecl) + MX_VISIT_BOOL(CXXConversionDecl, is_explicit, 173, MX_APPLY_METHOD, IsExplicit, bool, NthDecl) + MX_VISIT_BOOL(CXXConversionDecl, is_lambda_to_block_pointer_conversion, 174, MX_APPLY_METHOD, IsLambdaToBlockPointerConversion, bool, NthDecl) MX_EXIT_VISIT_CXXConversionDecl MX_END_VISIT_DECL(CXXConversionDecl) @@ -19125,13 +19130,13 @@ MX_END_VISIT_DECL(CXXConversionDecl) MX_BEGIN_VISIT_DECL(CXXConstructorDecl) MX_ENTER_VISIT_CXXConstructorDecl MX_VISIT_BASE(CXXConstructorDecl, CXXMethodDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXConstructorDecl, target_constructor, 170, MX_APPLY_METHOD, TargetConstructor, CXXConstructorDecl, NthDecl) - MX_VISIT_ENTITY_LIST(CXXConstructorDecl, initializers, 174, MX_APPLY_METHOD, Initializers, CXXCtorInitializer, NthDecl) - MX_VISIT_BOOL(CXXConstructorDecl, is_default_constructor, 172, MX_APPLY_METHOD, IsDefaultConstructor, bool, NthDecl) - MX_VISIT_BOOL(CXXConstructorDecl, is_delegating_constructor, 173, MX_APPLY_METHOD, IsDelegatingConstructor, bool, NthDecl) - MX_VISIT_BOOL(CXXConstructorDecl, is_explicit, 175, MX_APPLY_METHOD, IsExplicit, bool, NthDecl) - MX_VISIT_BOOL(CXXConstructorDecl, is_inheriting_constructor, 176, MX_APPLY_METHOD, IsInheritingConstructor, bool, NthDecl) - MX_VISIT_BOOL(CXXConstructorDecl, is_specialization_copying_object, 177, MX_APPLY_METHOD, IsSpecializationCopyingObject, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXConstructorDecl, target_constructor, 171, MX_APPLY_METHOD, TargetConstructor, CXXConstructorDecl, NthDecl) + MX_VISIT_ENTITY_LIST(CXXConstructorDecl, initializers, 175, MX_APPLY_METHOD, Initializers, CXXCtorInitializer, NthDecl) + MX_VISIT_BOOL(CXXConstructorDecl, is_default_constructor, 173, MX_APPLY_METHOD, IsDefaultConstructor, bool, NthDecl) + MX_VISIT_BOOL(CXXConstructorDecl, is_delegating_constructor, 174, MX_APPLY_METHOD, IsDelegatingConstructor, bool, NthDecl) + MX_VISIT_BOOL(CXXConstructorDecl, is_explicit, 176, MX_APPLY_METHOD, IsExplicit, bool, NthDecl) + MX_VISIT_BOOL(CXXConstructorDecl, is_inheriting_constructor, 177, MX_APPLY_METHOD, IsInheritingConstructor, bool, NthDecl) + MX_VISIT_BOOL(CXXConstructorDecl, is_specialization_copying_object, 178, MX_APPLY_METHOD, IsSpecializationCopyingObject, bool, NthDecl) MX_EXIT_VISIT_CXXConstructorDecl MX_END_VISIT_DECL(CXXConstructorDecl) @@ -19145,10 +19150,10 @@ MX_END_VISIT_DECL(CXXConstructorDecl) MX_BEGIN_VISIT_DECL(CXXDeductionGuideDecl) MX_ENTER_VISIT_CXXDeductionGuideDecl MX_VISIT_BASE(CXXDeductionGuideDecl, FunctionDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXDeductionGuideDecl, corresponding_constructor, 154, MX_APPLY_METHOD, CorrespondingConstructor, CXXConstructorDecl, NthDecl) - MX_VISIT_ENTITY(CXXDeductionGuideDecl, deduced_template, 155, MX_APPLY_METHOD, DeducedTemplate, TemplateDecl, NthDecl) - MX_VISIT_ENUM(CXXDeductionGuideDecl, deduction_candidate_kind, 156, MX_APPLY_METHOD, DeductionCandidateKind, DeductionCandidate, NthDecl) - MX_VISIT_BOOL(CXXDeductionGuideDecl, is_explicit, 158, MX_APPLY_METHOD, IsExplicit, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXDeductionGuideDecl, corresponding_constructor, 155, MX_APPLY_METHOD, CorrespondingConstructor, CXXConstructorDecl, NthDecl) + MX_VISIT_ENTITY(CXXDeductionGuideDecl, deduced_template, 156, MX_APPLY_METHOD, DeducedTemplate, TemplateDecl, NthDecl) + MX_VISIT_ENUM(CXXDeductionGuideDecl, deduction_candidate_kind, 157, MX_APPLY_METHOD, DeductionCandidateKind, DeductionCandidate, NthDecl) + MX_VISIT_BOOL(CXXDeductionGuideDecl, is_explicit, 159, MX_APPLY_METHOD, IsExplicit, bool, NthDecl) MX_EXIT_VISIT_CXXDeductionGuideDecl MX_END_VISIT_DECL(CXXDeductionGuideDecl) @@ -19162,22 +19167,22 @@ MX_END_VISIT_DECL(CXXDeductionGuideDecl) MX_BEGIN_VISIT_DECL(FieldDecl) MX_ENTER_VISIT_FieldDecl MX_VISIT_BASE(FieldDecl, DeclaratorDecl) - MX_VISIT_OPTIONAL_ENTITY(FieldDecl, bit_width, 71, MX_APPLY_METHOD, BitWidth, Expr, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(FieldDecl, captured_vla_type, 73, MX_APPLY_METHOD, CapturedVLAType, VariableArrayType, NthDecl) - MX_VISIT_INT(FieldDecl, field_index, 41, MX_APPLY_METHOD, FieldIndex, uint32_t, NthDecl) - MX_VISIT_ENUM(FieldDecl, in_class_initializer_style, 72, MX_APPLY_METHOD, InClassInitializerStyle, InClassInitStyle, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(FieldDecl, in_class_initializer, 74, MX_APPLY_METHOD, InClassInitializer, Expr, NthDecl) - MX_VISIT_BOOL(FieldDecl, has_captured_vla_type, 68, MX_APPLY_METHOD, HasCapturedVLAType, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, has_in_class_initializer, 69, MX_APPLY_METHOD, HasInClassInitializer, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, has_non_null_in_class_initializer, 81, MX_APPLY_METHOD, HasNonNullInClassInitializer, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, is_anonymous_struct_or_union, 82, MX_APPLY_METHOD, IsAnonymousStructOrUnion, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, is_bit_field, 83, MX_APPLY_METHOD, IsBitField, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, is_mutable, 84, MX_APPLY_METHOD, IsMutable, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, is_potentially_overlapping, 85, MX_APPLY_METHOD, IsPotentiallyOverlapping, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, is_unnamed_bitfield, 86, MX_APPLY_METHOD, IsUnnamedBitfield, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, is_zero_length_bit_field, 87, MX_APPLY_METHOD, IsZeroLengthBitField, bool, NthDecl) - MX_VISIT_BOOL(FieldDecl, is_zero_size, 88, MX_APPLY_METHOD, IsZeroSize, bool, NthDecl) - MX_VISIT_OPTIONAL_INT(FieldDecl, offset_in_bits, 75, MX_APPLY_METHOD, OffsetInBits, , NthDecl) + MX_VISIT_OPTIONAL_ENTITY(FieldDecl, bit_width, 72, MX_APPLY_METHOD, BitWidth, Expr, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(FieldDecl, captured_vla_type, 74, MX_APPLY_METHOD, CapturedVLAType, VariableArrayType, NthDecl) + MX_VISIT_INT(FieldDecl, field_index, 42, MX_APPLY_METHOD, FieldIndex, uint32_t, NthDecl) + MX_VISIT_ENUM(FieldDecl, in_class_initializer_style, 73, MX_APPLY_METHOD, InClassInitializerStyle, InClassInitStyle, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(FieldDecl, in_class_initializer, 75, MX_APPLY_METHOD, InClassInitializer, Expr, NthDecl) + MX_VISIT_BOOL(FieldDecl, has_captured_vla_type, 69, MX_APPLY_METHOD, HasCapturedVLAType, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, has_in_class_initializer, 70, MX_APPLY_METHOD, HasInClassInitializer, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, has_non_null_in_class_initializer, 82, MX_APPLY_METHOD, HasNonNullInClassInitializer, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, is_anonymous_struct_or_union, 83, MX_APPLY_METHOD, IsAnonymousStructOrUnion, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, is_bit_field, 84, MX_APPLY_METHOD, IsBitField, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, is_mutable, 85, MX_APPLY_METHOD, IsMutable, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, is_potentially_overlapping, 86, MX_APPLY_METHOD, IsPotentiallyOverlapping, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, is_unnamed_bitfield, 87, MX_APPLY_METHOD, IsUnnamedBitfield, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, is_zero_length_bit_field, 88, MX_APPLY_METHOD, IsZeroLengthBitField, bool, NthDecl) + MX_VISIT_BOOL(FieldDecl, is_zero_size, 89, MX_APPLY_METHOD, IsZeroSize, bool, NthDecl) + MX_VISIT_OPTIONAL_INT(FieldDecl, offset_in_bits, 76, MX_APPLY_METHOD, OffsetInBits, , NthDecl) MX_EXIT_VISIT_FieldDecl MX_END_VISIT_DECL(FieldDecl) @@ -19191,11 +19196,11 @@ MX_END_VISIT_DECL(FieldDecl) MX_BEGIN_VISIT_DECL(ObjCIvarDecl) MX_ENTER_VISIT_ObjCIvarDecl MX_VISIT_BASE(ObjCIvarDecl, FieldDecl) - MX_VISIT_ENUM(ObjCIvarDecl, access_control, 76, MX_APPLY_METHOD, AccessControl, ObjCIvarDeclAccessControl, NthDecl) - MX_VISIT_ENUM(ObjCIvarDecl, canonical_access_control, 77, MX_APPLY_METHOD, CanonicalAccessControl, ObjCIvarDeclAccessControl, NthDecl) - MX_VISIT_ENTITY(ObjCIvarDecl, containing_interface, 113, MX_APPLY_METHOD, ContainingInterface, ObjCInterfaceDecl, NthDecl) - MX_VISIT_ENTITY(ObjCIvarDecl, next_instance_variable, 114, MX_APPLY_METHOD, NextInstanceVariable, ObjCIvarDecl, NthDecl) - MX_VISIT_BOOL(ObjCIvarDecl, synthesize, 90, MX_APPLY_METHOD, Synthesize, bool, NthDecl) + MX_VISIT_ENUM(ObjCIvarDecl, access_control, 77, MX_APPLY_METHOD, AccessControl, ObjCIvarDeclAccessControl, NthDecl) + MX_VISIT_ENUM(ObjCIvarDecl, canonical_access_control, 78, MX_APPLY_METHOD, CanonicalAccessControl, ObjCIvarDeclAccessControl, NthDecl) + MX_VISIT_ENTITY(ObjCIvarDecl, containing_interface, 114, MX_APPLY_METHOD, ContainingInterface, ObjCInterfaceDecl, NthDecl) + MX_VISIT_ENTITY(ObjCIvarDecl, next_instance_variable, 115, MX_APPLY_METHOD, NextInstanceVariable, ObjCIvarDecl, NthDecl) + MX_VISIT_BOOL(ObjCIvarDecl, synthesize, 91, MX_APPLY_METHOD, Synthesize, bool, NthDecl) MX_EXIT_VISIT_ObjCIvarDecl MX_END_VISIT_DECL(ObjCIvarDecl) @@ -19222,9 +19227,9 @@ MX_END_VISIT_DECL(ObjCAtDefsFieldDecl) MX_BEGIN_VISIT_DECL(BindingDecl) MX_ENTER_VISIT_BindingDecl MX_VISIT_BASE(BindingDecl, ValueDecl) - MX_VISIT_OPTIONAL_ENTITY(BindingDecl, binding, 50, MX_APPLY_METHOD, Binding, Expr, NthDecl) - MX_VISIT_ENTITY(BindingDecl, decomposed_declaration, 58, MX_APPLY_METHOD, DecomposedDeclaration, ValueDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(BindingDecl, holding_variable, 59, MX_APPLY_METHOD, HoldingVariable, VarDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(BindingDecl, binding, 51, MX_APPLY_METHOD, Binding, Expr, NthDecl) + MX_VISIT_ENTITY(BindingDecl, decomposed_declaration, 59, MX_APPLY_METHOD, DecomposedDeclaration, ValueDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(BindingDecl, holding_variable, 60, MX_APPLY_METHOD, HoldingVariable, VarDecl, NthDecl) MX_EXIT_VISIT_BindingDecl MX_END_VISIT_DECL(BindingDecl) @@ -19251,8 +19256,8 @@ MX_END_VISIT_DECL(OMPDeclarativeDirectiveValueDecl) MX_BEGIN_VISIT_DECL(OMPDeclareMapperDecl) MX_ENTER_VISIT_OMPDeclareMapperDecl MX_VISIT_BASE(OMPDeclareMapperDecl, OMPDeclarativeDirectiveValueDecl) - MX_VISIT_ENTITY(OMPDeclareMapperDecl, mapper_variable_reference, 50, MX_APPLY_METHOD, MapperVariableReference, Expr, NthDecl) - MX_VISIT_DECL_CONTEXT(OMPDeclareMapperDecl, contained_declarations, 43, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_ENTITY(OMPDeclareMapperDecl, mapper_variable_reference, 51, MX_APPLY_METHOD, MapperVariableReference, Expr, NthDecl) + MX_VISIT_DECL_CONTEXT(OMPDeclareMapperDecl, contained_declarations, 44, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_OMPDeclareMapperDecl MX_END_VISIT_DECL(OMPDeclareMapperDecl) @@ -19266,9 +19271,9 @@ MX_END_VISIT_DECL(OMPDeclareMapperDecl) MX_BEGIN_VISIT_DECL(UsingShadowDecl) MX_ENTER_VISIT_UsingShadowDecl MX_VISIT_BASE(UsingShadowDecl, NamedDecl) - MX_VISIT_ENTITY(UsingShadowDecl, introducer, 48, MX_APPLY_METHOD, Introducer, BaseUsingDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(UsingShadowDecl, next_using_shadow_declaration, 49, MX_APPLY_METHOD, NextUsingShadowDeclaration, UsingShadowDecl, NthDecl) - MX_VISIT_ENTITY(UsingShadowDecl, target_declaration, 50, MX_APPLY_METHOD, TargetDeclaration, NamedDecl, NthDecl) + MX_VISIT_ENTITY(UsingShadowDecl, introducer, 49, MX_APPLY_METHOD, Introducer, BaseUsingDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(UsingShadowDecl, next_using_shadow_declaration, 50, MX_APPLY_METHOD, NextUsingShadowDeclaration, UsingShadowDecl, NthDecl) + MX_VISIT_ENTITY(UsingShadowDecl, target_declaration, 51, MX_APPLY_METHOD, TargetDeclaration, NamedDecl, NthDecl) MX_EXIT_VISIT_UsingShadowDecl MX_END_VISIT_DECL(UsingShadowDecl) @@ -19282,11 +19287,11 @@ MX_END_VISIT_DECL(UsingShadowDecl) MX_BEGIN_VISIT_DECL(ConstructorUsingShadowDecl) MX_ENTER_VISIT_ConstructorUsingShadowDecl MX_VISIT_BASE(ConstructorUsingShadowDecl, UsingShadowDecl) - MX_VISIT_BOOL(ConstructorUsingShadowDecl, constructs_virtual_base, 66, MX_APPLY_METHOD, ConstructsVirtualBase, bool, NthDecl) - MX_VISIT_ENTITY(ConstructorUsingShadowDecl, constructed_base_class, 58, MX_APPLY_METHOD, ConstructedBaseClass, CXXRecordDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(ConstructorUsingShadowDecl, constructed_base_class_shadow_declaration, 59, MX_APPLY_METHOD, ConstructedBaseClassShadowDeclaration, ConstructorUsingShadowDecl, NthDecl) - MX_VISIT_ENTITY(ConstructorUsingShadowDecl, nominated_base_class, 60, MX_APPLY_METHOD, NominatedBaseClass, CXXRecordDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(ConstructorUsingShadowDecl, nominated_base_class_shadow_declaration, 70, MX_APPLY_METHOD, NominatedBaseClassShadowDeclaration, ConstructorUsingShadowDecl, NthDecl) + MX_VISIT_BOOL(ConstructorUsingShadowDecl, constructs_virtual_base, 67, MX_APPLY_METHOD, ConstructsVirtualBase, bool, NthDecl) + MX_VISIT_ENTITY(ConstructorUsingShadowDecl, constructed_base_class, 59, MX_APPLY_METHOD, ConstructedBaseClass, CXXRecordDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(ConstructorUsingShadowDecl, constructed_base_class_shadow_declaration, 60, MX_APPLY_METHOD, ConstructedBaseClassShadowDeclaration, ConstructorUsingShadowDecl, NthDecl) + MX_VISIT_ENTITY(ConstructorUsingShadowDecl, nominated_base_class, 61, MX_APPLY_METHOD, NominatedBaseClass, CXXRecordDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(ConstructorUsingShadowDecl, nominated_base_class_shadow_declaration, 71, MX_APPLY_METHOD, NominatedBaseClassShadowDeclaration, ConstructorUsingShadowDecl, NthDecl) MX_EXIT_VISIT_ConstructorUsingShadowDecl MX_END_VISIT_DECL(ConstructorUsingShadowDecl) @@ -19300,7 +19305,7 @@ MX_END_VISIT_DECL(ConstructorUsingShadowDecl) MX_BEGIN_VISIT_DECL(UsingPackDecl) MX_ENTER_VISIT_UsingPackDecl MX_VISIT_BASE(UsingPackDecl, NamedDecl) - MX_VISIT_ENTITY_LIST(UsingPackDecl, expansions, 43, MX_APPLY_METHOD, Expansions, NamedDecl, NthDecl) + MX_VISIT_ENTITY_LIST(UsingPackDecl, expansions, 44, MX_APPLY_METHOD, Expansions, NamedDecl, NthDecl) MX_EXIT_VISIT_UsingPackDecl MX_END_VISIT_DECL(UsingPackDecl) @@ -19314,11 +19319,11 @@ MX_END_VISIT_DECL(UsingPackDecl) MX_BEGIN_VISIT_DECL(UsingDirectiveDecl) MX_ENTER_VISIT_UsingDirectiveDecl MX_VISIT_BASE(UsingDirectiveDecl, NamedDecl) - MX_VISIT_ENTITY(UsingDirectiveDecl, identifier_token, 48, MX_APPLY_METHOD, IdentifierToken, Token, NthDecl) - MX_VISIT_ENTITY(UsingDirectiveDecl, namespace_key_token, 49, MX_APPLY_METHOD, NamespaceKeyToken, Token, NthDecl) - MX_VISIT_ENTITY(UsingDirectiveDecl, nominated_namespace, 50, MX_APPLY_METHOD, NominatedNamespace, NamespaceDecl, NthDecl) - MX_VISIT_ENTITY(UsingDirectiveDecl, nominated_namespace_as_written, 58, MX_APPLY_METHOD, NominatedNamespaceAsWritten, NamedDecl, NthDecl) - MX_VISIT_ENTITY(UsingDirectiveDecl, using_token, 59, MX_APPLY_METHOD, UsingToken, Token, NthDecl) + MX_VISIT_ENTITY(UsingDirectiveDecl, identifier_token, 49, MX_APPLY_METHOD, IdentifierToken, Token, NthDecl) + MX_VISIT_ENTITY(UsingDirectiveDecl, namespace_key_token, 50, MX_APPLY_METHOD, NamespaceKeyToken, Token, NthDecl) + MX_VISIT_ENTITY(UsingDirectiveDecl, nominated_namespace, 51, MX_APPLY_METHOD, NominatedNamespace, NamespaceDecl, NthDecl) + MX_VISIT_ENTITY(UsingDirectiveDecl, nominated_namespace_as_written, 59, MX_APPLY_METHOD, NominatedNamespaceAsWritten, NamedDecl, NthDecl) + MX_VISIT_ENTITY(UsingDirectiveDecl, using_token, 60, MX_APPLY_METHOD, UsingToken, Token, NthDecl) MX_EXIT_VISIT_UsingDirectiveDecl MX_END_VISIT_DECL(UsingDirectiveDecl) @@ -19345,7 +19350,7 @@ MX_END_VISIT_DECL(UnresolvedUsingIfExistsDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(TypeDecl) MX_ENTER_VISIT_TypeDecl MX_VISIT_BASE(TypeDecl, NamedDecl) - MX_VISIT_OPTIONAL_ENTITY(TypeDecl, type_for_declaration, 48, MX_APPLY_METHOD, TypeForDeclaration, Type, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(TypeDecl, type_for_declaration, 49, MX_APPLY_METHOD, TypeForDeclaration, Type, NthDecl) MX_EXIT_VISIT_TypeDecl MX_END_VISIT_DECL(TypeDecl) @@ -19359,17 +19364,17 @@ MX_END_VISIT_DECL(TypeDecl) MX_BEGIN_VISIT_DECL(TemplateTypeParmDecl) MX_ENTER_VISIT_TemplateTypeParmDecl MX_VISIT_BASE(TemplateTypeParmDecl, TypeDecl) - MX_VISIT_BOOL(TemplateTypeParmDecl, default_argument_was_inherited, 66, MX_APPLY_METHOD, DefaultArgumentWasInherited, bool, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(TemplateTypeParmDecl, default_argument, 49, MX_APPLY_METHOD, DefaultArgument, Type, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(TemplateTypeParmDecl, default_argument_info, 50, MX_APPLY_METHOD, DefaultArgumentInfo, Type, NthDecl) - MX_VISIT_ENTITY(TemplateTypeParmDecl, default_argument_token, 58, MX_APPLY_METHOD, DefaultArgumentToken, Token, NthDecl) - MX_VISIT_INT(TemplateTypeParmDecl, depth, 41, MX_APPLY_METHOD, Depth, uint32_t, NthDecl) - MX_VISIT_INT(TemplateTypeParmDecl, index, 117, MX_APPLY_METHOD, Index, uint32_t, NthDecl) - MX_VISIT_BOOL(TemplateTypeParmDecl, has_default_argument, 67, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) - MX_VISIT_BOOL(TemplateTypeParmDecl, has_type_constraint, 68, MX_APPLY_METHOD, HasTypeConstraint, bool, NthDecl) - MX_VISIT_BOOL(TemplateTypeParmDecl, is_expanded_parameter_pack, 69, MX_APPLY_METHOD, IsExpandedParameterPack, bool, NthDecl) - MX_VISIT_BOOL(TemplateTypeParmDecl, is_pack_expansion, 81, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) - MX_VISIT_BOOL(TemplateTypeParmDecl, was_declared_with_typename, 82, MX_APPLY_METHOD, WasDeclaredWithTypename, bool, NthDecl) + MX_VISIT_BOOL(TemplateTypeParmDecl, default_argument_was_inherited, 67, MX_APPLY_METHOD, DefaultArgumentWasInherited, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(TemplateTypeParmDecl, default_argument, 50, MX_APPLY_METHOD, DefaultArgument, Type, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(TemplateTypeParmDecl, default_argument_info, 51, MX_APPLY_METHOD, DefaultArgumentInfo, Type, NthDecl) + MX_VISIT_ENTITY(TemplateTypeParmDecl, default_argument_token, 59, MX_APPLY_METHOD, DefaultArgumentToken, Token, NthDecl) + MX_VISIT_INT(TemplateTypeParmDecl, depth, 42, MX_APPLY_METHOD, Depth, uint32_t, NthDecl) + MX_VISIT_INT(TemplateTypeParmDecl, index, 118, MX_APPLY_METHOD, Index, uint32_t, NthDecl) + MX_VISIT_BOOL(TemplateTypeParmDecl, has_default_argument, 68, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) + MX_VISIT_BOOL(TemplateTypeParmDecl, has_type_constraint, 69, MX_APPLY_METHOD, HasTypeConstraint, bool, NthDecl) + MX_VISIT_BOOL(TemplateTypeParmDecl, is_expanded_parameter_pack, 70, MX_APPLY_METHOD, IsExpandedParameterPack, bool, NthDecl) + MX_VISIT_BOOL(TemplateTypeParmDecl, is_pack_expansion, 82, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) + MX_VISIT_BOOL(TemplateTypeParmDecl, was_declared_with_typename, 83, MX_APPLY_METHOD, WasDeclaredWithTypename, bool, NthDecl) MX_EXIT_VISIT_TemplateTypeParmDecl MX_END_VISIT_DECL(TemplateTypeParmDecl) @@ -19383,27 +19388,27 @@ MX_END_VISIT_DECL(TemplateTypeParmDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(TagDecl) MX_ENTER_VISIT_TagDecl MX_VISIT_BASE(TagDecl, TypeDecl) - MX_VISIT_TOKEN_RANGE(TagDecl, brace_range, 49, 50, NthDecl) - MX_VISIT_ENTITY(TagDecl, first_inner_token, 58, MX_APPLY_METHOD, FirstInnerToken, Token, NthDecl) - MX_VISIT_ENTITY(TagDecl, first_outer_token, 59, MX_APPLY_METHOD, FirstOuterToken, Token, NthDecl) - MX_VISIT_ENUM(TagDecl, tag_kind, 72, MX_APPLY_METHOD, TagKind, TagTypeKind, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(TagDecl, typedef_name_for_anonymous_declaration, 60, MX_APPLY_METHOD, TypedefNameForAnonymousDeclaration, TypedefNameDecl, NthDecl) - MX_VISIT_BOOL(TagDecl, has_name_for_linkage, 66, MX_APPLY_METHOD, HasNameForLinkage, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_being_defined, 67, MX_APPLY_METHOD, IsBeingDefined, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_class, 68, MX_APPLY_METHOD, IsClass, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_complete_definition, 69, MX_APPLY_METHOD, IsCompleteDefinition, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_complete_definition_required, 81, MX_APPLY_METHOD, IsCompleteDefinitionRequired, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_dependent_type, 82, MX_APPLY_METHOD, IsDependentType, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_enum, 83, MX_APPLY_METHOD, IsEnum, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_free_standing, 84, MX_APPLY_METHOD, IsFreeStanding, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_interface, 85, MX_APPLY_METHOD, IsInterface, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_struct, 86, MX_APPLY_METHOD, IsStruct, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_this_declaration_a_definition, 87, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_this_declaration_a_demoted_definition, 88, MX_APPLY_METHOD, IsThisDeclarationADemotedDefinition, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, is_union, 89, MX_APPLY_METHOD, IsUnion, bool, NthDecl) - MX_VISIT_BOOL(TagDecl, may_have_out_of_date_definition, 90, MX_APPLY_METHOD, MayHaveOutOfDateDefinition, bool, NthDecl) - MX_VISIT_ENTITY_LIST(TagDecl, template_parameter_lists, 43, MX_APPLY_METHOD, TemplateParameterLists, TemplateParameterList, NthDecl) - MX_VISIT_DECL_CONTEXT(TagDecl, contained_declarations, 44, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_TOKEN_RANGE(TagDecl, brace_range, 50, 51, NthDecl) + MX_VISIT_ENTITY(TagDecl, first_inner_token, 59, MX_APPLY_METHOD, FirstInnerToken, Token, NthDecl) + MX_VISIT_ENTITY(TagDecl, first_outer_token, 60, MX_APPLY_METHOD, FirstOuterToken, Token, NthDecl) + MX_VISIT_ENUM(TagDecl, tag_kind, 73, MX_APPLY_METHOD, TagKind, TagTypeKind, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(TagDecl, typedef_name_for_anonymous_declaration, 61, MX_APPLY_METHOD, TypedefNameForAnonymousDeclaration, TypedefNameDecl, NthDecl) + MX_VISIT_BOOL(TagDecl, has_name_for_linkage, 67, MX_APPLY_METHOD, HasNameForLinkage, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_being_defined, 68, MX_APPLY_METHOD, IsBeingDefined, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_class, 69, MX_APPLY_METHOD, IsClass, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_complete_definition, 70, MX_APPLY_METHOD, IsCompleteDefinition, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_complete_definition_required, 82, MX_APPLY_METHOD, IsCompleteDefinitionRequired, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_dependent_type, 83, MX_APPLY_METHOD, IsDependentType, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_enum, 84, MX_APPLY_METHOD, IsEnum, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_free_standing, 85, MX_APPLY_METHOD, IsFreeStanding, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_interface, 86, MX_APPLY_METHOD, IsInterface, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_struct, 87, MX_APPLY_METHOD, IsStruct, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_this_declaration_a_definition, 88, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_this_declaration_a_demoted_definition, 89, MX_APPLY_METHOD, IsThisDeclarationADemotedDefinition, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, is_union, 90, MX_APPLY_METHOD, IsUnion, bool, NthDecl) + MX_VISIT_BOOL(TagDecl, may_have_out_of_date_definition, 91, MX_APPLY_METHOD, MayHaveOutOfDateDefinition, bool, NthDecl) + MX_VISIT_ENTITY_LIST(TagDecl, template_parameter_lists, 44, MX_APPLY_METHOD, TemplateParameterLists, TemplateParameterList, NthDecl) + MX_VISIT_DECL_CONTEXT(TagDecl, contained_declarations, 45, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_TagDecl MX_END_VISIT_DECL(TagDecl) @@ -19417,31 +19422,31 @@ MX_END_VISIT_DECL(TagDecl) MX_BEGIN_VISIT_DECL(RecordDecl) MX_ENTER_VISIT_RecordDecl MX_VISIT_BASE(RecordDecl, TagDecl) - MX_VISIT_BOOL(RecordDecl, can_pass_in_registers, 91, MX_APPLY_METHOD, CanPassInRegisters, bool, NthDecl) - MX_VISIT_ENTITY_LIST(RecordDecl, fields, 54, MX_APPLY_METHOD, Fields, FieldDecl, NthDecl) - MX_VISIT_ENUM(RecordDecl, argument_passing_restrictions, 76, MX_APPLY_METHOD, ArgumentPassingRestrictions, RecordArgPassingKind, NthDecl) - MX_VISIT_BOOL(RecordDecl, has_flexible_array_member, 92, MX_APPLY_METHOD, HasFlexibleArrayMember, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, has_loaded_fields_from_external_storage, 93, MX_APPLY_METHOD, HasLoadedFieldsFromExternalStorage, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, has_non_trivial_to_primitive_copy_c_union, 94, MX_APPLY_METHOD, HasNonTrivialToPrimitiveCopyCUnion, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, has_non_trivial_to_primitive_default_initialize_c_union, 95, MX_APPLY_METHOD, HasNonTrivialToPrimitiveDefaultInitializeCUnion, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, has_non_trivial_to_primitive_destruct_c_union, 96, MX_APPLY_METHOD, HasNonTrivialToPrimitiveDestructCUnion, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, has_object_member, 97, MX_APPLY_METHOD, HasObjectMember, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, has_volatile_member, 98, MX_APPLY_METHOD, HasVolatileMember, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_anonymous_struct_or_union, 99, MX_APPLY_METHOD, IsAnonymousStructOrUnion, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_captured_record, 100, MX_APPLY_METHOD, IsCapturedRecord, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_injected_class_name, 101, MX_APPLY_METHOD, IsInjectedClassName, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_lambda, 102, MX_APPLY_METHOD, IsLambda, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_ms_struct, 103, MX_APPLY_METHOD, IsMsStruct, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_non_trivial_to_primitive_copy, 104, MX_APPLY_METHOD, IsNonTrivialToPrimitiveCopy, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_non_trivial_to_primitive_default_initialize, 105, MX_APPLY_METHOD, IsNonTrivialToPrimitiveDefaultInitialize, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_non_trivial_to_primitive_destroy, 106, MX_APPLY_METHOD, IsNonTrivialToPrimitiveDestroy, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_or_contains_union, 107, MX_APPLY_METHOD, IsOrContainsUnion, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_parameter_destroyed_in_callee, 108, MX_APPLY_METHOD, IsParameterDestroyedInCallee, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, is_randomized, 109, MX_APPLY_METHOD, IsRandomized, bool, NthDecl) - MX_VISIT_BOOL(RecordDecl, may_insert_extra_padding, 110, MX_APPLY_METHOD, MayInsertExtraPadding, bool, NthDecl) - MX_VISIT_OPTIONAL_INT(RecordDecl, size, 70, MX_APPLY_METHOD, Size, , NthDecl) - MX_VISIT_OPTIONAL_INT(RecordDecl, alignment, 71, MX_APPLY_METHOD, Alignment, , NthDecl) - MX_VISIT_OPTIONAL_INT(RecordDecl, size_without_trailing_padding, 73, MX_APPLY_METHOD, SizeWithoutTrailingPadding, , NthDecl) + MX_VISIT_BOOL(RecordDecl, can_pass_in_registers, 92, MX_APPLY_METHOD, CanPassInRegisters, bool, NthDecl) + MX_VISIT_ENTITY_LIST(RecordDecl, fields, 55, MX_APPLY_METHOD, Fields, FieldDecl, NthDecl) + MX_VISIT_ENUM(RecordDecl, argument_passing_restrictions, 77, MX_APPLY_METHOD, ArgumentPassingRestrictions, RecordArgPassingKind, NthDecl) + MX_VISIT_BOOL(RecordDecl, has_flexible_array_member, 93, MX_APPLY_METHOD, HasFlexibleArrayMember, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, has_loaded_fields_from_external_storage, 94, MX_APPLY_METHOD, HasLoadedFieldsFromExternalStorage, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, has_non_trivial_to_primitive_copy_c_union, 95, MX_APPLY_METHOD, HasNonTrivialToPrimitiveCopyCUnion, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, has_non_trivial_to_primitive_default_initialize_c_union, 96, MX_APPLY_METHOD, HasNonTrivialToPrimitiveDefaultInitializeCUnion, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, has_non_trivial_to_primitive_destruct_c_union, 97, MX_APPLY_METHOD, HasNonTrivialToPrimitiveDestructCUnion, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, has_object_member, 98, MX_APPLY_METHOD, HasObjectMember, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, has_volatile_member, 99, MX_APPLY_METHOD, HasVolatileMember, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_anonymous_struct_or_union, 100, MX_APPLY_METHOD, IsAnonymousStructOrUnion, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_captured_record, 101, MX_APPLY_METHOD, IsCapturedRecord, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_injected_class_name, 102, MX_APPLY_METHOD, IsInjectedClassName, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_lambda, 103, MX_APPLY_METHOD, IsLambda, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_ms_struct, 104, MX_APPLY_METHOD, IsMsStruct, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_non_trivial_to_primitive_copy, 105, MX_APPLY_METHOD, IsNonTrivialToPrimitiveCopy, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_non_trivial_to_primitive_default_initialize, 106, MX_APPLY_METHOD, IsNonTrivialToPrimitiveDefaultInitialize, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_non_trivial_to_primitive_destroy, 107, MX_APPLY_METHOD, IsNonTrivialToPrimitiveDestroy, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_or_contains_union, 108, MX_APPLY_METHOD, IsOrContainsUnion, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_parameter_destroyed_in_callee, 109, MX_APPLY_METHOD, IsParameterDestroyedInCallee, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, is_randomized, 110, MX_APPLY_METHOD, IsRandomized, bool, NthDecl) + MX_VISIT_BOOL(RecordDecl, may_insert_extra_padding, 111, MX_APPLY_METHOD, MayInsertExtraPadding, bool, NthDecl) + MX_VISIT_OPTIONAL_INT(RecordDecl, size, 71, MX_APPLY_METHOD, Size, , NthDecl) + MX_VISIT_OPTIONAL_INT(RecordDecl, alignment, 72, MX_APPLY_METHOD, Alignment, , NthDecl) + MX_VISIT_OPTIONAL_INT(RecordDecl, size_without_trailing_padding, 74, MX_APPLY_METHOD, SizeWithoutTrailingPadding, , NthDecl) MX_EXIT_VISIT_RecordDecl MX_END_VISIT_DECL(RecordDecl) @@ -19455,127 +19460,127 @@ MX_END_VISIT_DECL(RecordDecl) MX_BEGIN_VISIT_DECL(CXXRecordDecl) MX_ENTER_VISIT_CXXRecordDecl MX_VISIT_BASE(CXXRecordDecl, RecordDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, allow_const_default_initializer, 122, MX_APPLY_METHOD, AllowConstDefaultInitializer, bool, NthDecl) - MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, bases, 153, MX_APPLY_METHOD, Bases, CXXBaseSpecifier, NthDecl) - MX_VISIT_OPTIONAL_ENUM(CXXRecordDecl, inheritance_model, 77, MX_APPLY_METHOD, CalculateInheritanceModel, MSInheritanceModel, NthDecl) - MX_VISIT_ENTITY_LIST(CXXRecordDecl, constructors, 168, MX_APPLY_METHOD, Constructors, CXXConstructorDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, friends, 174, MX_APPLY_METHOD, Friends, FriendDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, dependent_lambda_call_operator, 74, MX_APPLY_METHOD, DependentLambdaCallOperator, FunctionTemplateDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, described_class_template, 75, MX_APPLY_METHOD, DescribedClassTemplate, ClassTemplateDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, destructor, 113, MX_APPLY_METHOD, Destructor, CXXDestructorDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, generic_lambda_template_parameter_list, 114, MX_APPLY_METHOD, GenericLambdaTemplateParameterList, TemplateParameterList, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, instantiated_from_member_class, 115, MX_APPLY_METHOD, InstantiatedFromMemberClass, CXXRecordDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, lambda_call_operator, 116, MX_APPLY_METHOD, LambdaCallOperator, CXXMethodDecl, NthDecl) - MX_VISIT_OPTIONAL_ENUM(CXXRecordDecl, lambda_capture_default, 78, MX_APPLY_METHOD, LambdaCaptureDefault, LambdaCaptureDefault, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, lambda_context_declaration, 119, MX_APPLY_METHOD, LambdaContextDeclaration, Decl, NthDecl) - MX_VISIT_INT(CXXRecordDecl, lambda_dependency_kind, 41, MX_APPLY_METHOD, LambdaDependencyKind, uint32_t, NthDecl) - MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, lambda_explicit_template_parameters, 178, MX_APPLY_METHOD, LambdaExplicitTemplateParameters, NamedDecl, NthDecl) - MX_VISIT_OPTIONAL_INT(CXXRecordDecl, lambda_mangling_number, 117, MX_APPLY_METHOD, LambdaManglingNumber, , NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, lambda_static_invoker, 120, MX_APPLY_METHOD, LambdaStaticInvoker, CXXMethodDecl, NthDecl) - MX_VISIT_OPTIONAL_ENUM(CXXRecordDecl, ms_inheritance_model, 79, MX_APPLY_METHOD, MSInheritanceModel, MSInheritanceModel, NthDecl) - MX_VISIT_ENUM(CXXRecordDecl, ms_vtor_disp_mode, 80, MX_APPLY_METHOD, MSVtorDispMode, MSVtorDispMode, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_any_dependent_bases, 133, MX_APPLY_METHOD, HasAnyDependentBases, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_constexpr_default_constructor, 135, MX_APPLY_METHOD, HasConstexprDefaultConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_constexpr_destructor, 137, MX_APPLY_METHOD, HasConstexprDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_constexpr_non_copy_move_constructor, 139, MX_APPLY_METHOD, HasConstexprNonCopyMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_copy_assignment_with_const_parameter, 141, MX_APPLY_METHOD, HasCopyAssignmentWithConstParameter, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_copy_constructor_with_const_parameter, 143, MX_APPLY_METHOD, HasCopyConstructorWithConstParameter, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_default_constructor, 145, MX_APPLY_METHOD, HasDefaultConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_definition, 147, MX_APPLY_METHOD, HasDefinition, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_direct_fields, 149, MX_APPLY_METHOD, HasDirectFields, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_friends, 151, MX_APPLY_METHOD, HasFriends, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_in_class_initializer, 159, MX_APPLY_METHOD, HasInClassInitializer, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_inherited_assignment, 161, MX_APPLY_METHOD, HasInheritedAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_inherited_constructor, 163, MX_APPLY_METHOD, HasInheritedConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_initializer_method, 165, MX_APPLY_METHOD, HasInitializerMethod, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_irrelevant_destructor, 167, MX_APPLY_METHOD, HasIrrelevantDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_known_lambda_internal_linkage, 173, MX_APPLY_METHOD, HasKnownLambdaInternalLinkage, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_move_assignment, 176, MX_APPLY_METHOD, HasMoveAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_move_constructor, 179, MX_APPLY_METHOD, HasMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_mutable_fields, 181, MX_APPLY_METHOD, HasMutableFields, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_literal_type_fields_or_bases, 183, MX_APPLY_METHOD, HasNonLiteralTypeFieldsOrBases, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_copy_assignment, 185, MX_APPLY_METHOD, HasNonTrivialCopyAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_copy_constructor, 187, MX_APPLY_METHOD, HasNonTrivialCopyConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_copy_constructor_for_call, 189, MX_APPLY_METHOD, HasNonTrivialCopyConstructorForCall, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_default_constructor, 191, MX_APPLY_METHOD, HasNonTrivialDefaultConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_destructor, 193, MX_APPLY_METHOD, HasNonTrivialDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_destructor_for_call, 195, MX_APPLY_METHOD, HasNonTrivialDestructorForCall, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_move_assignment, 197, MX_APPLY_METHOD, HasNonTrivialMoveAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_move_constructor, 199, MX_APPLY_METHOD, HasNonTrivialMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_move_constructor_for_call, 201, MX_APPLY_METHOD, HasNonTrivialMoveConstructorForCall, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_private_fields, 203, MX_APPLY_METHOD, HasPrivateFields, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_protected_fields, 205, MX_APPLY_METHOD, HasProtectedFields, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_copy_assignment, 207, MX_APPLY_METHOD, HasSimpleCopyAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_copy_constructor, 209, MX_APPLY_METHOD, HasSimpleCopyConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_destructor, 211, MX_APPLY_METHOD, HasSimpleDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_move_assignment, 213, MX_APPLY_METHOD, HasSimpleMoveAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_move_constructor, 215, MX_APPLY_METHOD, HasSimpleMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_copy_assignment, 217, MX_APPLY_METHOD, HasTrivialCopyAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_copy_constructor, 219, MX_APPLY_METHOD, HasTrivialCopyConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_copy_constructor_for_call, 221, MX_APPLY_METHOD, HasTrivialCopyConstructorForCall, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_default_constructor, 223, MX_APPLY_METHOD, HasTrivialDefaultConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_destructor, 225, MX_APPLY_METHOD, HasTrivialDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_destructor_for_call, 227, MX_APPLY_METHOD, HasTrivialDestructorForCall, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_move_assignment, 229, MX_APPLY_METHOD, HasTrivialMoveAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_move_constructor, 231, MX_APPLY_METHOD, HasTrivialMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_move_constructor_for_call, 233, MX_APPLY_METHOD, HasTrivialMoveConstructorForCall, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_uninitialized_reference_member, 235, MX_APPLY_METHOD, HasUninitializedReferenceMember, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_constructor, 237, MX_APPLY_METHOD, HasUserDeclaredConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_copy_assignment, 239, MX_APPLY_METHOD, HasUserDeclaredCopyAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_copy_constructor, 241, MX_APPLY_METHOD, HasUserDeclaredCopyConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_destructor, 243, MX_APPLY_METHOD, HasUserDeclaredDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_move_assignment, 245, MX_APPLY_METHOD, HasUserDeclaredMoveAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_move_constructor, 247, MX_APPLY_METHOD, HasUserDeclaredMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_move_operation, 249, MX_APPLY_METHOD, HasUserDeclaredMoveOperation, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_provided_default_constructor, 251, MX_APPLY_METHOD, HasUserProvidedDefaultConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_variant_members, 253, MX_APPLY_METHOD, HasVariantMembers, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, implicit_copy_assignment_has_const_parameter, 255, MX_APPLY_METHOD, ImplicitCopyAssignmentHasConstParameter, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, implicit_copy_constructor_has_const_parameter, 257, MX_APPLY_METHOD, ImplicitCopyConstructorHasConstParameter, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_abstract, 259, MX_APPLY_METHOD, IsAbstract, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_aggregate, 261, MX_APPLY_METHOD, IsAggregate, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_any_destructor_no_return, 263, MX_APPLY_METHOD, IsAnyDestructorNoReturn, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_c_like, 265, MX_APPLY_METHOD, IsCLike, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_cxx11_standard_layout, 267, MX_APPLY_METHOD, IsCXX11StandardLayout, bool, NthDecl) - MX_VISIT_BOOL(CXXRecordDecl, is_captureless_lambda, 269, MX_APPLY_METHOD, IsCapturelessLambda, bool, NthDecl) - MX_VISIT_BOOL(CXXRecordDecl, is_dependent_lambda, 270, MX_APPLY_METHOD, IsDependentLambda, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_dynamic_class, 271, MX_APPLY_METHOD, IsDynamicClass, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_effectively_final, 273, MX_APPLY_METHOD, IsEffectivelyFinal, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_empty, 275, MX_APPLY_METHOD, IsEmpty, bool, NthDecl) - MX_VISIT_BOOL(CXXRecordDecl, is_generic_lambda, 277, MX_APPLY_METHOD, IsGenericLambda, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_interface_like, 278, MX_APPLY_METHOD, IsInterfaceLike, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_literal, 280, MX_APPLY_METHOD, IsLiteral, bool, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, is_local_class, 152, MX_APPLY_METHOD, IsLocalClass, FunctionDecl, NthDecl) - MX_VISIT_BOOL(CXXRecordDecl, is_never_dependent_lambda, 282, MX_APPLY_METHOD, IsNeverDependentLambda, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_pod, 283, MX_APPLY_METHOD, IsPOD, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_polymorphic, 285, MX_APPLY_METHOD, IsPolymorphic, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_standard_layout, 287, MX_APPLY_METHOD, IsStandardLayout, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_structural, 289, MX_APPLY_METHOD, IsStructural, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_trivial, 291, MX_APPLY_METHOD, IsTrivial, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_trivially_copy_constructible, 293, MX_APPLY_METHOD, IsTriviallyCopyConstructible, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_trivially_copyable, 295, MX_APPLY_METHOD, IsTriviallyCopyable, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, lambda_is_default_constructible_and_assignable, 297, MX_APPLY_METHOD, LambdaIsDefaultConstructibleAndAssignable, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, may_be_abstract, 299, MX_APPLY_METHOD, MayBeAbstract, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, may_be_dynamic_class, 301, MX_APPLY_METHOD, MayBeDynamicClass, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, may_be_non_dynamic_class, 303, MX_APPLY_METHOD, MayBeNonDynamicClass, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_copy_assignment, 305, MX_APPLY_METHOD, NeedsImplicitCopyAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_copy_constructor, 307, MX_APPLY_METHOD, NeedsImplicitCopyConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_default_constructor, 309, MX_APPLY_METHOD, NeedsImplicitDefaultConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_destructor, 311, MX_APPLY_METHOD, NeedsImplicitDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_move_assignment, 313, MX_APPLY_METHOD, NeedsImplicitMoveAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_move_constructor, 315, MX_APPLY_METHOD, NeedsImplicitMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_copy_assignment, 317, MX_APPLY_METHOD, NeedsOverloadResolutionForCopyAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_copy_constructor, 319, MX_APPLY_METHOD, NeedsOverloadResolutionForCopyConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_destructor, 321, MX_APPLY_METHOD, NeedsOverloadResolutionForDestructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_move_assignment, 323, MX_APPLY_METHOD, NeedsOverloadResolutionForMoveAssignment, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_move_constructor, 325, MX_APPLY_METHOD, NeedsOverloadResolutionForMoveConstructor, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, null_field_offset_is_zero, 327, MX_APPLY_METHOD, NullFieldOffsetIsZero, bool, NthDecl) - MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, virtual_bases, 329, MX_APPLY_METHOD, VirtualBases, CXXBaseSpecifier, NthDecl) - MX_VISIT_OPTIONAL_INT(CXXRecordDecl, size_without_virtual_bases, 154, MX_APPLY_METHOD, SizeWithoutVirtualBases, , NthDecl) - MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, primary_base, 155, MX_APPLY_METHOD, PrimaryBase, CXXRecordDecl, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_own_virtual_function_table_pointer, 332, MX_APPLY_METHOD, HasOwnVirtualFunctionTablePointer, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_extendable_virtual_function_table_pointer, 334, MX_APPLY_METHOD, HasExtendableVirtualFunctionTablePointer, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_virtual_base_table_pointer, 336, MX_APPLY_METHOD, HasVirtualBaseTablePointer, bool, NthDecl) - MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_own_virtual_base_table_pointer, 338, MX_APPLY_METHOD, HasOwnVirtualBaseTablePointer, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, allow_const_default_initializer, 123, MX_APPLY_METHOD, AllowConstDefaultInitializer, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, bases, 154, MX_APPLY_METHOD, Bases, CXXBaseSpecifier, NthDecl) + MX_VISIT_OPTIONAL_ENUM(CXXRecordDecl, inheritance_model, 78, MX_APPLY_METHOD, CalculateInheritanceModel, MSInheritanceModel, NthDecl) + MX_VISIT_ENTITY_LIST(CXXRecordDecl, constructors, 169, MX_APPLY_METHOD, Constructors, CXXConstructorDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, friends, 175, MX_APPLY_METHOD, Friends, FriendDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, dependent_lambda_call_operator, 75, MX_APPLY_METHOD, DependentLambdaCallOperator, FunctionTemplateDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, described_class_template, 76, MX_APPLY_METHOD, DescribedClassTemplate, ClassTemplateDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, destructor, 114, MX_APPLY_METHOD, Destructor, CXXDestructorDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, generic_lambda_template_parameter_list, 115, MX_APPLY_METHOD, GenericLambdaTemplateParameterList, TemplateParameterList, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, instantiated_from_member_class, 116, MX_APPLY_METHOD, InstantiatedFromMemberClass, CXXRecordDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, lambda_call_operator, 117, MX_APPLY_METHOD, LambdaCallOperator, CXXMethodDecl, NthDecl) + MX_VISIT_OPTIONAL_ENUM(CXXRecordDecl, lambda_capture_default, 79, MX_APPLY_METHOD, LambdaCaptureDefault, LambdaCaptureDefault, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, lambda_context_declaration, 120, MX_APPLY_METHOD, LambdaContextDeclaration, Decl, NthDecl) + MX_VISIT_INT(CXXRecordDecl, lambda_dependency_kind, 42, MX_APPLY_METHOD, LambdaDependencyKind, uint32_t, NthDecl) + MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, lambda_explicit_template_parameters, 179, MX_APPLY_METHOD, LambdaExplicitTemplateParameters, NamedDecl, NthDecl) + MX_VISIT_OPTIONAL_INT(CXXRecordDecl, lambda_mangling_number, 118, MX_APPLY_METHOD, LambdaManglingNumber, , NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, lambda_static_invoker, 121, MX_APPLY_METHOD, LambdaStaticInvoker, CXXMethodDecl, NthDecl) + MX_VISIT_OPTIONAL_ENUM(CXXRecordDecl, ms_inheritance_model, 80, MX_APPLY_METHOD, MSInheritanceModel, MSInheritanceModel, NthDecl) + MX_VISIT_ENUM(CXXRecordDecl, ms_vtor_disp_mode, 81, MX_APPLY_METHOD, MSVtorDispMode, MSVtorDispMode, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_any_dependent_bases, 134, MX_APPLY_METHOD, HasAnyDependentBases, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_constexpr_default_constructor, 136, MX_APPLY_METHOD, HasConstexprDefaultConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_constexpr_destructor, 138, MX_APPLY_METHOD, HasConstexprDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_constexpr_non_copy_move_constructor, 140, MX_APPLY_METHOD, HasConstexprNonCopyMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_copy_assignment_with_const_parameter, 142, MX_APPLY_METHOD, HasCopyAssignmentWithConstParameter, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_copy_constructor_with_const_parameter, 144, MX_APPLY_METHOD, HasCopyConstructorWithConstParameter, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_default_constructor, 146, MX_APPLY_METHOD, HasDefaultConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_definition, 148, MX_APPLY_METHOD, HasDefinition, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_direct_fields, 150, MX_APPLY_METHOD, HasDirectFields, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_friends, 152, MX_APPLY_METHOD, HasFriends, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_in_class_initializer, 160, MX_APPLY_METHOD, HasInClassInitializer, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_inherited_assignment, 162, MX_APPLY_METHOD, HasInheritedAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_inherited_constructor, 164, MX_APPLY_METHOD, HasInheritedConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_initializer_method, 166, MX_APPLY_METHOD, HasInitializerMethod, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_irrelevant_destructor, 168, MX_APPLY_METHOD, HasIrrelevantDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_known_lambda_internal_linkage, 174, MX_APPLY_METHOD, HasKnownLambdaInternalLinkage, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_move_assignment, 177, MX_APPLY_METHOD, HasMoveAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_move_constructor, 180, MX_APPLY_METHOD, HasMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_mutable_fields, 182, MX_APPLY_METHOD, HasMutableFields, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_literal_type_fields_or_bases, 184, MX_APPLY_METHOD, HasNonLiteralTypeFieldsOrBases, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_copy_assignment, 186, MX_APPLY_METHOD, HasNonTrivialCopyAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_copy_constructor, 188, MX_APPLY_METHOD, HasNonTrivialCopyConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_copy_constructor_for_call, 190, MX_APPLY_METHOD, HasNonTrivialCopyConstructorForCall, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_default_constructor, 192, MX_APPLY_METHOD, HasNonTrivialDefaultConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_destructor, 194, MX_APPLY_METHOD, HasNonTrivialDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_destructor_for_call, 196, MX_APPLY_METHOD, HasNonTrivialDestructorForCall, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_move_assignment, 198, MX_APPLY_METHOD, HasNonTrivialMoveAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_move_constructor, 200, MX_APPLY_METHOD, HasNonTrivialMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_non_trivial_move_constructor_for_call, 202, MX_APPLY_METHOD, HasNonTrivialMoveConstructorForCall, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_private_fields, 204, MX_APPLY_METHOD, HasPrivateFields, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_protected_fields, 206, MX_APPLY_METHOD, HasProtectedFields, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_copy_assignment, 208, MX_APPLY_METHOD, HasSimpleCopyAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_copy_constructor, 210, MX_APPLY_METHOD, HasSimpleCopyConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_destructor, 212, MX_APPLY_METHOD, HasSimpleDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_move_assignment, 214, MX_APPLY_METHOD, HasSimpleMoveAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_simple_move_constructor, 216, MX_APPLY_METHOD, HasSimpleMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_copy_assignment, 218, MX_APPLY_METHOD, HasTrivialCopyAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_copy_constructor, 220, MX_APPLY_METHOD, HasTrivialCopyConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_copy_constructor_for_call, 222, MX_APPLY_METHOD, HasTrivialCopyConstructorForCall, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_default_constructor, 224, MX_APPLY_METHOD, HasTrivialDefaultConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_destructor, 226, MX_APPLY_METHOD, HasTrivialDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_destructor_for_call, 228, MX_APPLY_METHOD, HasTrivialDestructorForCall, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_move_assignment, 230, MX_APPLY_METHOD, HasTrivialMoveAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_move_constructor, 232, MX_APPLY_METHOD, HasTrivialMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_trivial_move_constructor_for_call, 234, MX_APPLY_METHOD, HasTrivialMoveConstructorForCall, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_uninitialized_reference_member, 236, MX_APPLY_METHOD, HasUninitializedReferenceMember, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_constructor, 238, MX_APPLY_METHOD, HasUserDeclaredConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_copy_assignment, 240, MX_APPLY_METHOD, HasUserDeclaredCopyAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_copy_constructor, 242, MX_APPLY_METHOD, HasUserDeclaredCopyConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_destructor, 244, MX_APPLY_METHOD, HasUserDeclaredDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_move_assignment, 246, MX_APPLY_METHOD, HasUserDeclaredMoveAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_move_constructor, 248, MX_APPLY_METHOD, HasUserDeclaredMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_declared_move_operation, 250, MX_APPLY_METHOD, HasUserDeclaredMoveOperation, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_user_provided_default_constructor, 252, MX_APPLY_METHOD, HasUserProvidedDefaultConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_variant_members, 254, MX_APPLY_METHOD, HasVariantMembers, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, implicit_copy_assignment_has_const_parameter, 256, MX_APPLY_METHOD, ImplicitCopyAssignmentHasConstParameter, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, implicit_copy_constructor_has_const_parameter, 258, MX_APPLY_METHOD, ImplicitCopyConstructorHasConstParameter, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_abstract, 260, MX_APPLY_METHOD, IsAbstract, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_aggregate, 262, MX_APPLY_METHOD, IsAggregate, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_any_destructor_no_return, 264, MX_APPLY_METHOD, IsAnyDestructorNoReturn, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_c_like, 266, MX_APPLY_METHOD, IsCLike, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_cxx11_standard_layout, 268, MX_APPLY_METHOD, IsCXX11StandardLayout, bool, NthDecl) + MX_VISIT_BOOL(CXXRecordDecl, is_captureless_lambda, 270, MX_APPLY_METHOD, IsCapturelessLambda, bool, NthDecl) + MX_VISIT_BOOL(CXXRecordDecl, is_dependent_lambda, 271, MX_APPLY_METHOD, IsDependentLambda, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_dynamic_class, 272, MX_APPLY_METHOD, IsDynamicClass, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_effectively_final, 274, MX_APPLY_METHOD, IsEffectivelyFinal, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_empty, 276, MX_APPLY_METHOD, IsEmpty, bool, NthDecl) + MX_VISIT_BOOL(CXXRecordDecl, is_generic_lambda, 278, MX_APPLY_METHOD, IsGenericLambda, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_interface_like, 279, MX_APPLY_METHOD, IsInterfaceLike, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_literal, 281, MX_APPLY_METHOD, IsLiteral, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, is_local_class, 153, MX_APPLY_METHOD, IsLocalClass, FunctionDecl, NthDecl) + MX_VISIT_BOOL(CXXRecordDecl, is_never_dependent_lambda, 283, MX_APPLY_METHOD, IsNeverDependentLambda, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_pod, 284, MX_APPLY_METHOD, IsPOD, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_polymorphic, 286, MX_APPLY_METHOD, IsPolymorphic, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_standard_layout, 288, MX_APPLY_METHOD, IsStandardLayout, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_structural, 290, MX_APPLY_METHOD, IsStructural, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_trivial, 292, MX_APPLY_METHOD, IsTrivial, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_trivially_copy_constructible, 294, MX_APPLY_METHOD, IsTriviallyCopyConstructible, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, is_trivially_copyable, 296, MX_APPLY_METHOD, IsTriviallyCopyable, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, lambda_is_default_constructible_and_assignable, 298, MX_APPLY_METHOD, LambdaIsDefaultConstructibleAndAssignable, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, may_be_abstract, 300, MX_APPLY_METHOD, MayBeAbstract, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, may_be_dynamic_class, 302, MX_APPLY_METHOD, MayBeDynamicClass, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, may_be_non_dynamic_class, 304, MX_APPLY_METHOD, MayBeNonDynamicClass, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_copy_assignment, 306, MX_APPLY_METHOD, NeedsImplicitCopyAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_copy_constructor, 308, MX_APPLY_METHOD, NeedsImplicitCopyConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_default_constructor, 310, MX_APPLY_METHOD, NeedsImplicitDefaultConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_destructor, 312, MX_APPLY_METHOD, NeedsImplicitDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_move_assignment, 314, MX_APPLY_METHOD, NeedsImplicitMoveAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_implicit_move_constructor, 316, MX_APPLY_METHOD, NeedsImplicitMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_copy_assignment, 318, MX_APPLY_METHOD, NeedsOverloadResolutionForCopyAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_copy_constructor, 320, MX_APPLY_METHOD, NeedsOverloadResolutionForCopyConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_destructor, 322, MX_APPLY_METHOD, NeedsOverloadResolutionForDestructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_move_assignment, 324, MX_APPLY_METHOD, NeedsOverloadResolutionForMoveAssignment, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, needs_overload_resolution_for_move_constructor, 326, MX_APPLY_METHOD, NeedsOverloadResolutionForMoveConstructor, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, null_field_offset_is_zero, 328, MX_APPLY_METHOD, NullFieldOffsetIsZero, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY_LIST(CXXRecordDecl, virtual_bases, 330, MX_APPLY_METHOD, VirtualBases, CXXBaseSpecifier, NthDecl) + MX_VISIT_OPTIONAL_INT(CXXRecordDecl, size_without_virtual_bases, 155, MX_APPLY_METHOD, SizeWithoutVirtualBases, , NthDecl) + MX_VISIT_OPTIONAL_ENTITY(CXXRecordDecl, primary_base, 156, MX_APPLY_METHOD, PrimaryBase, CXXRecordDecl, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_own_virtual_function_table_pointer, 333, MX_APPLY_METHOD, HasOwnVirtualFunctionTablePointer, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_extendable_virtual_function_table_pointer, 335, MX_APPLY_METHOD, HasExtendableVirtualFunctionTablePointer, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_virtual_base_table_pointer, 337, MX_APPLY_METHOD, HasVirtualBaseTablePointer, bool, NthDecl) + MX_VISIT_OPTIONAL_BOOL(CXXRecordDecl, has_own_virtual_base_table_pointer, 339, MX_APPLY_METHOD, HasOwnVirtualBaseTablePointer, bool, NthDecl) MX_EXIT_VISIT_CXXRecordDecl MX_END_VISIT_DECL(CXXRecordDecl) @@ -19589,14 +19594,14 @@ MX_END_VISIT_DECL(CXXRecordDecl) MX_BEGIN_VISIT_DECL(ClassTemplateSpecializationDecl) MX_ENTER_VISIT_ClassTemplateSpecializationDecl MX_VISIT_BASE(ClassTemplateSpecializationDecl, CXXRecordDecl) - MX_VISIT_ENTITY(ClassTemplateSpecializationDecl, extern_token, 157, MX_APPLY_METHOD, ExternToken, Token, NthDecl) - MX_VISIT_ENUM(ClassTemplateSpecializationDecl, specialization_kind, 118, MX_APPLY_METHOD, SpecializationKind, TemplateSpecializationKind, NthDecl) - MX_VISIT_ENTITY(ClassTemplateSpecializationDecl, specialized_template, 170, MX_APPLY_METHOD, SpecializedTemplate, ClassTemplateDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ClassTemplateSpecializationDecl, template_arguments, 340, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) - MX_VISIT_ENTITY(ClassTemplateSpecializationDecl, template_keyword_token, 171, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthDecl) - MX_VISIT_BOOL(ClassTemplateSpecializationDecl, is_class_scope_explicit_specialization, 341, MX_APPLY_METHOD, IsClassScopeExplicitSpecialization, bool, NthDecl) - MX_VISIT_BOOL(ClassTemplateSpecializationDecl, is_explicit_instantiation_or_specialization, 342, MX_APPLY_METHOD, IsExplicitInstantiationOrSpecialization, bool, NthDecl) - MX_VISIT_BOOL(ClassTemplateSpecializationDecl, is_explicit_specialization, 343, MX_APPLY_METHOD, IsExplicitSpecialization, bool, NthDecl) + MX_VISIT_ENTITY(ClassTemplateSpecializationDecl, extern_token, 158, MX_APPLY_METHOD, ExternToken, Token, NthDecl) + MX_VISIT_ENUM(ClassTemplateSpecializationDecl, specialization_kind, 119, MX_APPLY_METHOD, SpecializationKind, TemplateSpecializationKind, NthDecl) + MX_VISIT_ENTITY(ClassTemplateSpecializationDecl, specialized_template, 171, MX_APPLY_METHOD, SpecializedTemplate, ClassTemplateDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ClassTemplateSpecializationDecl, template_arguments, 341, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) + MX_VISIT_ENTITY(ClassTemplateSpecializationDecl, template_keyword_token, 172, MX_APPLY_METHOD, TemplateKeywordToken, Token, NthDecl) + MX_VISIT_BOOL(ClassTemplateSpecializationDecl, is_class_scope_explicit_specialization, 342, MX_APPLY_METHOD, IsClassScopeExplicitSpecialization, bool, NthDecl) + MX_VISIT_BOOL(ClassTemplateSpecializationDecl, is_explicit_instantiation_or_specialization, 343, MX_APPLY_METHOD, IsExplicitInstantiationOrSpecialization, bool, NthDecl) + MX_VISIT_BOOL(ClassTemplateSpecializationDecl, is_explicit_specialization, 344, MX_APPLY_METHOD, IsExplicitSpecialization, bool, NthDecl) MX_EXIT_VISIT_ClassTemplateSpecializationDecl MX_END_VISIT_DECL(ClassTemplateSpecializationDecl) @@ -19610,9 +19615,9 @@ MX_END_VISIT_DECL(ClassTemplateSpecializationDecl) MX_BEGIN_VISIT_DECL(ClassTemplatePartialSpecializationDecl) MX_ENTER_VISIT_ClassTemplatePartialSpecializationDecl MX_VISIT_BASE(ClassTemplatePartialSpecializationDecl, ClassTemplateSpecializationDecl) - MX_VISIT_ENTITY(ClassTemplatePartialSpecializationDecl, injected_specialization_type, 344, MX_APPLY_METHOD, InjectedSpecializationType, Type, NthDecl) - MX_VISIT_ENTITY(ClassTemplatePartialSpecializationDecl, template_parameters, 345, MX_APPLY_METHOD, TemplateParameters, TemplateParameterList, NthDecl) - MX_VISIT_BOOL(ClassTemplatePartialSpecializationDecl, has_associated_constraints, 346, MX_APPLY_METHOD, HasAssociatedConstraints, bool, NthDecl) + MX_VISIT_ENTITY(ClassTemplatePartialSpecializationDecl, injected_specialization_type, 345, MX_APPLY_METHOD, InjectedSpecializationType, Type, NthDecl) + MX_VISIT_ENTITY(ClassTemplatePartialSpecializationDecl, template_parameters, 346, MX_APPLY_METHOD, TemplateParameters, TemplateParameterList, NthDecl) + MX_VISIT_BOOL(ClassTemplatePartialSpecializationDecl, has_associated_constraints, 347, MX_APPLY_METHOD, HasAssociatedConstraints, bool, NthDecl) MX_EXIT_VISIT_ClassTemplatePartialSpecializationDecl MX_END_VISIT_DECL(ClassTemplatePartialSpecializationDecl) @@ -19626,17 +19631,17 @@ MX_END_VISIT_DECL(ClassTemplatePartialSpecializationDecl) MX_BEGIN_VISIT_DECL(EnumDecl) MX_ENTER_VISIT_EnumDecl MX_VISIT_BASE(EnumDecl, TagDecl) - MX_VISIT_ENTITY_LIST(EnumDecl, enumerators, 54, MX_APPLY_METHOD, Enumerators, EnumConstantDecl, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(EnumDecl, integer_type, 70, MX_APPLY_METHOD, IntegerType, Type, NthDecl) - MX_VISIT_TOKEN_RANGE(EnumDecl, integer_type_range, 71, 73, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(EnumDecl, promotion_type, 74, MX_APPLY_METHOD, PromotionType, Type, NthDecl) - MX_VISIT_BOOL(EnumDecl, is_closed, 91, MX_APPLY_METHOD, IsClosed, bool, NthDecl) - MX_VISIT_BOOL(EnumDecl, is_closed_flag, 92, MX_APPLY_METHOD, IsClosedFlag, bool, NthDecl) - MX_VISIT_BOOL(EnumDecl, is_closed_non_flag, 93, MX_APPLY_METHOD, IsClosedNonFlag, bool, NthDecl) - MX_VISIT_BOOL(EnumDecl, is_complete, 94, MX_APPLY_METHOD, IsComplete, bool, NthDecl) - MX_VISIT_BOOL(EnumDecl, is_fixed, 95, MX_APPLY_METHOD, IsFixed, bool, NthDecl) - MX_VISIT_BOOL(EnumDecl, is_scoped, 96, MX_APPLY_METHOD, IsScoped, bool, NthDecl) - MX_VISIT_BOOL(EnumDecl, is_scoped_using_class_tag, 97, MX_APPLY_METHOD, IsScopedUsingClassTag, bool, NthDecl) + MX_VISIT_ENTITY_LIST(EnumDecl, enumerators, 55, MX_APPLY_METHOD, Enumerators, EnumConstantDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(EnumDecl, integer_type, 71, MX_APPLY_METHOD, IntegerType, Type, NthDecl) + MX_VISIT_TOKEN_RANGE(EnumDecl, integer_type_range, 72, 74, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(EnumDecl, promotion_type, 75, MX_APPLY_METHOD, PromotionType, Type, NthDecl) + MX_VISIT_BOOL(EnumDecl, is_closed, 92, MX_APPLY_METHOD, IsClosed, bool, NthDecl) + MX_VISIT_BOOL(EnumDecl, is_closed_flag, 93, MX_APPLY_METHOD, IsClosedFlag, bool, NthDecl) + MX_VISIT_BOOL(EnumDecl, is_closed_non_flag, 94, MX_APPLY_METHOD, IsClosedNonFlag, bool, NthDecl) + MX_VISIT_BOOL(EnumDecl, is_complete, 95, MX_APPLY_METHOD, IsComplete, bool, NthDecl) + MX_VISIT_BOOL(EnumDecl, is_fixed, 96, MX_APPLY_METHOD, IsFixed, bool, NthDecl) + MX_VISIT_BOOL(EnumDecl, is_scoped, 97, MX_APPLY_METHOD, IsScoped, bool, NthDecl) + MX_VISIT_BOOL(EnumDecl, is_scoped_using_class_tag, 98, MX_APPLY_METHOD, IsScopedUsingClassTag, bool, NthDecl) MX_EXIT_VISIT_EnumDecl MX_END_VISIT_DECL(EnumDecl) @@ -19650,10 +19655,10 @@ MX_END_VISIT_DECL(EnumDecl) MX_BEGIN_VISIT_DECL(UnresolvedUsingTypenameDecl) MX_ENTER_VISIT_UnresolvedUsingTypenameDecl MX_VISIT_BASE(UnresolvedUsingTypenameDecl, TypeDecl) - MX_VISIT_ENTITY(UnresolvedUsingTypenameDecl, ellipsis_token, 49, MX_APPLY_METHOD, EllipsisToken, Token, NthDecl) - MX_VISIT_ENTITY(UnresolvedUsingTypenameDecl, typename_token, 50, MX_APPLY_METHOD, TypenameToken, Token, NthDecl) - MX_VISIT_ENTITY(UnresolvedUsingTypenameDecl, using_token, 58, MX_APPLY_METHOD, UsingToken, Token, NthDecl) - MX_VISIT_BOOL(UnresolvedUsingTypenameDecl, is_pack_expansion, 66, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) + MX_VISIT_ENTITY(UnresolvedUsingTypenameDecl, ellipsis_token, 50, MX_APPLY_METHOD, EllipsisToken, Token, NthDecl) + MX_VISIT_ENTITY(UnresolvedUsingTypenameDecl, typename_token, 51, MX_APPLY_METHOD, TypenameToken, Token, NthDecl) + MX_VISIT_ENTITY(UnresolvedUsingTypenameDecl, using_token, 59, MX_APPLY_METHOD, UsingToken, Token, NthDecl) + MX_VISIT_BOOL(UnresolvedUsingTypenameDecl, is_pack_expansion, 67, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) MX_EXIT_VISIT_UnresolvedUsingTypenameDecl MX_END_VISIT_DECL(UnresolvedUsingTypenameDecl) @@ -19667,10 +19672,10 @@ MX_END_VISIT_DECL(UnresolvedUsingTypenameDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(TypedefNameDecl) MX_ENTER_VISIT_TypedefNameDecl MX_VISIT_BASE(TypedefNameDecl, TypeDecl) - MX_VISIT_OPTIONAL_ENTITY(TypedefNameDecl, anonymous_declaration_with_typedef_name, 49, MX_APPLY_METHOD, AnonymousDeclarationWithTypedefName, TagDecl, NthDecl) - MX_VISIT_ENTITY(TypedefNameDecl, underlying_type, 50, MX_APPLY_METHOD, UnderlyingType, Type, NthDecl) - MX_VISIT_BOOL(TypedefNameDecl, is_moded, 66, MX_APPLY_METHOD, IsModed, bool, NthDecl) - MX_VISIT_BOOL(TypedefNameDecl, is_transparent_tag, 67, MX_APPLY_METHOD, IsTransparentTag, bool, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(TypedefNameDecl, anonymous_declaration_with_typedef_name, 50, MX_APPLY_METHOD, AnonymousDeclarationWithTypedefName, TagDecl, NthDecl) + MX_VISIT_ENTITY(TypedefNameDecl, underlying_type, 51, MX_APPLY_METHOD, UnderlyingType, Type, NthDecl) + MX_VISIT_BOOL(TypedefNameDecl, is_moded, 67, MX_APPLY_METHOD, IsModed, bool, NthDecl) + MX_VISIT_BOOL(TypedefNameDecl, is_transparent_tag, 68, MX_APPLY_METHOD, IsTransparentTag, bool, NthDecl) MX_EXIT_VISIT_TypedefNameDecl MX_END_VISIT_DECL(TypedefNameDecl) @@ -19697,7 +19702,7 @@ MX_END_VISIT_DECL(TypedefDecl) MX_BEGIN_VISIT_DECL(TypeAliasDecl) MX_ENTER_VISIT_TypeAliasDecl MX_VISIT_BASE(TypeAliasDecl, TypedefNameDecl) - MX_VISIT_OPTIONAL_ENTITY(TypeAliasDecl, described_alias_template, 58, MX_APPLY_METHOD, DescribedAliasTemplate, TypeAliasTemplateDecl, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(TypeAliasDecl, described_alias_template, 59, MX_APPLY_METHOD, DescribedAliasTemplate, TypeAliasTemplateDecl, NthDecl) MX_EXIT_VISIT_TypeAliasDecl MX_END_VISIT_DECL(TypeAliasDecl) @@ -19711,11 +19716,11 @@ MX_END_VISIT_DECL(TypeAliasDecl) MX_BEGIN_VISIT_DECL(ObjCTypeParamDecl) MX_ENTER_VISIT_ObjCTypeParamDecl MX_VISIT_BASE(ObjCTypeParamDecl, TypedefNameDecl) - MX_VISIT_ENTITY(ObjCTypeParamDecl, colon_token, 58, MX_APPLY_METHOD, ColonToken, Token, NthDecl) - MX_VISIT_INT(ObjCTypeParamDecl, index, 41, MX_APPLY_METHOD, Index, uint32_t, NthDecl) - MX_VISIT_ENUM(ObjCTypeParamDecl, variance, 72, MX_APPLY_METHOD, Variance, ObjCTypeParamVariance, NthDecl) - MX_VISIT_ENTITY(ObjCTypeParamDecl, variance_token, 59, MX_APPLY_METHOD, VarianceToken, Token, NthDecl) - MX_VISIT_BOOL(ObjCTypeParamDecl, has_explicit_bound, 68, MX_APPLY_METHOD, HasExplicitBound, bool, NthDecl) + MX_VISIT_ENTITY(ObjCTypeParamDecl, colon_token, 59, MX_APPLY_METHOD, ColonToken, Token, NthDecl) + MX_VISIT_INT(ObjCTypeParamDecl, index, 42, MX_APPLY_METHOD, Index, uint32_t, NthDecl) + MX_VISIT_ENUM(ObjCTypeParamDecl, variance, 73, MX_APPLY_METHOD, Variance, ObjCTypeParamVariance, NthDecl) + MX_VISIT_ENTITY(ObjCTypeParamDecl, variance_token, 60, MX_APPLY_METHOD, VarianceToken, Token, NthDecl) + MX_VISIT_BOOL(ObjCTypeParamDecl, has_explicit_bound, 69, MX_APPLY_METHOD, HasExplicitBound, bool, NthDecl) MX_EXIT_VISIT_ObjCTypeParamDecl MX_END_VISIT_DECL(ObjCTypeParamDecl) @@ -19729,10 +19734,10 @@ MX_END_VISIT_DECL(ObjCTypeParamDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(TemplateDecl) MX_ENTER_VISIT_TemplateDecl MX_VISIT_BASE(TemplateDecl, NamedDecl) - MX_VISIT_ENTITY(TemplateDecl, template_parameters, 48, MX_APPLY_METHOD, TemplateParameters, TemplateParameterList, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(TemplateDecl, templated_declaration, 49, MX_APPLY_METHOD, TemplatedDeclaration, NamedDecl, NthDecl) - MX_VISIT_BOOL(TemplateDecl, has_associated_constraints, 66, MX_APPLY_METHOD, HasAssociatedConstraints, bool, NthDecl) - MX_VISIT_BOOL(TemplateDecl, is_type_alias, 67, MX_APPLY_METHOD, IsTypeAlias, bool, NthDecl) + MX_VISIT_ENTITY(TemplateDecl, template_parameters, 49, MX_APPLY_METHOD, TemplateParameters, TemplateParameterList, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(TemplateDecl, templated_declaration, 50, MX_APPLY_METHOD, TemplatedDeclaration, NamedDecl, NthDecl) + MX_VISIT_BOOL(TemplateDecl, has_associated_constraints, 67, MX_APPLY_METHOD, HasAssociatedConstraints, bool, NthDecl) + MX_VISIT_BOOL(TemplateDecl, is_type_alias, 68, MX_APPLY_METHOD, IsTypeAlias, bool, NthDecl) MX_EXIT_VISIT_TemplateDecl MX_END_VISIT_DECL(TemplateDecl) @@ -19746,7 +19751,7 @@ MX_END_VISIT_DECL(TemplateDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(RedeclarableTemplateDecl) MX_ENTER_VISIT_RedeclarableTemplateDecl MX_VISIT_BASE(RedeclarableTemplateDecl, TemplateDecl) - MX_VISIT_BOOL(RedeclarableTemplateDecl, is_member_specialization, 68, MX_APPLY_METHOD, IsMemberSpecialization, bool, NthDecl) + MX_VISIT_BOOL(RedeclarableTemplateDecl, is_member_specialization, 69, MX_APPLY_METHOD, IsMemberSpecialization, bool, NthDecl) MX_EXIT_VISIT_RedeclarableTemplateDecl MX_END_VISIT_DECL(RedeclarableTemplateDecl) @@ -19760,8 +19765,8 @@ MX_END_VISIT_DECL(RedeclarableTemplateDecl) MX_BEGIN_VISIT_DECL(FunctionTemplateDecl) MX_ENTER_VISIT_FunctionTemplateDecl MX_VISIT_BASE(FunctionTemplateDecl, RedeclarableTemplateDecl) - MX_VISIT_BOOL(FunctionTemplateDecl, is_abbreviated, 69, MX_APPLY_METHOD, IsAbbreviated, bool, NthDecl) - MX_VISIT_BOOL(FunctionTemplateDecl, is_this_declaration_a_definition, 81, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_BOOL(FunctionTemplateDecl, is_abbreviated, 70, MX_APPLY_METHOD, IsAbbreviated, bool, NthDecl) + MX_VISIT_BOOL(FunctionTemplateDecl, is_this_declaration_a_definition, 82, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) MX_EXIT_VISIT_FunctionTemplateDecl MX_END_VISIT_DECL(FunctionTemplateDecl) @@ -19775,7 +19780,7 @@ MX_END_VISIT_DECL(FunctionTemplateDecl) MX_BEGIN_VISIT_DECL(ClassTemplateDecl) MX_ENTER_VISIT_ClassTemplateDecl MX_VISIT_BASE(ClassTemplateDecl, RedeclarableTemplateDecl) - MX_VISIT_BOOL(ClassTemplateDecl, is_this_declaration_a_definition, 69, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_BOOL(ClassTemplateDecl, is_this_declaration_a_definition, 70, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) MX_EXIT_VISIT_ClassTemplateDecl MX_END_VISIT_DECL(ClassTemplateDecl) @@ -19789,7 +19794,7 @@ MX_END_VISIT_DECL(ClassTemplateDecl) MX_BEGIN_VISIT_DECL(VarTemplateDecl) MX_ENTER_VISIT_VarTemplateDecl MX_VISIT_BASE(VarTemplateDecl, RedeclarableTemplateDecl) - MX_VISIT_BOOL(VarTemplateDecl, is_this_declaration_a_definition, 69, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_BOOL(VarTemplateDecl, is_this_declaration_a_definition, 70, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) MX_EXIT_VISIT_VarTemplateDecl MX_END_VISIT_DECL(VarTemplateDecl) @@ -19816,8 +19821,8 @@ MX_END_VISIT_DECL(TypeAliasTemplateDecl) MX_BEGIN_VISIT_DECL(ConceptDecl) MX_ENTER_VISIT_ConceptDecl MX_VISIT_BASE(ConceptDecl, TemplateDecl) - MX_VISIT_ENTITY(ConceptDecl, constraint_expression, 50, MX_APPLY_METHOD, ConstraintExpression, Expr, NthDecl) - MX_VISIT_BOOL(ConceptDecl, is_type_concept, 68, MX_APPLY_METHOD, IsTypeConcept, bool, NthDecl) + MX_VISIT_ENTITY(ConceptDecl, constraint_expression, 51, MX_APPLY_METHOD, ConstraintExpression, Expr, NthDecl) + MX_VISIT_BOOL(ConceptDecl, is_type_concept, 69, MX_APPLY_METHOD, IsTypeConcept, bool, NthDecl) MX_EXIT_VISIT_ConceptDecl MX_END_VISIT_DECL(ConceptDecl) @@ -19844,11 +19849,11 @@ MX_END_VISIT_DECL(BuiltinTemplateDecl) MX_BEGIN_VISIT_DECL(TemplateTemplateParmDecl) MX_ENTER_VISIT_TemplateTemplateParmDecl MX_VISIT_BASE(TemplateTemplateParmDecl, TemplateDecl) - MX_VISIT_BOOL(TemplateTemplateParmDecl, default_argument_was_inherited, 68, MX_APPLY_METHOD, DefaultArgumentWasInherited, bool, NthDecl) - MX_VISIT_ENTITY(TemplateTemplateParmDecl, default_argument_token, 50, MX_APPLY_METHOD, DefaultArgumentToken, Token, NthDecl) - MX_VISIT_BOOL(TemplateTemplateParmDecl, has_default_argument, 69, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) - MX_VISIT_BOOL(TemplateTemplateParmDecl, is_expanded_parameter_pack, 81, MX_APPLY_METHOD, IsExpandedParameterPack, bool, NthDecl) - MX_VISIT_BOOL(TemplateTemplateParmDecl, is_pack_expansion, 82, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) + MX_VISIT_BOOL(TemplateTemplateParmDecl, default_argument_was_inherited, 69, MX_APPLY_METHOD, DefaultArgumentWasInherited, bool, NthDecl) + MX_VISIT_ENTITY(TemplateTemplateParmDecl, default_argument_token, 51, MX_APPLY_METHOD, DefaultArgumentToken, Token, NthDecl) + MX_VISIT_BOOL(TemplateTemplateParmDecl, has_default_argument, 70, MX_APPLY_METHOD, HasDefaultArgument, bool, NthDecl) + MX_VISIT_BOOL(TemplateTemplateParmDecl, is_expanded_parameter_pack, 82, MX_APPLY_METHOD, IsExpandedParameterPack, bool, NthDecl) + MX_VISIT_BOOL(TemplateTemplateParmDecl, is_pack_expansion, 83, MX_APPLY_METHOD, IsPackExpansion, bool, NthDecl) MX_EXIT_VISIT_TemplateTemplateParmDecl MX_END_VISIT_DECL(TemplateTemplateParmDecl) @@ -19862,24 +19867,24 @@ MX_END_VISIT_DECL(TemplateTemplateParmDecl) MX_BEGIN_VISIT_DECL(ObjCPropertyDecl) MX_ENTER_VISIT_ObjCPropertyDecl MX_VISIT_BASE(ObjCPropertyDecl, NamedDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, at_token, 48, MX_APPLY_METHOD, AtToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, getter_method_declaration, 49, MX_APPLY_METHOD, GetterMethodDeclaration, ObjCMethodDecl, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, getter_name_token, 50, MX_APPLY_METHOD, GetterNameToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, l_paren_token, 58, MX_APPLY_METHOD, LParenToken, Token, NthDecl) - MX_VISIT_ENUM(ObjCPropertyDecl, property_implementation, 72, MX_APPLY_METHOD, PropertyImplementation, ObjCPropertyDeclPropertyControl, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, property_instance_variable_declaration, 59, MX_APPLY_METHOD, PropertyInstanceVariableDeclaration, ObjCIvarDecl, NthDecl) - MX_VISIT_ENUM(ObjCPropertyDecl, query_kind, 76, MX_APPLY_METHOD, QueryKind, ObjCPropertyQueryKind, NthDecl) - MX_VISIT_ENUM(ObjCPropertyDecl, setter_kind, 77, MX_APPLY_METHOD, SetterKind, ObjCPropertyDeclSetterKind, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, setter_method_declaration, 60, MX_APPLY_METHOD, SetterMethodDeclaration, ObjCMethodDecl, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, setter_name_token, 70, MX_APPLY_METHOD, SetterNameToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCPropertyDecl, type, 71, MX_APPLY_METHOD, Type, Type, NthDecl) - MX_VISIT_BOOL(ObjCPropertyDecl, is_atomic, 66, MX_APPLY_METHOD, IsAtomic, bool, NthDecl) - MX_VISIT_BOOL(ObjCPropertyDecl, is_class_property, 67, MX_APPLY_METHOD, IsClassProperty, bool, NthDecl) - MX_VISIT_BOOL(ObjCPropertyDecl, is_direct_property, 68, MX_APPLY_METHOD, IsDirectProperty, bool, NthDecl) - MX_VISIT_BOOL(ObjCPropertyDecl, is_instance_property, 69, MX_APPLY_METHOD, IsInstanceProperty, bool, NthDecl) - MX_VISIT_BOOL(ObjCPropertyDecl, is_optional, 81, MX_APPLY_METHOD, IsOptional, bool, NthDecl) - MX_VISIT_BOOL(ObjCPropertyDecl, is_read_only, 82, MX_APPLY_METHOD, IsReadOnly, bool, NthDecl) - MX_VISIT_BOOL(ObjCPropertyDecl, is_retaining, 83, MX_APPLY_METHOD, IsRetaining, bool, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, at_token, 49, MX_APPLY_METHOD, AtToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, getter_method_declaration, 50, MX_APPLY_METHOD, GetterMethodDeclaration, ObjCMethodDecl, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, getter_name_token, 51, MX_APPLY_METHOD, GetterNameToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, l_paren_token, 59, MX_APPLY_METHOD, LParenToken, Token, NthDecl) + MX_VISIT_ENUM(ObjCPropertyDecl, property_implementation, 73, MX_APPLY_METHOD, PropertyImplementation, ObjCPropertyDeclPropertyControl, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, property_instance_variable_declaration, 60, MX_APPLY_METHOD, PropertyInstanceVariableDeclaration, ObjCIvarDecl, NthDecl) + MX_VISIT_ENUM(ObjCPropertyDecl, query_kind, 77, MX_APPLY_METHOD, QueryKind, ObjCPropertyQueryKind, NthDecl) + MX_VISIT_ENUM(ObjCPropertyDecl, setter_kind, 78, MX_APPLY_METHOD, SetterKind, ObjCPropertyDeclSetterKind, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, setter_method_declaration, 61, MX_APPLY_METHOD, SetterMethodDeclaration, ObjCMethodDecl, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, setter_name_token, 71, MX_APPLY_METHOD, SetterNameToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCPropertyDecl, type, 72, MX_APPLY_METHOD, Type, Type, NthDecl) + MX_VISIT_BOOL(ObjCPropertyDecl, is_atomic, 67, MX_APPLY_METHOD, IsAtomic, bool, NthDecl) + MX_VISIT_BOOL(ObjCPropertyDecl, is_class_property, 68, MX_APPLY_METHOD, IsClassProperty, bool, NthDecl) + MX_VISIT_BOOL(ObjCPropertyDecl, is_direct_property, 69, MX_APPLY_METHOD, IsDirectProperty, bool, NthDecl) + MX_VISIT_BOOL(ObjCPropertyDecl, is_instance_property, 70, MX_APPLY_METHOD, IsInstanceProperty, bool, NthDecl) + MX_VISIT_BOOL(ObjCPropertyDecl, is_optional, 82, MX_APPLY_METHOD, IsOptional, bool, NthDecl) + MX_VISIT_BOOL(ObjCPropertyDecl, is_read_only, 83, MX_APPLY_METHOD, IsReadOnly, bool, NthDecl) + MX_VISIT_BOOL(ObjCPropertyDecl, is_retaining, 84, MX_APPLY_METHOD, IsRetaining, bool, NthDecl) MX_EXIT_VISIT_ObjCPropertyDecl MX_END_VISIT_DECL(ObjCPropertyDecl) @@ -19893,38 +19898,38 @@ MX_END_VISIT_DECL(ObjCPropertyDecl) MX_BEGIN_VISIT_DECL(ObjCMethodDecl) MX_ENTER_VISIT_ObjCMethodDecl MX_VISIT_BASE(ObjCMethodDecl, NamedDecl) - MX_VISIT_BOOL(ObjCMethodDecl, defined_in_ns_object, 66, MX_APPLY_METHOD, DefinedInNSObject, bool, NthDecl) - MX_VISIT_ENTITY(ObjCMethodDecl, find_property_declaration, 48, MX_APPLY_METHOD, FindPropertyDeclaration, ObjCPropertyDecl, NthDecl) - MX_VISIT_ENTITY(ObjCMethodDecl, class_interface, 49, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) - MX_VISIT_ENTITY(ObjCMethodDecl, command_declaration, 50, MX_APPLY_METHOD, CommandDeclaration, ImplicitParamDecl, NthDecl) - MX_VISIT_ENTITY(ObjCMethodDecl, declarator_end_token, 58, MX_APPLY_METHOD, DeclaratorEndToken, Token, NthDecl) - MX_VISIT_ENUM(ObjCMethodDecl, implementation_control, 72, MX_APPLY_METHOD, ImplementationControl, ObjCImplementationControl, NthDecl) - MX_VISIT_ENUM(ObjCMethodDecl, method_family, 76, MX_APPLY_METHOD, MethodFamily, ObjCMethodFamily, NthDecl) - MX_VISIT_ENUM(ObjCMethodDecl, obj_c_decl_qualifier, 77, MX_APPLY_METHOD, ObjCDeclQualifier, DeclObjCDeclQualifier, NthDecl) - MX_VISIT_ENTITY(ObjCMethodDecl, return_type, 59, MX_APPLY_METHOD, ReturnType, Type, NthDecl) - MX_VISIT_TOKEN_RANGE(ObjCMethodDecl, return_type_tokens, 60, 70, NthDecl) - MX_VISIT_ENTITY(ObjCMethodDecl, selector_start_token, 71, MX_APPLY_METHOD, SelectorStartToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCMethodDecl, self_declaration, 73, MX_APPLY_METHOD, SelfDeclaration, ImplicitParamDecl, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, has_parameter_destroyed_in_callee, 67, MX_APPLY_METHOD, HasParameterDestroyedInCallee, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, has_redeclaration, 68, MX_APPLY_METHOD, HasRedeclaration, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, has_related_result_type, 69, MX_APPLY_METHOD, HasRelatedResultType, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, has_skipped_body, 81, MX_APPLY_METHOD, HasSkippedBody, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_class_method, 82, MX_APPLY_METHOD, IsClassMethod, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_defined, 83, MX_APPLY_METHOD, IsDefined, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_designated_initializer_for_the_interface, 84, MX_APPLY_METHOD, IsDesignatedInitializerForTheInterface, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_direct_method, 85, MX_APPLY_METHOD, IsDirectMethod, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_instance_method, 86, MX_APPLY_METHOD, IsInstanceMethod, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_optional, 87, MX_APPLY_METHOD, IsOptional, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_overriding, 88, MX_APPLY_METHOD, IsOverriding, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_property_accessor, 89, MX_APPLY_METHOD, IsPropertyAccessor, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_redeclaration, 90, MX_APPLY_METHOD, IsRedeclaration, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_synthesized_accessor_stub, 91, MX_APPLY_METHOD, IsSynthesizedAccessorStub, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_this_declaration_a_definition, 92, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_this_declaration_a_designated_initializer, 93, MX_APPLY_METHOD, IsThisDeclarationADesignatedInitializer, bool, NthDecl) - MX_VISIT_BOOL(ObjCMethodDecl, is_variadic, 94, MX_APPLY_METHOD, IsVariadic, bool, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCMethodDecl, parameters, 43, MX_APPLY_METHOD, Parameters, ParmVarDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCMethodDecl, selector_tokens, 44, MX_APPLY_METHOD, SelectorTokens, Token, NthDecl) - MX_VISIT_DECL_CONTEXT(ObjCMethodDecl, contained_declarations, 54, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, defined_in_ns_object, 67, MX_APPLY_METHOD, DefinedInNSObject, bool, NthDecl) + MX_VISIT_ENTITY(ObjCMethodDecl, find_property_declaration, 49, MX_APPLY_METHOD, FindPropertyDeclaration, ObjCPropertyDecl, NthDecl) + MX_VISIT_ENTITY(ObjCMethodDecl, class_interface, 50, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) + MX_VISIT_ENTITY(ObjCMethodDecl, command_declaration, 51, MX_APPLY_METHOD, CommandDeclaration, ImplicitParamDecl, NthDecl) + MX_VISIT_ENTITY(ObjCMethodDecl, declarator_end_token, 59, MX_APPLY_METHOD, DeclaratorEndToken, Token, NthDecl) + MX_VISIT_ENUM(ObjCMethodDecl, implementation_control, 73, MX_APPLY_METHOD, ImplementationControl, ObjCImplementationControl, NthDecl) + MX_VISIT_ENUM(ObjCMethodDecl, method_family, 77, MX_APPLY_METHOD, MethodFamily, ObjCMethodFamily, NthDecl) + MX_VISIT_ENUM(ObjCMethodDecl, obj_c_decl_qualifier, 78, MX_APPLY_METHOD, ObjCDeclQualifier, DeclObjCDeclQualifier, NthDecl) + MX_VISIT_ENTITY(ObjCMethodDecl, return_type, 60, MX_APPLY_METHOD, ReturnType, Type, NthDecl) + MX_VISIT_TOKEN_RANGE(ObjCMethodDecl, return_type_tokens, 61, 71, NthDecl) + MX_VISIT_ENTITY(ObjCMethodDecl, selector_start_token, 72, MX_APPLY_METHOD, SelectorStartToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCMethodDecl, self_declaration, 74, MX_APPLY_METHOD, SelfDeclaration, ImplicitParamDecl, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, has_parameter_destroyed_in_callee, 68, MX_APPLY_METHOD, HasParameterDestroyedInCallee, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, has_redeclaration, 69, MX_APPLY_METHOD, HasRedeclaration, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, has_related_result_type, 70, MX_APPLY_METHOD, HasRelatedResultType, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, has_skipped_body, 82, MX_APPLY_METHOD, HasSkippedBody, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_class_method, 83, MX_APPLY_METHOD, IsClassMethod, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_defined, 84, MX_APPLY_METHOD, IsDefined, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_designated_initializer_for_the_interface, 85, MX_APPLY_METHOD, IsDesignatedInitializerForTheInterface, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_direct_method, 86, MX_APPLY_METHOD, IsDirectMethod, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_instance_method, 87, MX_APPLY_METHOD, IsInstanceMethod, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_optional, 88, MX_APPLY_METHOD, IsOptional, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_overriding, 89, MX_APPLY_METHOD, IsOverriding, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_property_accessor, 90, MX_APPLY_METHOD, IsPropertyAccessor, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_redeclaration, 91, MX_APPLY_METHOD, IsRedeclaration, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_synthesized_accessor_stub, 92, MX_APPLY_METHOD, IsSynthesizedAccessorStub, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_this_declaration_a_definition, 93, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_this_declaration_a_designated_initializer, 94, MX_APPLY_METHOD, IsThisDeclarationADesignatedInitializer, bool, NthDecl) + MX_VISIT_BOOL(ObjCMethodDecl, is_variadic, 95, MX_APPLY_METHOD, IsVariadic, bool, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCMethodDecl, parameters, 44, MX_APPLY_METHOD, Parameters, ParmVarDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCMethodDecl, selector_tokens, 45, MX_APPLY_METHOD, SelectorTokens, Token, NthDecl) + MX_VISIT_DECL_CONTEXT(ObjCMethodDecl, contained_declarations, 55, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_ObjCMethodDecl MX_END_VISIT_DECL(ObjCMethodDecl) @@ -19938,15 +19943,15 @@ MX_END_VISIT_DECL(ObjCMethodDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(ObjCContainerDecl) MX_ENTER_VISIT_ObjCContainerDecl MX_VISIT_BASE(ObjCContainerDecl, NamedDecl) - MX_VISIT_ENTITY_LIST(ObjCContainerDecl, class_methods, 43, MX_APPLY_METHOD, ClassMethods, ObjCMethodDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCContainerDecl, class_properties, 44, MX_APPLY_METHOD, ClassProperties, ObjCPropertyDecl, NthDecl) - MX_VISIT_TOKEN_RANGE(ObjCContainerDecl, at_end_range, 48, 49, NthDecl) - MX_VISIT_ENTITY(ObjCContainerDecl, at_start_token, 50, MX_APPLY_METHOD, AtStartToken, Token, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCContainerDecl, instance_methods, 54, MX_APPLY_METHOD, InstanceMethods, ObjCMethodDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCContainerDecl, instance_properties, 153, MX_APPLY_METHOD, InstanceProperties, ObjCPropertyDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCContainerDecl, methods, 168, MX_APPLY_METHOD, Methods, ObjCMethodDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCContainerDecl, properties, 174, MX_APPLY_METHOD, Properties, ObjCPropertyDecl, NthDecl) - MX_VISIT_DECL_CONTEXT(ObjCContainerDecl, contained_declarations, 178, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCContainerDecl, class_methods, 44, MX_APPLY_METHOD, ClassMethods, ObjCMethodDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCContainerDecl, class_properties, 45, MX_APPLY_METHOD, ClassProperties, ObjCPropertyDecl, NthDecl) + MX_VISIT_TOKEN_RANGE(ObjCContainerDecl, at_end_range, 49, 50, NthDecl) + MX_VISIT_ENTITY(ObjCContainerDecl, at_start_token, 51, MX_APPLY_METHOD, AtStartToken, Token, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCContainerDecl, instance_methods, 55, MX_APPLY_METHOD, InstanceMethods, ObjCMethodDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCContainerDecl, instance_properties, 154, MX_APPLY_METHOD, InstanceProperties, ObjCPropertyDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCContainerDecl, methods, 169, MX_APPLY_METHOD, Methods, ObjCMethodDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCContainerDecl, properties, 175, MX_APPLY_METHOD, Properties, ObjCPropertyDecl, NthDecl) + MX_VISIT_DECL_CONTEXT(ObjCContainerDecl, contained_declarations, 179, MX_APPLY_FUNC, DeclarationsInDeclContext, Decl, NthDecl) MX_EXIT_VISIT_ObjCContainerDecl MX_END_VISIT_DECL(ObjCContainerDecl) @@ -19960,16 +19965,16 @@ MX_END_VISIT_DECL(ObjCContainerDecl) MX_BEGIN_VISIT_DECL(ObjCCategoryDecl) MX_ENTER_VISIT_ObjCCategoryDecl MX_VISIT_BASE(ObjCCategoryDecl, ObjCContainerDecl) - MX_VISIT_BOOL(ObjCCategoryDecl, is_class_extension, 66, MX_APPLY_METHOD, IsClassExtension, bool, NthDecl) - MX_VISIT_ENTITY(ObjCCategoryDecl, category_name_token, 58, MX_APPLY_METHOD, CategoryNameToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCCategoryDecl, class_interface, 59, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) - MX_VISIT_ENTITY(ObjCCategoryDecl, implementation, 60, MX_APPLY_METHOD, Implementation, ObjCCategoryImplDecl, NthDecl) - MX_VISIT_ENTITY(ObjCCategoryDecl, instance_variable_l_brace_token, 70, MX_APPLY_METHOD, InstanceVariableLBraceToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCCategoryDecl, instance_variable_r_brace_token, 71, MX_APPLY_METHOD, InstanceVariableRBraceToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCCategoryDecl, next_class_category, 73, MX_APPLY_METHOD, NextClassCategory, ObjCCategoryDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCCategoryDecl, instance_variables, 329, MX_APPLY_METHOD, InstanceVariables, ObjCIvarDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCCategoryDecl, protocol_tokens, 340, MX_APPLY_METHOD, ProtocolTokens, Token, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCCategoryDecl, protocols, 347, MX_APPLY_METHOD, Protocols, ObjCProtocolDecl, NthDecl) + MX_VISIT_BOOL(ObjCCategoryDecl, is_class_extension, 67, MX_APPLY_METHOD, IsClassExtension, bool, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryDecl, category_name_token, 59, MX_APPLY_METHOD, CategoryNameToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryDecl, class_interface, 60, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryDecl, implementation, 61, MX_APPLY_METHOD, Implementation, ObjCCategoryImplDecl, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryDecl, instance_variable_l_brace_token, 71, MX_APPLY_METHOD, InstanceVariableLBraceToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryDecl, instance_variable_r_brace_token, 72, MX_APPLY_METHOD, InstanceVariableRBraceToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryDecl, next_class_category, 74, MX_APPLY_METHOD, NextClassCategory, ObjCCategoryDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCCategoryDecl, instance_variables, 330, MX_APPLY_METHOD, InstanceVariables, ObjCIvarDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCCategoryDecl, protocol_tokens, 341, MX_APPLY_METHOD, ProtocolTokens, Token, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCCategoryDecl, protocols, 348, MX_APPLY_METHOD, Protocols, ObjCProtocolDecl, NthDecl) MX_EXIT_VISIT_ObjCCategoryDecl MX_END_VISIT_DECL(ObjCCategoryDecl) @@ -19983,12 +19988,12 @@ MX_END_VISIT_DECL(ObjCCategoryDecl) MX_BEGIN_VISIT_DECL(ObjCProtocolDecl) MX_ENTER_VISIT_ObjCProtocolDecl MX_VISIT_BASE(ObjCProtocolDecl, ObjCContainerDecl) - MX_VISIT_TEXT(ObjCProtocolDecl, obj_c_runtime_name_as_string, 56, MX_APPLY_METHOD, ObjCRuntimeNameAsString, basic_string_view, NthDecl) - MX_VISIT_BOOL(ObjCProtocolDecl, has_definition, 66, MX_APPLY_METHOD, HasDefinition, bool, NthDecl) - MX_VISIT_BOOL(ObjCProtocolDecl, is_non_runtime_protocol, 67, MX_APPLY_METHOD, IsNonRuntimeProtocol, bool, NthDecl) - MX_VISIT_BOOL(ObjCProtocolDecl, is_this_declaration_a_definition, 68, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCProtocolDecl, protocol_tokens, 329, MX_APPLY_METHOD, ProtocolTokens, Token, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCProtocolDecl, protocols, 340, MX_APPLY_METHOD, Protocols, ObjCProtocolDecl, NthDecl) + MX_VISIT_TEXT(ObjCProtocolDecl, obj_c_runtime_name_as_string, 57, MX_APPLY_METHOD, ObjCRuntimeNameAsString, basic_string_view, NthDecl) + MX_VISIT_BOOL(ObjCProtocolDecl, has_definition, 67, MX_APPLY_METHOD, HasDefinition, bool, NthDecl) + MX_VISIT_BOOL(ObjCProtocolDecl, is_non_runtime_protocol, 68, MX_APPLY_METHOD, IsNonRuntimeProtocol, bool, NthDecl) + MX_VISIT_BOOL(ObjCProtocolDecl, is_this_declaration_a_definition, 69, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCProtocolDecl, protocol_tokens, 330, MX_APPLY_METHOD, ProtocolTokens, Token, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCProtocolDecl, protocols, 341, MX_APPLY_METHOD, Protocols, ObjCProtocolDecl, NthDecl) MX_EXIT_VISIT_ObjCProtocolDecl MX_END_VISIT_DECL(ObjCProtocolDecl) @@ -20002,28 +20007,28 @@ MX_END_VISIT_DECL(ObjCProtocolDecl) MX_BEGIN_VISIT_DECL(ObjCInterfaceDecl) MX_ENTER_VISIT_ObjCInterfaceDecl MX_VISIT_BASE(ObjCInterfaceDecl, ObjCContainerDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, all_referenced_protocols, 329, MX_APPLY_METHOD, AllReferencedProtocols, ObjCProtocolDecl, NthDecl) - MX_VISIT_BOOL(ObjCInterfaceDecl, declares_or_inherits_designated_initializers, 66, MX_APPLY_METHOD, DeclaresOrInheritsDesignatedInitializers, bool, NthDecl) - MX_VISIT_ENTITY(ObjCInterfaceDecl, end_of_definition_token, 58, MX_APPLY_METHOD, EndOfDefinitionToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCInterfaceDecl, implementation, 59, MX_APPLY_METHOD, Implementation, ObjCImplementationDecl, NthDecl) - MX_VISIT_TEXT(ObjCInterfaceDecl, obj_c_runtime_name_as_string, 56, MX_APPLY_METHOD, ObjCRuntimeNameAsString, basic_string_view, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(ObjCInterfaceDecl, super_class, 60, MX_APPLY_METHOD, SuperClass, ObjCInterfaceDecl, NthDecl) - MX_VISIT_ENTITY(ObjCInterfaceDecl, super_class_token, 70, MX_APPLY_METHOD, SuperClassToken, Token, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(ObjCInterfaceDecl, super_class_type, 71, MX_APPLY_METHOD, SuperClassTypeInfo, Type, NthDecl) - MX_VISIT_ENTITY(ObjCInterfaceDecl, type_for_declaration, 73, MX_APPLY_METHOD, TypeForDeclaration, Type, NthDecl) - MX_VISIT_BOOL(ObjCInterfaceDecl, has_definition, 67, MX_APPLY_METHOD, HasDefinition, bool, NthDecl) - MX_VISIT_BOOL(ObjCInterfaceDecl, has_designated_initializers, 68, MX_APPLY_METHOD, HasDesignatedInitializers, bool, NthDecl) - MX_VISIT_BOOL(ObjCInterfaceDecl, is_arc_weakref_unavailable, 69, MX_APPLY_METHOD, IsArcWeakrefUnavailable, bool, NthDecl) - MX_VISIT_BOOL(ObjCInterfaceDecl, is_implicit_interface_declaration, 81, MX_APPLY_METHOD, IsImplicitInterfaceDeclaration, bool, NthDecl) - MX_VISIT_ENTITY(ObjCInterfaceDecl, is_obj_c_requires_property_definitions, 74, MX_APPLY_METHOD, IsObjCRequiresPropertyDefinitions, ObjCInterfaceDecl, NthDecl) - MX_VISIT_BOOL(ObjCInterfaceDecl, is_this_declaration_a_definition, 82, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, instance_variables, 340, MX_APPLY_METHOD, InstanceVariables, ObjCIvarDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, known_categories, 347, MX_APPLY_METHOD, KnownCategories, ObjCCategoryDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, known_extensions, 348, MX_APPLY_METHOD, KnownExtensions, ObjCCategoryDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, protocol_tokens, 349, MX_APPLY_METHOD, ProtocolTokens, Token, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, protocols, 350, MX_APPLY_METHOD, Protocols, ObjCProtocolDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, visible_categories, 351, MX_APPLY_METHOD, VisibleCategories, ObjCCategoryDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, visible_extensions, 352, MX_APPLY_METHOD, VisibleExtensions, ObjCCategoryDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, all_referenced_protocols, 330, MX_APPLY_METHOD, AllReferencedProtocols, ObjCProtocolDecl, NthDecl) + MX_VISIT_BOOL(ObjCInterfaceDecl, declares_or_inherits_designated_initializers, 67, MX_APPLY_METHOD, DeclaresOrInheritsDesignatedInitializers, bool, NthDecl) + MX_VISIT_ENTITY(ObjCInterfaceDecl, end_of_definition_token, 59, MX_APPLY_METHOD, EndOfDefinitionToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCInterfaceDecl, implementation, 60, MX_APPLY_METHOD, Implementation, ObjCImplementationDecl, NthDecl) + MX_VISIT_TEXT(ObjCInterfaceDecl, obj_c_runtime_name_as_string, 57, MX_APPLY_METHOD, ObjCRuntimeNameAsString, basic_string_view, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(ObjCInterfaceDecl, super_class, 61, MX_APPLY_METHOD, SuperClass, ObjCInterfaceDecl, NthDecl) + MX_VISIT_ENTITY(ObjCInterfaceDecl, super_class_token, 71, MX_APPLY_METHOD, SuperClassToken, Token, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(ObjCInterfaceDecl, super_class_type, 72, MX_APPLY_METHOD, SuperClassTypeInfo, Type, NthDecl) + MX_VISIT_ENTITY(ObjCInterfaceDecl, type_for_declaration, 74, MX_APPLY_METHOD, TypeForDeclaration, Type, NthDecl) + MX_VISIT_BOOL(ObjCInterfaceDecl, has_definition, 68, MX_APPLY_METHOD, HasDefinition, bool, NthDecl) + MX_VISIT_BOOL(ObjCInterfaceDecl, has_designated_initializers, 69, MX_APPLY_METHOD, HasDesignatedInitializers, bool, NthDecl) + MX_VISIT_BOOL(ObjCInterfaceDecl, is_arc_weakref_unavailable, 70, MX_APPLY_METHOD, IsArcWeakrefUnavailable, bool, NthDecl) + MX_VISIT_BOOL(ObjCInterfaceDecl, is_implicit_interface_declaration, 82, MX_APPLY_METHOD, IsImplicitInterfaceDeclaration, bool, NthDecl) + MX_VISIT_ENTITY(ObjCInterfaceDecl, is_obj_c_requires_property_definitions, 75, MX_APPLY_METHOD, IsObjCRequiresPropertyDefinitions, ObjCInterfaceDecl, NthDecl) + MX_VISIT_BOOL(ObjCInterfaceDecl, is_this_declaration_a_definition, 83, MX_APPLY_METHOD, IsThisDeclarationADefinition, bool, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, instance_variables, 341, MX_APPLY_METHOD, InstanceVariables, ObjCIvarDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, known_categories, 348, MX_APPLY_METHOD, KnownCategories, ObjCCategoryDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, known_extensions, 349, MX_APPLY_METHOD, KnownExtensions, ObjCCategoryDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, protocol_tokens, 350, MX_APPLY_METHOD, ProtocolTokens, Token, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, protocols, 351, MX_APPLY_METHOD, Protocols, ObjCProtocolDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, visible_categories, 352, MX_APPLY_METHOD, VisibleCategories, ObjCCategoryDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCInterfaceDecl, visible_extensions, 353, MX_APPLY_METHOD, VisibleExtensions, ObjCCategoryDecl, NthDecl) MX_EXIT_VISIT_ObjCInterfaceDecl MX_END_VISIT_DECL(ObjCInterfaceDecl) @@ -20037,8 +20042,8 @@ MX_END_VISIT_DECL(ObjCInterfaceDecl) MX_BEGIN_VISIT_ABSTRACT_DECL(ObjCImplDecl) MX_ENTER_VISIT_ObjCImplDecl MX_VISIT_BASE(ObjCImplDecl, ObjCContainerDecl) - MX_VISIT_ENTITY(ObjCImplDecl, class_interface, 58, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCImplDecl, property_implementations, 329, MX_APPLY_METHOD, PropertyImplementations, ObjCPropertyImplDecl, NthDecl) + MX_VISIT_ENTITY(ObjCImplDecl, class_interface, 59, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCImplDecl, property_implementations, 330, MX_APPLY_METHOD, PropertyImplementations, ObjCPropertyImplDecl, NthDecl) MX_EXIT_VISIT_ObjCImplDecl MX_END_VISIT_DECL(ObjCImplDecl) @@ -20052,8 +20057,8 @@ MX_END_VISIT_DECL(ObjCImplDecl) MX_BEGIN_VISIT_DECL(ObjCCategoryImplDecl) MX_ENTER_VISIT_ObjCCategoryImplDecl MX_VISIT_BASE(ObjCCategoryImplDecl, ObjCImplDecl) - MX_VISIT_ENTITY(ObjCCategoryImplDecl, category_declaration, 59, MX_APPLY_METHOD, CategoryDeclaration, ObjCCategoryDecl, NthDecl) - MX_VISIT_ENTITY(ObjCCategoryImplDecl, category_name_token, 60, MX_APPLY_METHOD, CategoryNameToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryImplDecl, category_declaration, 60, MX_APPLY_METHOD, CategoryDeclaration, ObjCCategoryDecl, NthDecl) + MX_VISIT_ENTITY(ObjCCategoryImplDecl, category_name_token, 61, MX_APPLY_METHOD, CategoryNameToken, Token, NthDecl) MX_EXIT_VISIT_ObjCCategoryImplDecl MX_END_VISIT_DECL(ObjCCategoryImplDecl) @@ -20067,15 +20072,15 @@ MX_END_VISIT_DECL(ObjCCategoryImplDecl) MX_BEGIN_VISIT_DECL(ObjCImplementationDecl) MX_ENTER_VISIT_ObjCImplementationDecl MX_VISIT_BASE(ObjCImplementationDecl, ObjCImplDecl) - MX_VISIT_ENTITY(ObjCImplementationDecl, instance_variable_l_brace_token, 59, MX_APPLY_METHOD, InstanceVariableLBraceToken, Token, NthDecl) - MX_VISIT_ENTITY(ObjCImplementationDecl, instance_variable_r_brace_token, 60, MX_APPLY_METHOD, InstanceVariableRBraceToken, Token, NthDecl) - MX_VISIT_TEXT(ObjCImplementationDecl, obj_c_runtime_name_as_string, 56, MX_APPLY_METHOD, ObjCRuntimeNameAsString, basic_string_view, NthDecl) - MX_VISIT_ENTITY(ObjCImplementationDecl, super_class, 70, MX_APPLY_METHOD, SuperClass, ObjCInterfaceDecl, NthDecl) - MX_VISIT_ENTITY(ObjCImplementationDecl, super_class_token, 71, MX_APPLY_METHOD, SuperClassToken, Token, NthDecl) - MX_VISIT_BOOL(ObjCImplementationDecl, has_destructors, 66, MX_APPLY_METHOD, HasDestructors, bool, NthDecl) - MX_VISIT_BOOL(ObjCImplementationDecl, has_non_zero_constructors, 67, MX_APPLY_METHOD, HasNonZeroConstructors, bool, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCImplementationDecl, initializers, 340, MX_APPLY_METHOD, Initializers, CXXCtorInitializer, NthDecl) - MX_VISIT_ENTITY_LIST(ObjCImplementationDecl, instance_variables, 347, MX_APPLY_METHOD, InstanceVariables, ObjCIvarDecl, NthDecl) + MX_VISIT_ENTITY(ObjCImplementationDecl, instance_variable_l_brace_token, 60, MX_APPLY_METHOD, InstanceVariableLBraceToken, Token, NthDecl) + MX_VISIT_ENTITY(ObjCImplementationDecl, instance_variable_r_brace_token, 61, MX_APPLY_METHOD, InstanceVariableRBraceToken, Token, NthDecl) + MX_VISIT_TEXT(ObjCImplementationDecl, obj_c_runtime_name_as_string, 57, MX_APPLY_METHOD, ObjCRuntimeNameAsString, basic_string_view, NthDecl) + MX_VISIT_ENTITY(ObjCImplementationDecl, super_class, 71, MX_APPLY_METHOD, SuperClass, ObjCInterfaceDecl, NthDecl) + MX_VISIT_ENTITY(ObjCImplementationDecl, super_class_token, 72, MX_APPLY_METHOD, SuperClassToken, Token, NthDecl) + MX_VISIT_BOOL(ObjCImplementationDecl, has_destructors, 67, MX_APPLY_METHOD, HasDestructors, bool, NthDecl) + MX_VISIT_BOOL(ObjCImplementationDecl, has_non_zero_constructors, 68, MX_APPLY_METHOD, HasNonZeroConstructors, bool, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCImplementationDecl, initializers, 341, MX_APPLY_METHOD, Initializers, CXXCtorInitializer, NthDecl) + MX_VISIT_ENTITY_LIST(ObjCImplementationDecl, instance_variables, 348, MX_APPLY_METHOD, InstanceVariables, ObjCIvarDecl, NthDecl) MX_EXIT_VISIT_ObjCImplementationDecl MX_END_VISIT_DECL(ObjCImplementationDecl) @@ -20089,7 +20094,7 @@ MX_END_VISIT_DECL(ObjCImplementationDecl) MX_BEGIN_VISIT_DECL(ObjCCompatibleAliasDecl) MX_ENTER_VISIT_ObjCCompatibleAliasDecl MX_VISIT_BASE(ObjCCompatibleAliasDecl, NamedDecl) - MX_VISIT_ENTITY(ObjCCompatibleAliasDecl, class_interface, 48, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) + MX_VISIT_ENTITY(ObjCCompatibleAliasDecl, class_interface, 49, MX_APPLY_METHOD, ClassInterface, ObjCInterfaceDecl, NthDecl) MX_EXIT_VISIT_ObjCCompatibleAliasDecl MX_END_VISIT_DECL(ObjCCompatibleAliasDecl) @@ -20103,10 +20108,10 @@ MX_END_VISIT_DECL(ObjCCompatibleAliasDecl) MX_BEGIN_VISIT_DECL(NamespaceDecl) MX_ENTER_VISIT_NamespaceDecl MX_VISIT_BASE(NamespaceDecl, NamedDecl) - MX_VISIT_ENTITY(NamespaceDecl, r_brace_token, 48, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) - MX_VISIT_BOOL(NamespaceDecl, is_anonymous_namespace, 66, MX_APPLY_METHOD, IsAnonymousNamespace, bool, NthDecl) - MX_VISIT_BOOL(NamespaceDecl, is_inline, 67, MX_APPLY_METHOD, IsInline, bool, NthDecl) - MX_VISIT_BOOL(NamespaceDecl, is_nested, 68, MX_APPLY_METHOD, IsNested, bool, NthDecl) + MX_VISIT_ENTITY(NamespaceDecl, r_brace_token, 49, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) + MX_VISIT_BOOL(NamespaceDecl, is_anonymous_namespace, 67, MX_APPLY_METHOD, IsAnonymousNamespace, bool, NthDecl) + MX_VISIT_BOOL(NamespaceDecl, is_inline, 68, MX_APPLY_METHOD, IsInline, bool, NthDecl) + MX_VISIT_BOOL(NamespaceDecl, is_nested, 69, MX_APPLY_METHOD, IsNested, bool, NthDecl) MX_EXIT_VISIT_NamespaceDecl MX_END_VISIT_DECL(NamespaceDecl) @@ -20120,11 +20125,11 @@ MX_END_VISIT_DECL(NamespaceDecl) MX_BEGIN_VISIT_DECL(NamespaceAliasDecl) MX_ENTER_VISIT_NamespaceAliasDecl MX_VISIT_BASE(NamespaceAliasDecl, NamedDecl) - MX_VISIT_ENTITY(NamespaceAliasDecl, alias_token, 48, MX_APPLY_METHOD, AliasToken, Token, NthDecl) - MX_VISIT_ENTITY(NamespaceAliasDecl, aliased_namespace, 49, MX_APPLY_METHOD, AliasedNamespace, NamedDecl, NthDecl) - MX_VISIT_ENTITY(NamespaceAliasDecl, namespace_, 50, MX_APPLY_METHOD, Namespace, NamespaceDecl, NthDecl) - MX_VISIT_ENTITY(NamespaceAliasDecl, namespace_token, 58, MX_APPLY_METHOD, NamespaceToken, Token, NthDecl) - MX_VISIT_ENTITY(NamespaceAliasDecl, target_name_token, 59, MX_APPLY_METHOD, TargetNameToken, Token, NthDecl) + MX_VISIT_ENTITY(NamespaceAliasDecl, alias_token, 49, MX_APPLY_METHOD, AliasToken, Token, NthDecl) + MX_VISIT_ENTITY(NamespaceAliasDecl, aliased_namespace, 50, MX_APPLY_METHOD, AliasedNamespace, NamedDecl, NthDecl) + MX_VISIT_ENTITY(NamespaceAliasDecl, namespace_, 51, MX_APPLY_METHOD, Namespace, NamespaceDecl, NthDecl) + MX_VISIT_ENTITY(NamespaceAliasDecl, namespace_token, 59, MX_APPLY_METHOD, NamespaceToken, Token, NthDecl) + MX_VISIT_ENTITY(NamespaceAliasDecl, target_name_token, 60, MX_APPLY_METHOD, TargetNameToken, Token, NthDecl) MX_EXIT_VISIT_NamespaceAliasDecl MX_END_VISIT_DECL(NamespaceAliasDecl) @@ -20138,10 +20143,10 @@ MX_END_VISIT_DECL(NamespaceAliasDecl) MX_BEGIN_VISIT_DECL(LinkageSpecDecl) MX_ENTER_VISIT_LinkageSpecDecl MX_VISIT_BASE(LinkageSpecDecl, Decl) - MX_VISIT_ENTITY(LinkageSpecDecl, extern_token, 40, MX_APPLY_METHOD, ExternToken, Token, NthDecl) - MX_VISIT_ENUM(LinkageSpecDecl, language, 57, MX_APPLY_METHOD, Language, LinkageSpecLanguageIDs, NthDecl) - MX_VISIT_ENTITY(LinkageSpecDecl, r_brace_token, 48, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) - MX_VISIT_BOOL(LinkageSpecDecl, has_braces, 42, MX_APPLY_METHOD, HasBraces, bool, NthDecl) + MX_VISIT_ENTITY(LinkageSpecDecl, extern_token, 41, MX_APPLY_METHOD, ExternToken, Token, NthDecl) + MX_VISIT_ENUM(LinkageSpecDecl, language, 58, MX_APPLY_METHOD, Language, LinkageSpecLanguageIDs, NthDecl) + MX_VISIT_ENTITY(LinkageSpecDecl, r_brace_token, 49, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) + MX_VISIT_BOOL(LinkageSpecDecl, has_braces, 43, MX_APPLY_METHOD, HasBraces, bool, NthDecl) MX_EXIT_VISIT_LinkageSpecDecl MX_END_VISIT_DECL(LinkageSpecDecl) @@ -20155,11 +20160,11 @@ MX_END_VISIT_DECL(LinkageSpecDecl) MX_BEGIN_VISIT_DECL(LifetimeExtendedTemporaryDecl) MX_ENTER_VISIT_LifetimeExtendedTemporaryDecl MX_VISIT_BASE(LifetimeExtendedTemporaryDecl, Decl) - MX_VISIT_ENTITY_LIST(LifetimeExtendedTemporaryDecl, children, 43, MX_APPLY_METHOD, Children, Stmt, NthDecl) - MX_VISIT_ENTITY(LifetimeExtendedTemporaryDecl, extending_declaration, 40, MX_APPLY_METHOD, ExtendingDeclaration, ValueDecl, NthDecl) - MX_VISIT_INT(LifetimeExtendedTemporaryDecl, mangling_number, 41, MX_APPLY_METHOD, ManglingNumber, uint32_t, NthDecl) - MX_VISIT_ENUM(LifetimeExtendedTemporaryDecl, storage_duration, 57, MX_APPLY_METHOD, StorageDuration, StorageDuration, NthDecl) - MX_VISIT_ENTITY(LifetimeExtendedTemporaryDecl, temporary_expression, 48, MX_APPLY_METHOD, TemporaryExpression, Expr, NthDecl) + MX_VISIT_ENTITY_LIST(LifetimeExtendedTemporaryDecl, children, 44, MX_APPLY_METHOD, Children, Stmt, NthDecl) + MX_VISIT_ENTITY(LifetimeExtendedTemporaryDecl, extending_declaration, 41, MX_APPLY_METHOD, ExtendingDeclaration, ValueDecl, NthDecl) + MX_VISIT_INT(LifetimeExtendedTemporaryDecl, mangling_number, 42, MX_APPLY_METHOD, ManglingNumber, uint32_t, NthDecl) + MX_VISIT_ENUM(LifetimeExtendedTemporaryDecl, storage_duration, 58, MX_APPLY_METHOD, StorageDuration, StorageDuration, NthDecl) + MX_VISIT_ENTITY(LifetimeExtendedTemporaryDecl, temporary_expression, 49, MX_APPLY_METHOD, TemporaryExpression, Expr, NthDecl) MX_EXIT_VISIT_LifetimeExtendedTemporaryDecl MX_END_VISIT_DECL(LifetimeExtendedTemporaryDecl) @@ -20173,7 +20178,7 @@ MX_END_VISIT_DECL(LifetimeExtendedTemporaryDecl) MX_BEGIN_VISIT_DECL(ImportDecl) MX_ENTER_VISIT_ImportDecl MX_VISIT_BASE(ImportDecl, Decl) - MX_VISIT_ENTITY_LIST(ImportDecl, identifier_tokens, 43, MX_APPLY_METHOD, IdentifierTokens, Token, NthDecl) + MX_VISIT_ENTITY_LIST(ImportDecl, identifier_tokens, 44, MX_APPLY_METHOD, IdentifierTokens, Token, NthDecl) MX_EXIT_VISIT_ImportDecl MX_END_VISIT_DECL(ImportDecl) @@ -20187,7 +20192,7 @@ MX_END_VISIT_DECL(ImportDecl) MX_BEGIN_VISIT_DECL(ImplicitConceptSpecializationDecl) MX_ENTER_VISIT_ImplicitConceptSpecializationDecl MX_VISIT_BASE(ImplicitConceptSpecializationDecl, Decl) - MX_VISIT_ENTITY_LIST(ImplicitConceptSpecializationDecl, template_arguments, 43, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) + MX_VISIT_ENTITY_LIST(ImplicitConceptSpecializationDecl, template_arguments, 44, MX_APPLY_METHOD, TemplateArguments, TemplateArgument, NthDecl) MX_EXIT_VISIT_ImplicitConceptSpecializationDecl MX_END_VISIT_DECL(ImplicitConceptSpecializationDecl) @@ -20201,10 +20206,10 @@ MX_END_VISIT_DECL(ImplicitConceptSpecializationDecl) MX_BEGIN_VISIT_DECL(FriendTemplateDecl) MX_ENTER_VISIT_FriendTemplateDecl MX_VISIT_BASE(FriendTemplateDecl, Decl) - MX_VISIT_ENTITY(FriendTemplateDecl, friend_declaration, 40, MX_APPLY_METHOD, FriendDeclaration, NamedDecl, NthDecl) - MX_VISIT_ENTITY(FriendTemplateDecl, friend_token, 48, MX_APPLY_METHOD, FriendToken, Token, NthDecl) - MX_VISIT_ENTITY(FriendTemplateDecl, friend_type, 49, MX_APPLY_METHOD, FriendType, Type, NthDecl) - MX_VISIT_ENTITY_LIST(FriendTemplateDecl, template_parameter_lists, 43, MX_APPLY_METHOD, TemplateParameterLists, TemplateParameterList, NthDecl) + MX_VISIT_ENTITY(FriendTemplateDecl, friend_declaration, 41, MX_APPLY_METHOD, FriendDeclaration, NamedDecl, NthDecl) + MX_VISIT_ENTITY(FriendTemplateDecl, friend_token, 49, MX_APPLY_METHOD, FriendToken, Token, NthDecl) + MX_VISIT_ENTITY(FriendTemplateDecl, friend_type, 50, MX_APPLY_METHOD, FriendType, Type, NthDecl) + MX_VISIT_ENTITY_LIST(FriendTemplateDecl, template_parameter_lists, 44, MX_APPLY_METHOD, TemplateParameterLists, TemplateParameterList, NthDecl) MX_EXIT_VISIT_FriendTemplateDecl MX_END_VISIT_DECL(FriendTemplateDecl) @@ -20218,12 +20223,12 @@ MX_END_VISIT_DECL(FriendTemplateDecl) MX_BEGIN_VISIT_DECL(FriendDecl) MX_ENTER_VISIT_FriendDecl MX_VISIT_BASE(FriendDecl, Decl) - MX_VISIT_OPTIONAL_ENTITY(FriendDecl, friend_declaration, 40, MX_APPLY_METHOD, FriendDeclaration, NamedDecl, NthDecl) - MX_VISIT_ENTITY(FriendDecl, friend_token, 48, MX_APPLY_METHOD, FriendToken, Token, NthDecl) - MX_VISIT_OPTIONAL_ENTITY(FriendDecl, friend_type, 49, MX_APPLY_METHOD, FriendType, Type, NthDecl) - MX_VISIT_INT(FriendDecl, friend_type_num_template_parameter_lists, 41, MX_APPLY_METHOD, FriendTypeNumTemplateParameterLists, uint32_t, NthDecl) - MX_VISIT_BOOL(FriendDecl, is_unsupported_friend, 42, MX_APPLY_METHOD, IsUnsupportedFriend, bool, NthDecl) - MX_VISIT_ENTITY_LIST(FriendDecl, friend_type_template_parameter_lists, 43, MX_APPLY_METHOD, FriendTypeTemplateParameterLists, TemplateParameterList, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(FriendDecl, friend_declaration, 41, MX_APPLY_METHOD, FriendDeclaration, NamedDecl, NthDecl) + MX_VISIT_ENTITY(FriendDecl, friend_token, 49, MX_APPLY_METHOD, FriendToken, Token, NthDecl) + MX_VISIT_OPTIONAL_ENTITY(FriendDecl, friend_type, 50, MX_APPLY_METHOD, FriendType, Type, NthDecl) + MX_VISIT_INT(FriendDecl, friend_type_num_template_parameter_lists, 42, MX_APPLY_METHOD, FriendTypeNumTemplateParameterLists, uint32_t, NthDecl) + MX_VISIT_BOOL(FriendDecl, is_unsupported_friend, 43, MX_APPLY_METHOD, IsUnsupportedFriend, bool, NthDecl) + MX_VISIT_ENTITY_LIST(FriendDecl, friend_type_template_parameter_lists, 44, MX_APPLY_METHOD, FriendTypeTemplateParameterLists, TemplateParameterList, NthDecl) MX_EXIT_VISIT_FriendDecl MX_END_VISIT_DECL(FriendDecl) @@ -20237,9 +20242,9 @@ MX_END_VISIT_DECL(FriendDecl) MX_BEGIN_VISIT_DECL(FileScopeAsmDecl) MX_ENTER_VISIT_FileScopeAsmDecl MX_VISIT_BASE(FileScopeAsmDecl, Decl) - MX_VISIT_ENTITY(FileScopeAsmDecl, assembly_token, 40, MX_APPLY_METHOD, AssemblyToken, Token, NthDecl) - MX_VISIT_ENTITY(FileScopeAsmDecl, assembly_string, 48, MX_APPLY_METHOD, AssemblyString, StringLiteral, NthDecl) - MX_VISIT_ENTITY(FileScopeAsmDecl, r_paren_token, 49, MX_APPLY_METHOD, RParenToken, Token, NthDecl) + MX_VISIT_ENTITY(FileScopeAsmDecl, assembly_token, 41, MX_APPLY_METHOD, AssemblyToken, Token, NthDecl) + MX_VISIT_ENTITY(FileScopeAsmDecl, assembly_string, 49, MX_APPLY_METHOD, AssemblyString, StringLiteral, NthDecl) + MX_VISIT_ENTITY(FileScopeAsmDecl, r_paren_token, 50, MX_APPLY_METHOD, RParenToken, Token, NthDecl) MX_EXIT_VISIT_FileScopeAsmDecl MX_END_VISIT_DECL(FileScopeAsmDecl) @@ -20266,9 +20271,9 @@ MX_END_VISIT_DECL(ExternCContextDecl) MX_BEGIN_VISIT_DECL(ExportDecl) MX_ENTER_VISIT_ExportDecl MX_VISIT_BASE(ExportDecl, Decl) - MX_VISIT_ENTITY(ExportDecl, export_token, 40, MX_APPLY_METHOD, ExportToken, Token, NthDecl) - MX_VISIT_ENTITY(ExportDecl, r_brace_token, 48, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) - MX_VISIT_BOOL(ExportDecl, has_braces, 42, MX_APPLY_METHOD, HasBraces, bool, NthDecl) + MX_VISIT_ENTITY(ExportDecl, export_token, 41, MX_APPLY_METHOD, ExportToken, Token, NthDecl) + MX_VISIT_ENTITY(ExportDecl, r_brace_token, 49, MX_APPLY_METHOD, RBraceToken, Token, NthDecl) + MX_VISIT_BOOL(ExportDecl, has_braces, 43, MX_APPLY_METHOD, HasBraces, bool, NthDecl) MX_EXIT_VISIT_ExportDecl MX_END_VISIT_DECL(ExportDecl) diff --git a/lib/AST.capnp b/lib/AST.capnp index 596d427b1..951611f81 100644 --- a/lib/AST.capnp +++ b/lib/AST.capnp @@ -11,77 +11,77 @@ using Cxx = import "/capnp/c++.capnp"; $Cxx.namespace("mx::ast"); struct Decl @0xfb5879761ffaedb6{ - val4 @0 :UInt8; - val7 @1 :UInt8; - val10 @2 :UInt8; - val35 @3 :UInt8; - val36 @4 :UInt8; - val57 @5 :UInt8; - val61 @6 :UInt8; - val62 @7 :UInt8; - val72 @8 :UInt8; - val76 @9 :UInt8; - val77 @10 :UInt8; - val78 @11 :UInt8; - val79 @12 :UInt8; - val80 @13 :UInt8; - val118 @14 :UInt8; - val156 @15 :UInt8; - val3 @16 :List(UInt64); - val43 @17 :List(UInt64); - val44 @18 :List(UInt64); - val54 @19 :List(UInt64); - val153 @20 :List(UInt64); - val168 @21 :List(UInt64); - val174 @22 :List(UInt64); - val178 @23 :List(UInt64); - val329 @24 :List(UInt64); - val340 @25 :List(UInt64); - val347 @26 :List(UInt64); - val348 @27 :List(UInt64); - val349 @28 :List(UInt64); - val350 @29 :List(UInt64); - val351 @30 :List(UInt64); - val352 @31 :List(UInt64); - val55 @32 :Text; - val56 @33 :Text; + val5 @0 :UInt8; + val8 @1 :UInt8; + val11 @2 :UInt8; + val36 @3 :UInt8; + val37 @4 :UInt8; + val58 @5 :UInt8; + val62 @6 :UInt8; + val63 @7 :UInt8; + val73 @8 :UInt8; + val77 @9 :UInt8; + val78 @10 :UInt8; + val79 @11 :UInt8; + val80 @12 :UInt8; + val81 @13 :UInt8; + val119 @14 :UInt8; + val157 @15 :UInt8; + val4 @16 :List(UInt64); + val44 @17 :List(UInt64); + val45 @18 :List(UInt64); + val55 @19 :List(UInt64); + val154 @20 :List(UInt64); + val169 @21 :List(UInt64); + val175 @22 :List(UInt64); + val179 @23 :List(UInt64); + val330 @24 :List(UInt64); + val341 @25 :List(UInt64); + val348 @26 :List(UInt64); + val349 @27 :List(UInt64); + val350 @28 :List(UInt64); + val351 @29 :List(UInt64); + val352 @30 :List(UInt64); + val353 @31 :List(UInt64); + val56 @32 :Text; + val57 @33 :Text; val0 @34 :UInt64; val1 @35 :UInt64; - val5 @36 :UInt64; + val2 @36 :UInt64; val6 @37 :UInt64; - val11 @38 :UInt64; - val37 @39 :UInt64; + val7 @38 :UInt64; + val12 @39 :UInt64; val38 @40 :UInt64; val39 @41 :UInt64; val40 @42 :UInt64; - val48 @43 :UInt64; + val41 @43 :UInt64; val49 @44 :UInt64; val50 @45 :UInt64; - val58 @46 :UInt64; + val51 @46 :UInt64; val59 @47 :UInt64; val60 @48 :UInt64; - val70 @49 :UInt64; + val61 @49 :UInt64; val71 @50 :UInt64; - val73 @51 :UInt64; + val72 @51 :UInt64; val74 @52 :UInt64; val75 @53 :UInt64; - val113 @54 :UInt64; + val76 @54 :UInt64; val114 @55 :UInt64; val115 @56 :UInt64; val116 @57 :UInt64; - val119 @58 :UInt64; + val117 @58 :UInt64; val120 @59 :UInt64; - val152 @60 :UInt64; - val154 @61 :UInt64; + val121 @60 :UInt64; + val153 @61 :UInt64; val155 @62 :UInt64; - val157 @63 :UInt64; - val170 @64 :UInt64; + val156 @63 :UInt64; + val158 @64 :UInt64; val171 @65 :UInt64; - val344 @66 :UInt64; + val172 @66 :UInt64; val345 @67 :UInt64; - val2 @68 :Bool; - val9 @69 :Bool; - val14 @70 :Bool; + val346 @68 :UInt64; + val3 @69 :Bool; + val10 @70 :Bool; val15 @71 :Bool; val16 @72 :Bool; val17 @73 :Bool; @@ -102,21 +102,21 @@ struct Decl @0xfb5879761ffaedb6{ val32 @88 :Bool; val33 @89 :Bool; val34 @90 :Bool; - val42 @91 :Bool; - val45 @92 :Bool; + val35 @91 :Bool; + val43 @92 :Bool; val46 @93 :Bool; val47 @94 :Bool; - val51 @95 :Bool; + val48 @95 :Bool; val52 @96 :Bool; val53 @97 :Bool; - val63 @98 :Bool; + val54 @98 :Bool; val64 @99 :Bool; val65 @100 :Bool; val66 @101 :Bool; val67 @102 :Bool; val68 @103 :Bool; val69 @104 :Bool; - val81 @105 :Bool; + val70 @105 :Bool; val82 @106 :Bool; val83 @107 :Bool; val84 @108 :Bool; @@ -148,7 +148,7 @@ struct Decl @0xfb5879761ffaedb6{ val110 @134 :Bool; val111 @135 :Bool; val112 @136 :Bool; - val121 @137 :Bool; + val113 @137 :Bool; val122 @138 :Bool; val123 @139 :Bool; val124 @140 :Bool; @@ -156,7 +156,7 @@ struct Decl @0xfb5879761ffaedb6{ val126 @142 :Bool; val127 @143 :Bool; val128 @144 :Bool; - val131 @145 :Bool; + val129 @145 :Bool; val132 @146 :Bool; val133 @147 :Bool; val134 @148 :Bool; @@ -177,7 +177,7 @@ struct Decl @0xfb5879761ffaedb6{ val149 @163 :Bool; val150 @164 :Bool; val151 @165 :Bool; - val158 @166 :Bool; + val152 @166 :Bool; val159 @167 :Bool; val160 @168 :Bool; val161 @169 :Bool; @@ -187,12 +187,12 @@ struct Decl @0xfb5879761ffaedb6{ val165 @173 :Bool; val166 @174 :Bool; val167 @175 :Bool; - val172 @176 :Bool; + val168 @176 :Bool; val173 @177 :Bool; - val175 @178 :Bool; + val174 @178 :Bool; val176 @179 :Bool; val177 @180 :Bool; - val179 @181 :Bool; + val178 @181 :Bool; val180 @182 :Bool; val181 @183 :Bool; val182 @184 :Bool; @@ -342,7 +342,7 @@ struct Decl @0xfb5879761ffaedb6{ val326 @328 :Bool; val327 @329 :Bool; val328 @330 :Bool; - val330 @331 :Bool; + val329 @331 :Bool; val331 @332 :Bool; val332 @333 :Bool; val333 @334 :Bool; @@ -352,63 +352,64 @@ struct Decl @0xfb5879761ffaedb6{ val337 @338 :Bool; val338 @339 :Bool; val339 @340 :Bool; - val341 @341 :Bool; + val340 @341 :Bool; val342 @342 :Bool; val343 @343 :Bool; - val346 @344 :Bool; - val8 @345 :UInt32; - val12 @346 :UInt32; + val344 @344 :Bool; + val347 @345 :Bool; + val9 @346 :UInt32; val13 @347 :UInt32; - val41 @348 :UInt32; - val117 @349 :UInt32; - val129 @350 :UInt32; + val14 @348 :UInt32; + val42 @349 :UInt32; + val118 @350 :UInt32; val130 @351 :UInt32; - val169 @352 :UInt32; + val131 @352 :UInt32; + val170 @353 :UInt32; } struct Stmt @0x91127d30fade9a32{ - val62 @0 :List(Text); - val63 @1 :List(Text); - val64 @2 :List(Text); - val65 @3 :List(Text); - val67 @4 :List(Text); - val69 @5 :List(Text); - val4 @6 :List(UInt64); - val15 @7 :List(UInt64); - val27 @8 :List(UInt64); - val28 @9 :List(UInt64); - val29 @10 :List(UInt64); - val30 @11 :List(UInt64); - val53 @12 :List(UInt64); - val54 @13 :List(UInt64); - val55 @14 :List(UInt64); - val68 @15 :List(UInt64); - val7 @16 :UInt8; - val57 @17 :UInt8; - val70 @18 :UInt8; - val89 @19 :UInt8; - val91 @20 :UInt8; - val61 @21 :Text; - val66 @22 :Text; + val63 @0 :List(Text); + val64 @1 :List(Text); + val65 @2 :List(Text); + val66 @3 :List(Text); + val68 @4 :List(Text); + val70 @5 :List(Text); + val5 @6 :List(UInt64); + val16 @7 :List(UInt64); + val28 @8 :List(UInt64); + val29 @9 :List(UInt64); + val30 @10 :List(UInt64); + val31 @11 :List(UInt64); + val54 @12 :List(UInt64); + val55 @13 :List(UInt64); + val56 @14 :List(UInt64); + val69 @15 :List(UInt64); + val8 @16 :UInt8; + val58 @17 :UInt8; + val71 @18 :UInt8; + val90 @19 :UInt8; + val92 @20 :UInt8; + val62 @21 :Text; + val67 @22 :Text; val0 @23 :UInt64; val1 @24 :UInt64; val2 @25 :UInt64; val3 @26 :UInt64; - val5 @27 :UInt64; + val4 @27 :UInt64; val6 @28 :UInt64; - val8 @29 :UInt64; + val7 @29 :UInt64; val9 @30 :UInt64; val10 @31 :UInt64; val11 @32 :UInt64; - val13 @33 :UInt64; + val12 @33 :UInt64; val14 @34 :UInt64; - val17 @35 :UInt64; + val15 @35 :UInt64; val18 @36 :UInt64; val19 @37 :UInt64; val20 @38 :UInt64; val21 @39 :UInt64; val22 @40 :UInt64; - val31 @41 :UInt64; + val23 @41 :UInt64; val32 @42 :UInt64; val33 @43 :UInt64; val34 @44 :UInt64; @@ -430,16 +431,16 @@ struct Stmt @0x91127d30fade9a32{ val50 @60 :UInt64; val51 @61 :UInt64; val52 @62 :UInt64; - val56 @63 :UInt64; - val12 @64 :Bool; - val16 @65 :Bool; - val23 @66 :Bool; + val53 @63 :UInt64; + val57 @64 :UInt64; + val13 @65 :Bool; + val17 @66 :Bool; val24 @67 :Bool; val25 @68 :Bool; - val58 @69 :Bool; + val26 @69 :Bool; val59 @70 :Bool; val60 @71 :Bool; - val71 @72 :Bool; + val61 @72 :Bool; val72 @73 :Bool; val73 @74 :Bool; val74 @75 :Bool; @@ -457,8 +458,8 @@ struct Stmt @0x91127d30fade9a32{ val86 @87 :Bool; val87 @88 :Bool; val88 @89 :Bool; - val90 @90 :Bool; - val92 @91 :Bool; + val89 @90 :Bool; + val91 @91 :Bool; val93 @92 :Bool; val94 @93 :Bool; val95 @94 :Bool; @@ -466,10 +467,11 @@ struct Stmt @0x91127d30fade9a32{ val97 @96 :Bool; val98 @97 :Bool; val99 @98 :Bool; - val26 @99 :UInt32; - val100 @100 :UInt32; + val100 @99 :Bool; + val27 @100 :UInt32; val101 @101 :UInt32; val102 @102 :UInt32; + val103 @103 :UInt32; } struct Type @0xd739e808bc1b3fd7{ diff --git a/lib/AST/AbstractConditionalOperator.cpp b/lib/AST/AbstractConditionalOperator.cpp index dfe006879..119ecbecd 100644 --- a/lib/AST/AbstractConditionalOperator.cpp +++ b/lib/AST/AbstractConditionalOperator.cpp @@ -187,25 +187,25 @@ std::optional AbstractConditionalOperator::from(con } Token AbstractConditionalOperator::colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Expr AbstractConditionalOperator::condition(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr AbstractConditionalOperator::false_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token AbstractConditionalOperator::question_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Expr AbstractConditionalOperator::true_expression(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/AccessSpecDecl.cpp b/lib/AST/AccessSpecDecl.cpp index d93c03615..e5d4dc7ad 100644 --- a/lib/AST/AccessSpecDecl.cpp +++ b/lib/AST/AccessSpecDecl.cpp @@ -210,11 +210,11 @@ std::optional AccessSpecDecl::from(const TokenContext &t) { } Token AccessSpecDecl::access_specifier_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token AccessSpecDecl::colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } #pragma GCC diagnostic pop diff --git a/lib/AST/AddrLabelExpr.cpp b/lib/AST/AddrLabelExpr.cpp index 0871086c2..8dd21340d 100644 --- a/lib/AST/AddrLabelExpr.cpp +++ b/lib/AST/AddrLabelExpr.cpp @@ -184,16 +184,16 @@ std::optional AddrLabelExpr::from(const TokenContext &t) { } Token AddrLabelExpr::amp_amp_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } LabelDecl AddrLabelExpr::label(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return LabelDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token AddrLabelExpr::label_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ArrayInitLoopExpr.cpp b/lib/AST/ArrayInitLoopExpr.cpp index 7a43a0d02..1fc5d4660 100644 --- a/lib/AST/ArrayInitLoopExpr.cpp +++ b/lib/AST/ArrayInitLoopExpr.cpp @@ -184,12 +184,12 @@ std::optional ArrayInitLoopExpr::from(const TokenContext &t) } OpaqueValueExpr ArrayInitLoopExpr::common_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return OpaqueValueExpr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ArrayInitLoopExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ArraySubscriptExpr.cpp b/lib/AST/ArraySubscriptExpr.cpp index 21b80aa40..6a2537c2e 100644 --- a/lib/AST/ArraySubscriptExpr.cpp +++ b/lib/AST/ArraySubscriptExpr.cpp @@ -183,26 +183,26 @@ std::optional ArraySubscriptExpr::from(const TokenContext &t } Expr ArraySubscriptExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ArraySubscriptExpr::index(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ArraySubscriptExpr::lhs(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token ArraySubscriptExpr::r_bracket_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Expr ArraySubscriptExpr::rhs(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ArrayTypeTraitExpr.cpp b/lib/AST/ArrayTypeTraitExpr.cpp index 2dc2fafe4..1d80bb831 100644 --- a/lib/AST/ArrayTypeTraitExpr.cpp +++ b/lib/AST/ArrayTypeTraitExpr.cpp @@ -184,21 +184,21 @@ std::optional ArrayTypeTraitExpr::from(const TokenContext &t } Expr ArrayTypeTraitExpr::dimension_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Type ArrayTypeTraitExpr::queried_type(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Type(impl->ep->TypeFor(impl->ep, eid)); } ArrayTypeTrait ArrayTypeTraitExpr::trait(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } uint64_t ArrayTypeTraitExpr::value(void) const { - return impl->reader.getVal40(); + return impl->reader.getVal41(); } #pragma GCC diagnostic pop diff --git a/lib/AST/AsTypeExpr.cpp b/lib/AST/AsTypeExpr.cpp index 4f6587825..aa6581001 100644 --- a/lib/AST/AsTypeExpr.cpp +++ b/lib/AST/AsTypeExpr.cpp @@ -183,15 +183,15 @@ std::optional AsTypeExpr::from(const TokenContext &t) { } Token AsTypeExpr::builtin_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token AsTypeExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Expr AsTypeExpr::src_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/AsmStmt.cpp b/lib/AST/AsmStmt.cpp index b2d644bc5..768a744cf 100644 --- a/lib/AST/AsmStmt.cpp +++ b/lib/AST/AsmStmt.cpp @@ -186,20 +186,20 @@ std::optional AsmStmt::from(const TokenContext &t) { } std::string_view AsmStmt::generate_assembly_string(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } Token AsmStmt::assembly_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } unsigned AsmStmt::num_inputs(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional AsmStmt::nth_input(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -213,12 +213,12 @@ std::optional AsmStmt::nth_input(unsigned n) const { } gap::generator AsmStmt::inputs(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -227,19 +227,19 @@ gap::generator AsmStmt::inputs(void) const & { } bool AsmStmt::is_simple(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } bool AsmStmt::is_volatile(void) const { - return impl->reader.getVal16(); + return impl->reader.getVal17(); } unsigned AsmStmt::num_outputs(void) const { - return impl->reader.getVal27().size(); + return impl->reader.getVal28().size(); } std::optional AsmStmt::nth_output(unsigned n) const { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); if (n >= list.size()) { return std::nullopt; } @@ -253,12 +253,12 @@ std::optional AsmStmt::nth_output(unsigned n) const { } gap::generator AsmStmt::outputs(void) const & { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d27 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d27))) { + if (auto d28 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d28))) { co_yield std::move(*e); } } @@ -267,7 +267,7 @@ gap::generator AsmStmt::outputs(void) const & { } gap::generator AsmStmt::output_constraints(void) const & { - auto list = impl->reader.getVal62(); + auto list = impl->reader.getVal63(); EntityProviderPtr ep = impl->ep; for (auto v : list) { co_yield std::string_view(v.cStr(), v.size()); @@ -276,11 +276,11 @@ co_yield std::string_view(v.cStr(), v.size()); } unsigned AsmStmt::num_output_expressions(void) const { - return impl->reader.getVal28().size(); + return impl->reader.getVal29().size(); } std::optional AsmStmt::nth_output_expression(unsigned n) const { - auto list = impl->reader.getVal28(); + auto list = impl->reader.getVal29(); if (n >= list.size()) { return std::nullopt; } @@ -294,12 +294,12 @@ std::optional AsmStmt::nth_output_expression(unsigned n) const { } gap::generator AsmStmt::output_expressions(void) const & { - auto list = impl->reader.getVal28(); + auto list = impl->reader.getVal29(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d28 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d28))) { + if (auto d29 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d29))) { co_yield std::move(*e); } } @@ -308,7 +308,7 @@ gap::generator AsmStmt::output_expressions(void) const & { } gap::generator AsmStmt::input_constraints(void) const & { - auto list = impl->reader.getVal63(); + auto list = impl->reader.getVal64(); EntityProviderPtr ep = impl->ep; for (auto v : list) { co_yield std::string_view(v.cStr(), v.size()); @@ -317,11 +317,11 @@ co_yield std::string_view(v.cStr(), v.size()); } unsigned AsmStmt::num_input_expressions(void) const { - return impl->reader.getVal29().size(); + return impl->reader.getVal30().size(); } std::optional AsmStmt::nth_input_expression(unsigned n) const { - auto list = impl->reader.getVal29(); + auto list = impl->reader.getVal30(); if (n >= list.size()) { return std::nullopt; } @@ -335,12 +335,12 @@ std::optional AsmStmt::nth_input_expression(unsigned n) const { } gap::generator AsmStmt::input_expressions(void) const & { - auto list = impl->reader.getVal29(); + auto list = impl->reader.getVal30(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d29 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d29))) { + if (auto d30 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d30))) { co_yield std::move(*e); } } @@ -349,7 +349,7 @@ gap::generator AsmStmt::input_expressions(void) const & { } gap::generator AsmStmt::clobbers(void) const & { - auto list = impl->reader.getVal64(); + auto list = impl->reader.getVal65(); EntityProviderPtr ep = impl->ep; for (auto v : list) { co_yield std::string_view(v.cStr(), v.size()); diff --git a/lib/AST/AtomicExpr.cpp b/lib/AST/AtomicExpr.cpp index 5c911063c..c1f0e72f6 100644 --- a/lib/AST/AtomicExpr.cpp +++ b/lib/AST/AtomicExpr.cpp @@ -184,26 +184,26 @@ std::optional AtomicExpr::from(const TokenContext &t) { } Token AtomicExpr::builtin_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } AtomicExprAtomicOp AtomicExpr::operation(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } std::string_view AtomicExpr::operation_as_string(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } Expr AtomicExpr::order(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional AtomicExpr::order_fail(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -215,17 +215,17 @@ std::optional AtomicExpr::order_fail(void) const { } Expr AtomicExpr::pointer(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token AtomicExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } std::optional AtomicExpr::scope(void) const { if (true) { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -238,7 +238,7 @@ std::optional AtomicExpr::scope(void) const { std::optional AtomicExpr::value1(void) const { if (true) { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -251,7 +251,7 @@ std::optional AtomicExpr::value1(void) const { std::optional AtomicExpr::value2(void) const { if (true) { - RawEntityId eid = impl->reader.getVal45(); + RawEntityId eid = impl->reader.getVal46(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -263,13 +263,13 @@ std::optional AtomicExpr::value2(void) const { } Type AtomicExpr::value_type(void) const { - RawEntityId eid = impl->reader.getVal46(); + RawEntityId eid = impl->reader.getVal47(); return Type(impl->ep->TypeFor(impl->ep, eid)); } std::optional AtomicExpr::weak(void) const { if (true) { - RawEntityId eid = impl->reader.getVal47(); + RawEntityId eid = impl->reader.getVal48(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -281,23 +281,23 @@ std::optional AtomicExpr::weak(void) const { } bool AtomicExpr::is_cmp_x_chg(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool AtomicExpr::is_open_cl(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool AtomicExpr::is_volatile(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } unsigned AtomicExpr::num_sub_expressions(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional AtomicExpr::nth_sub_expression(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -311,12 +311,12 @@ std::optional AtomicExpr::nth_sub_expression(unsigned n) const { } gap::generator AtomicExpr::sub_expressions(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/AttributedStmt.cpp b/lib/AST/AttributedStmt.cpp index 58b1fb2a3..d9f50f649 100644 --- a/lib/AST/AttributedStmt.cpp +++ b/lib/AST/AttributedStmt.cpp @@ -183,15 +183,15 @@ std::optional AttributedStmt::from(const TokenContext &t) { } Token AttributedStmt::attribute_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } unsigned AttributedStmt::num_attributes(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional AttributedStmt::nth_attribute(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -205,19 +205,19 @@ std::optional AttributedStmt::nth_attribute(unsigned n) const { } gap::generator AttributedStmt::attributes(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->AttrFor(ep, v)) { - co_yield Attr(std::move(d15)); + if (auto d16 = ep->AttrFor(ep, v)) { + co_yield Attr(std::move(d16)); } } co_return; } Stmt AttributedStmt::sub_statement(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/BaseUsingDecl.cpp b/lib/AST/BaseUsingDecl.cpp index 491adf6b8..00b85c7e6 100644 --- a/lib/AST/BaseUsingDecl.cpp +++ b/lib/AST/BaseUsingDecl.cpp @@ -216,11 +216,11 @@ std::optional BaseUsingDecl::from(const TokenContext &t) { } unsigned BaseUsingDecl::num_shadows(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional BaseUsingDecl::nth_shadow(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -234,12 +234,12 @@ std::optional BaseUsingDecl::nth_shadow(unsigned n) const { } gap::generator BaseUsingDecl::shadows(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->DeclFor(ep, v)) { - if (auto e = UsingShadowDecl::from_base(std::move(d43))) { + if (auto d44 = ep->DeclFor(ep, v)) { + if (auto e = UsingShadowDecl::from_base(std::move(d44))) { co_yield std::move(*e); } } diff --git a/lib/AST/BinaryConditionalOperator.cpp b/lib/AST/BinaryConditionalOperator.cpp index 15320f6d5..47ebacb56 100644 --- a/lib/AST/BinaryConditionalOperator.cpp +++ b/lib/AST/BinaryConditionalOperator.cpp @@ -185,12 +185,12 @@ std::optional BinaryConditionalOperator::from(const T } Expr BinaryConditionalOperator::common(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } OpaqueValueExpr BinaryConditionalOperator::opaque_value(void) const { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); return OpaqueValueExpr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/BinaryOperator.cpp b/lib/AST/BinaryOperator.cpp index 12c0ee3b4..7667a8d08 100644 --- a/lib/AST/BinaryOperator.cpp +++ b/lib/AST/BinaryOperator.cpp @@ -186,82 +186,82 @@ std::optional BinaryOperator::from(const TokenContext &t) { } Expr BinaryOperator::lhs(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } BinaryOperatorKind BinaryOperator::opcode(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } std::string_view BinaryOperator::opcode_string(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } Token BinaryOperator::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Expr BinaryOperator::rhs(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool BinaryOperator::has_stored_fp_features(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool BinaryOperator::is_additive_operation(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool BinaryOperator::is_assignment_operation(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool BinaryOperator::is_bitwise_operation(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool BinaryOperator::is_comma_operation(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool BinaryOperator::is_comparison_operation(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool BinaryOperator::is_compound_assignment_operation(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool BinaryOperator::is_equality_operation(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool BinaryOperator::is_logical_operation(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } bool BinaryOperator::is_multiplicative_operation(void) const { - return impl->reader.getVal95(); + return impl->reader.getVal96(); } bool BinaryOperator::is_pointer_memory_operation(void) const { - return impl->reader.getVal96(); + return impl->reader.getVal97(); } bool BinaryOperator::is_relational_operation(void) const { - return impl->reader.getVal97(); + return impl->reader.getVal98(); } bool BinaryOperator::is_shift_assign_operation(void) const { - return impl->reader.getVal98(); + return impl->reader.getVal99(); } bool BinaryOperator::is_shift_operation(void) const { - return impl->reader.getVal99(); + return impl->reader.getVal100(); } #pragma GCC diagnostic pop diff --git a/lib/AST/BindingDecl.cpp b/lib/AST/BindingDecl.cpp index 8c8838c09..cb0e6fb69 100644 --- a/lib/AST/BindingDecl.cpp +++ b/lib/AST/BindingDecl.cpp @@ -215,7 +215,7 @@ std::optional BindingDecl::from(const TokenContext &t) { std::optional BindingDecl::binding(void) const { if (true) { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -227,13 +227,13 @@ std::optional BindingDecl::binding(void) const { } ValueDecl BindingDecl::decomposed_declaration(void) const { - RawEntityId eid = impl->reader.getVal58(); + RawEntityId eid = impl->reader.getVal59(); return ValueDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional BindingDecl::holding_variable(void) const { if (true) { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/BlockDecl.cpp b/lib/AST/BlockDecl.cpp index 5425bf1fb..38a95dc80 100644 --- a/lib/AST/BlockDecl.cpp +++ b/lib/AST/BlockDecl.cpp @@ -214,24 +214,24 @@ std::optional BlockDecl::from(const TokenContext &t) { } bool BlockDecl::block_missing_return_type(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } bool BlockDecl::can_avoid_copy_to_heap(void) const { - return impl->reader.getVal45(); + return impl->reader.getVal46(); } bool BlockDecl::captures_cxx_this(void) const { - return impl->reader.getVal46(); + return impl->reader.getVal47(); } bool BlockDecl::does_not_escape(void) const { - return impl->reader.getVal47(); + return impl->reader.getVal48(); } std::optional BlockDecl::block_mangling_context_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -243,41 +243,41 @@ std::optional BlockDecl::block_mangling_context_declaration(void) const { } uint32_t BlockDecl::block_mangling_number(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } Token BlockDecl::caret_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } CompoundStmt BlockDecl::compound_body(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Type BlockDecl::signature_as_written(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool BlockDecl::has_captures(void) const { - return impl->reader.getVal51(); + return impl->reader.getVal52(); } bool BlockDecl::is_conversion_from_lambda(void) const { - return impl->reader.getVal52(); + return impl->reader.getVal53(); } bool BlockDecl::is_variadic(void) const { - return impl->reader.getVal53(); + return impl->reader.getVal54(); } unsigned BlockDecl::num_parameters(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional BlockDecl::nth_parameter(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -291,12 +291,12 @@ std::optional BlockDecl::nth_parameter(unsigned n) const { } gap::generator BlockDecl::parameters(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->DeclFor(ep, v)) { - if (auto e = ParmVarDecl::from_base(std::move(d43))) { + if (auto d44 = ep->DeclFor(ep, v)) { + if (auto e = ParmVarDecl::from_base(std::move(d44))) { co_yield std::move(*e); } } @@ -305,11 +305,11 @@ gap::generator BlockDecl::parameters(void) const & { } unsigned BlockDecl::num_parameter_declarations(void) const { - return impl->reader.getVal44().size(); + return impl->reader.getVal45().size(); } std::optional BlockDecl::nth_parameter_declaration(unsigned n) const { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); if (n >= list.size()) { return std::nullopt; } @@ -323,12 +323,12 @@ std::optional BlockDecl::nth_parameter_declaration(unsigned n) cons } gap::generator BlockDecl::parameter_declarations(void) const & { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d44 = ep->DeclFor(ep, v)) { - if (auto e = ParmVarDecl::from_base(std::move(d44))) { + if (auto d45 = ep->DeclFor(ep, v)) { + if (auto e = ParmVarDecl::from_base(std::move(d45))) { co_yield std::move(*e); } } diff --git a/lib/AST/BlockExpr.cpp b/lib/AST/BlockExpr.cpp index 0115db7ab..8d398e522 100644 --- a/lib/AST/BlockExpr.cpp +++ b/lib/AST/BlockExpr.cpp @@ -185,21 +185,21 @@ std::optional BlockExpr::from(const TokenContext &t) { } BlockDecl BlockExpr::block_declaration(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return BlockDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Stmt BlockExpr::body(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Token BlockExpr::caret_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } FunctionProtoType BlockExpr::function_type(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return FunctionProtoType::from_base(impl->ep->TypeFor(impl->ep, eid)).value(); } diff --git a/lib/AST/BreakStmt.cpp b/lib/AST/BreakStmt.cpp index 06325e59e..184c96c43 100644 --- a/lib/AST/BreakStmt.cpp +++ b/lib/AST/BreakStmt.cpp @@ -181,7 +181,7 @@ std::optional BreakStmt::from(const TokenContext &t) { } Token BreakStmt::break_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } #pragma GCC diagnostic pop diff --git a/lib/AST/CStyleCastExpr.cpp b/lib/AST/CStyleCastExpr.cpp index 0d70f7052..06b6bd2ae 100644 --- a/lib/AST/CStyleCastExpr.cpp +++ b/lib/AST/CStyleCastExpr.cpp @@ -185,11 +185,11 @@ std::optional CStyleCastExpr::from(const TokenContext &t) { } Token CStyleCastExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } Token CStyleCastExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } #pragma GCC diagnostic pop diff --git a/lib/AST/CUDAKernelCallExpr.cpp b/lib/AST/CUDAKernelCallExpr.cpp index edb23f430..1ba689b0c 100644 --- a/lib/AST/CUDAKernelCallExpr.cpp +++ b/lib/AST/CUDAKernelCallExpr.cpp @@ -184,7 +184,7 @@ std::optional CUDAKernelCallExpr::from(const TokenContext &t } CallExpr CUDAKernelCallExpr::config(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return CallExpr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/CXXBindTemporaryExpr.cpp b/lib/AST/CXXBindTemporaryExpr.cpp index 18387a0bf..084389750 100644 --- a/lib/AST/CXXBindTemporaryExpr.cpp +++ b/lib/AST/CXXBindTemporaryExpr.cpp @@ -183,7 +183,7 @@ std::optional CXXBindTemporaryExpr::from(const TokenContex } Expr CXXBindTemporaryExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/CXXBoolLiteralExpr.cpp b/lib/AST/CXXBoolLiteralExpr.cpp index 3985db41f..888c99b15 100644 --- a/lib/AST/CXXBoolLiteralExpr.cpp +++ b/lib/AST/CXXBoolLiteralExpr.cpp @@ -183,11 +183,11 @@ std::optional CXXBoolLiteralExpr::from(const TokenContext &t } Token CXXBoolLiteralExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } bool CXXBoolLiteralExpr::value(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXCatchStmt.cpp b/lib/AST/CXXCatchStmt.cpp index 2d39aac3c..d2ae19828 100644 --- a/lib/AST/CXXCatchStmt.cpp +++ b/lib/AST/CXXCatchStmt.cpp @@ -183,12 +183,12 @@ std::optional CXXCatchStmt::from(const TokenContext &t) { } Token CXXCatchStmt::catch_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } std::optional CXXCatchStmt::caught_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -201,7 +201,7 @@ std::optional CXXCatchStmt::caught_type(void) const { std::optional CXXCatchStmt::exception_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -213,7 +213,7 @@ std::optional CXXCatchStmt::exception_declaration(void) const { } Stmt CXXCatchStmt::handler_block(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/CXXConstructExpr.cpp b/lib/AST/CXXConstructExpr.cpp index 778627caf..43ed7980e 100644 --- a/lib/AST/CXXConstructExpr.cpp +++ b/lib/AST/CXXConstructExpr.cpp @@ -188,11 +188,11 @@ std::optional CXXConstructExpr::from(const TokenContext &t) { } unsigned CXXConstructExpr::num_arguments(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional CXXConstructExpr::nth_argument(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -206,12 +206,12 @@ std::optional CXXConstructExpr::nth_argument(unsigned n) const { } gap::generator CXXConstructExpr::arguments(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -220,44 +220,44 @@ gap::generator CXXConstructExpr::arguments(void) const & { } CXXConstructionKind CXXConstructExpr::construction_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } CXXConstructorDecl CXXConstructExpr::constructor(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return CXXConstructorDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token CXXConstructExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } TokenRange CXXConstructExpr::parenthesis_or_brace_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal40(), impl->reader.getVal41()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal41(), impl->reader.getVal42()); } bool CXXConstructExpr::had_multiple_candidates(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool CXXConstructExpr::is_elidable(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool CXXConstructExpr::is_immediate_escalating(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool CXXConstructExpr::is_list_initialization(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool CXXConstructExpr::is_std_initializer_list_initialization(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool CXXConstructExpr::requires_zero_initialization(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXConstructorDecl.cpp b/lib/AST/CXXConstructorDecl.cpp index 4742d8ade..277f0aac2 100644 --- a/lib/AST/CXXConstructorDecl.cpp +++ b/lib/AST/CXXConstructorDecl.cpp @@ -218,7 +218,7 @@ std::optional CXXConstructorDecl::from(const TokenContext &t std::optional CXXConstructorDecl::target_constructor(void) const { if (true) { - RawEntityId eid = impl->reader.getVal170(); + RawEntityId eid = impl->reader.getVal171(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -230,11 +230,11 @@ std::optional CXXConstructorDecl::target_constructor(void) c } unsigned CXXConstructorDecl::num_initializers(void) const { - return impl->reader.getVal174().size(); + return impl->reader.getVal175().size(); } std::optional CXXConstructorDecl::nth_initializer(unsigned n) const { - auto list = impl->reader.getVal174(); + auto list = impl->reader.getVal175(); if (n >= list.size()) { return std::nullopt; } @@ -248,35 +248,35 @@ std::optional CXXConstructorDecl::nth_initializer(unsigned n } gap::generator CXXConstructorDecl::initializers(void) const & { - auto list = impl->reader.getVal174(); + auto list = impl->reader.getVal175(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d174 = ep->CXXCtorInitializerFor(ep, v)) { - co_yield CXXCtorInitializer(std::move(d174)); + if (auto d175 = ep->CXXCtorInitializerFor(ep, v)) { + co_yield CXXCtorInitializer(std::move(d175)); } } co_return; } bool CXXConstructorDecl::is_default_constructor(void) const { - return impl->reader.getVal172(); + return impl->reader.getVal173(); } bool CXXConstructorDecl::is_delegating_constructor(void) const { - return impl->reader.getVal173(); + return impl->reader.getVal174(); } bool CXXConstructorDecl::is_explicit(void) const { - return impl->reader.getVal175(); + return impl->reader.getVal176(); } bool CXXConstructorDecl::is_inheriting_constructor(void) const { - return impl->reader.getVal176(); + return impl->reader.getVal177(); } bool CXXConstructorDecl::is_specialization_copying_object(void) const { - return impl->reader.getVal177(); + return impl->reader.getVal178(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXConversionDecl.cpp b/lib/AST/CXXConversionDecl.cpp index fcf330c86..abd30500f 100644 --- a/lib/AST/CXXConversionDecl.cpp +++ b/lib/AST/CXXConversionDecl.cpp @@ -217,16 +217,16 @@ std::optional CXXConversionDecl::from(const TokenContext &t) } Type CXXConversionDecl::conversion_type(void) const { - RawEntityId eid = impl->reader.getVal170(); + RawEntityId eid = impl->reader.getVal171(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool CXXConversionDecl::is_explicit(void) const { - return impl->reader.getVal172(); + return impl->reader.getVal173(); } bool CXXConversionDecl::is_lambda_to_block_pointer_conversion(void) const { - return impl->reader.getVal173(); + return impl->reader.getVal174(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXDeductionGuideDecl.cpp b/lib/AST/CXXDeductionGuideDecl.cpp index 937c15e5c..5d43e695a 100644 --- a/lib/AST/CXXDeductionGuideDecl.cpp +++ b/lib/AST/CXXDeductionGuideDecl.cpp @@ -218,7 +218,7 @@ std::optional CXXDeductionGuideDecl::from(const TokenCont std::optional CXXDeductionGuideDecl::corresponding_constructor(void) const { if (true) { - RawEntityId eid = impl->reader.getVal154(); + RawEntityId eid = impl->reader.getVal155(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -230,16 +230,16 @@ std::optional CXXDeductionGuideDecl::corresponding_construct } TemplateDecl CXXDeductionGuideDecl::deduced_template(void) const { - RawEntityId eid = impl->reader.getVal155(); + RawEntityId eid = impl->reader.getVal156(); return TemplateDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } DeductionCandidate CXXDeductionGuideDecl::deduction_candidate_kind(void) const { - return static_cast(impl->reader.getVal156()); + return static_cast(impl->reader.getVal157()); } bool CXXDeductionGuideDecl::is_explicit(void) const { - return impl->reader.getVal158(); + return impl->reader.getVal159(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXDefaultArgExpr.cpp b/lib/AST/CXXDefaultArgExpr.cpp index 784e871cc..dfd313e30 100644 --- a/lib/AST/CXXDefaultArgExpr.cpp +++ b/lib/AST/CXXDefaultArgExpr.cpp @@ -184,18 +184,18 @@ std::optional CXXDefaultArgExpr::from(const TokenContext &t) } Expr CXXDefaultArgExpr::expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } ParmVarDecl CXXDefaultArgExpr::parameter(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return ParmVarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional CXXDefaultArgExpr::rewritten_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -207,11 +207,11 @@ std::optional CXXDefaultArgExpr::rewritten_expression(void) const { } Token CXXDefaultArgExpr::used_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } bool CXXDefaultArgExpr::has_rewritten_initializer(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXDefaultInitExpr.cpp b/lib/AST/CXXDefaultInitExpr.cpp index af8ee614d..8ef2c2e6c 100644 --- a/lib/AST/CXXDefaultInitExpr.cpp +++ b/lib/AST/CXXDefaultInitExpr.cpp @@ -185,7 +185,7 @@ std::optional CXXDefaultInitExpr::from(const TokenContext &t std::optional CXXDefaultInitExpr::expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -197,21 +197,21 @@ std::optional CXXDefaultInitExpr::expression(void) const { } FieldDecl CXXDefaultInitExpr::field(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return FieldDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Expr CXXDefaultInitExpr::rewritten_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token CXXDefaultInitExpr::used_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } bool CXXDefaultInitExpr::has_rewritten_initializer(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXDeleteExpr.cpp b/lib/AST/CXXDeleteExpr.cpp index 31d516952..5db86ac5d 100644 --- a/lib/AST/CXXDeleteExpr.cpp +++ b/lib/AST/CXXDeleteExpr.cpp @@ -185,17 +185,17 @@ std::optional CXXDeleteExpr::from(const TokenContext &t) { } bool CXXDeleteExpr::does_usual_array_delete_want_size(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } Expr CXXDeleteExpr::argument(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional CXXDeleteExpr::destroyed_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -208,7 +208,7 @@ std::optional CXXDeleteExpr::destroyed_type(void) const { std::optional CXXDeleteExpr::operator_delete(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -220,15 +220,15 @@ std::optional CXXDeleteExpr::operator_delete(void) const { } bool CXXDeleteExpr::is_array_form(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool CXXDeleteExpr::is_array_form_as_written(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool CXXDeleteExpr::is_global_delete(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXDependentScopeMemberExpr.cpp b/lib/AST/CXXDependentScopeMemberExpr.cpp index 36498de6f..0d151a2ad 100644 --- a/lib/AST/CXXDependentScopeMemberExpr.cpp +++ b/lib/AST/CXXDependentScopeMemberExpr.cpp @@ -186,7 +186,7 @@ std::optional CXXDependentScopeMemberExpr::from(con std::optional CXXDependentScopeMemberExpr::base(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -198,13 +198,13 @@ std::optional CXXDependentScopeMemberExpr::base(void) const { } Type CXXDependentScopeMemberExpr::base_type(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Type(impl->ep->TypeFor(impl->ep, eid)); } std::optional CXXDependentScopeMemberExpr::first_qualifier_found_in_scope(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -216,39 +216,39 @@ std::optional CXXDependentScopeMemberExpr::first_qualifier_found_in_s } Token CXXDependentScopeMemberExpr::l_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Token CXXDependentScopeMemberExpr::member_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } Token CXXDependentScopeMemberExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } Token CXXDependentScopeMemberExpr::r_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } Token CXXDependentScopeMemberExpr::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal46()); } bool CXXDependentScopeMemberExpr::has_explicit_template_arguments(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool CXXDependentScopeMemberExpr::has_template_keyword(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool CXXDependentScopeMemberExpr::is_arrow(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool CXXDependentScopeMemberExpr::is_implicit_access(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXDestructorDecl.cpp b/lib/AST/CXXDestructorDecl.cpp index ec204e34b..e481e057a 100644 --- a/lib/AST/CXXDestructorDecl.cpp +++ b/lib/AST/CXXDestructorDecl.cpp @@ -218,7 +218,7 @@ std::optional CXXDestructorDecl::from(const TokenContext &t) std::optional CXXDestructorDecl::operator_delete(void) const { if (true) { - RawEntityId eid = impl->reader.getVal170(); + RawEntityId eid = impl->reader.getVal171(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -231,7 +231,7 @@ std::optional CXXDestructorDecl::operator_delete(void) const { std::optional CXXDestructorDecl::operator_delete_this_argument(void) const { if (true) { - RawEntityId eid = impl->reader.getVal171(); + RawEntityId eid = impl->reader.getVal172(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/CXXDynamicCastExpr.cpp b/lib/AST/CXXDynamicCastExpr.cpp index 8747b6894..d187fa524 100644 --- a/lib/AST/CXXDynamicCastExpr.cpp +++ b/lib/AST/CXXDynamicCastExpr.cpp @@ -186,7 +186,7 @@ std::optional CXXDynamicCastExpr::from(const TokenContext &t } bool CXXDynamicCastExpr::is_always_null(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXFoldExpr.cpp b/lib/AST/CXXFoldExpr.cpp index 4e3dc4a74..1e338644a 100644 --- a/lib/AST/CXXFoldExpr.cpp +++ b/lib/AST/CXXFoldExpr.cpp @@ -185,7 +185,7 @@ std::optional CXXFoldExpr::from(const TokenContext &t) { std::optional CXXFoldExpr::callee(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -197,12 +197,12 @@ std::optional CXXFoldExpr::callee(void) const { } Token CXXFoldExpr::ellipsis_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } std::optional CXXFoldExpr::initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -215,7 +215,7 @@ std::optional CXXFoldExpr::initializer(void) const { std::optional CXXFoldExpr::lhs(void) const { if (true) { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -227,21 +227,21 @@ std::optional CXXFoldExpr::lhs(void) const { } Token CXXFoldExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } BinaryOperatorKind CXXFoldExpr::operator_(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } Expr CXXFoldExpr::pattern(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional CXXFoldExpr::rhs(void) const { if (true) { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -253,15 +253,15 @@ std::optional CXXFoldExpr::rhs(void) const { } Token CXXFoldExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal46()); } bool CXXFoldExpr::is_left_fold(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool CXXFoldExpr::is_right_fold(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXForRangeStmt.cpp b/lib/AST/CXXForRangeStmt.cpp index b958c4800..1173f960c 100644 --- a/lib/AST/CXXForRangeStmt.cpp +++ b/lib/AST/CXXForRangeStmt.cpp @@ -185,7 +185,7 @@ std::optional CXXForRangeStmt::from(const TokenContext &t) { std::optional CXXForRangeStmt::begin_statement(void) const { if (true) { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -197,21 +197,21 @@ std::optional CXXForRangeStmt::begin_statement(void) const { } Stmt CXXForRangeStmt::body(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Token CXXForRangeStmt::coawait_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal12()); } Token CXXForRangeStmt::colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal13()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); } std::optional CXXForRangeStmt::condition(void) const { if (true) { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -224,7 +224,7 @@ std::optional CXXForRangeStmt::condition(void) const { std::optional CXXForRangeStmt::end_statement(void) const { if (true) { - RawEntityId eid = impl->reader.getVal17(); + RawEntityId eid = impl->reader.getVal18(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -236,12 +236,12 @@ std::optional CXXForRangeStmt::end_statement(void) const { } Token CXXForRangeStmt::for_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal18()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal19()); } std::optional CXXForRangeStmt::increment(void) const { if (true) { - RawEntityId eid = impl->reader.getVal19(); + RawEntityId eid = impl->reader.getVal20(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -254,7 +254,7 @@ std::optional CXXForRangeStmt::increment(void) const { std::optional CXXForRangeStmt::initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal20(); + RawEntityId eid = impl->reader.getVal21(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -266,26 +266,26 @@ std::optional CXXForRangeStmt::initializer(void) const { } DeclStmt CXXForRangeStmt::loop_variable_statement(void) const { - RawEntityId eid = impl->reader.getVal21(); + RawEntityId eid = impl->reader.getVal22(); return DeclStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } VarDecl CXXForRangeStmt::loop_variable(void) const { - RawEntityId eid = impl->reader.getVal22(); + RawEntityId eid = impl->reader.getVal23(); return VarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token CXXForRangeStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal31()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal32()); } Expr CXXForRangeStmt::range_initializer(void) const { - RawEntityId eid = impl->reader.getVal32(); + RawEntityId eid = impl->reader.getVal33(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } DeclStmt CXXForRangeStmt::range_statement(void) const { - RawEntityId eid = impl->reader.getVal33(); + RawEntityId eid = impl->reader.getVal34(); return DeclStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/CXXFunctionalCastExpr.cpp b/lib/AST/CXXFunctionalCastExpr.cpp index 0ac3437b9..135e87574 100644 --- a/lib/AST/CXXFunctionalCastExpr.cpp +++ b/lib/AST/CXXFunctionalCastExpr.cpp @@ -185,15 +185,15 @@ std::optional CXXFunctionalCastExpr::from(const TokenCont } Token CXXFunctionalCastExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } Token CXXFunctionalCastExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } bool CXXFunctionalCastExpr::is_list_initialization(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXInheritedCtorInitExpr.cpp b/lib/AST/CXXInheritedCtorInitExpr.cpp index 0cc62b029..4168655ca 100644 --- a/lib/AST/CXXInheritedCtorInitExpr.cpp +++ b/lib/AST/CXXInheritedCtorInitExpr.cpp @@ -184,24 +184,24 @@ std::optional CXXInheritedCtorInitExpr::from(const Tok } bool CXXInheritedCtorInitExpr::constructs_virtual_base(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } CXXConstructionKind CXXInheritedCtorInitExpr::construction_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } CXXConstructorDecl CXXInheritedCtorInitExpr::constructor(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return CXXConstructorDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token CXXInheritedCtorInitExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } bool CXXInheritedCtorInitExpr::inherited_from_virtual_base(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXMemberCallExpr.cpp b/lib/AST/CXXMemberCallExpr.cpp index 344ad1f29..a8adff270 100644 --- a/lib/AST/CXXMemberCallExpr.cpp +++ b/lib/AST/CXXMemberCallExpr.cpp @@ -187,13 +187,13 @@ std::optional CXXMemberCallExpr::from(const TokenContext &t) } Expr CXXMemberCallExpr::implicit_object_argument(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional CXXMemberCallExpr::method_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -205,12 +205,12 @@ std::optional CXXMemberCallExpr::method_declaration(void) const { } Type CXXMemberCallExpr::object_type(void) const { - RawEntityId eid = impl->reader.getVal45(); + RawEntityId eid = impl->reader.getVal46(); return Type(impl->ep->TypeFor(impl->ep, eid)); } CXXRecordDecl CXXMemberCallExpr::record_declaration(void) const { - RawEntityId eid = impl->reader.getVal46(); + RawEntityId eid = impl->reader.getVal47(); return CXXRecordDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } diff --git a/lib/AST/CXXMethodDecl.cpp b/lib/AST/CXXMethodDecl.cpp index 965736ee8..7b79a27c2 100644 --- a/lib/AST/CXXMethodDecl.cpp +++ b/lib/AST/CXXMethodDecl.cpp @@ -225,22 +225,22 @@ std::optional CXXMethodDecl::from(const TokenContext &t) { } Type CXXMethodDecl::function_object_parameter_reference_type(void) const { - RawEntityId eid = impl->reader.getVal154(); + RawEntityId eid = impl->reader.getVal155(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Type CXXMethodDecl::function_object_parameter_type(void) const { - RawEntityId eid = impl->reader.getVal155(); + RawEntityId eid = impl->reader.getVal156(); return Type(impl->ep->TypeFor(impl->ep, eid)); } RefQualifierKind CXXMethodDecl::reference_qualifier(void) const { - return static_cast(impl->reader.getVal156()); + return static_cast(impl->reader.getVal157()); } std::optional CXXMethodDecl::this_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal157(); + RawEntityId eid = impl->reader.getVal158(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -252,51 +252,51 @@ std::optional CXXMethodDecl::this_type(void) const { } bool CXXMethodDecl::has_inline_body(void) const { - return impl->reader.getVal158(); + return impl->reader.getVal159(); } bool CXXMethodDecl::is_const(void) const { - return impl->reader.getVal159(); + return impl->reader.getVal160(); } bool CXXMethodDecl::is_copy_assignment_operator(void) const { - return impl->reader.getVal160(); + return impl->reader.getVal161(); } bool CXXMethodDecl::is_explicit_object_member_function(void) const { - return impl->reader.getVal161(); + return impl->reader.getVal162(); } bool CXXMethodDecl::is_implicit_object_member_function(void) const { - return impl->reader.getVal162(); + return impl->reader.getVal163(); } bool CXXMethodDecl::is_instance(void) const { - return impl->reader.getVal163(); + return impl->reader.getVal164(); } bool CXXMethodDecl::is_lambda_static_invoker(void) const { - return impl->reader.getVal164(); + return impl->reader.getVal165(); } bool CXXMethodDecl::is_move_assignment_operator(void) const { - return impl->reader.getVal165(); + return impl->reader.getVal166(); } bool CXXMethodDecl::is_virtual(void) const { - return impl->reader.getVal166(); + return impl->reader.getVal167(); } bool CXXMethodDecl::is_volatile(void) const { - return impl->reader.getVal167(); + return impl->reader.getVal168(); } unsigned CXXMethodDecl::num_overridden_methods(void) const { - return impl->reader.getVal168().size(); + return impl->reader.getVal169().size(); } std::optional CXXMethodDecl::nth_overridden_method(unsigned n) const { - auto list = impl->reader.getVal168(); + auto list = impl->reader.getVal169(); if (n >= list.size()) { return std::nullopt; } @@ -310,12 +310,12 @@ std::optional CXXMethodDecl::nth_overridden_method(unsigned n) co } gap::generator CXXMethodDecl::overridden_methods(void) const & { - auto list = impl->reader.getVal168(); + auto list = impl->reader.getVal169(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d168 = ep->DeclFor(ep, v)) { - if (auto e = CXXMethodDecl::from_base(std::move(d168))) { + if (auto d169 = ep->DeclFor(ep, v)) { + if (auto e = CXXMethodDecl::from_base(std::move(d169))) { co_yield std::move(*e); } } @@ -324,7 +324,7 @@ gap::generator CXXMethodDecl::overridden_methods(void) const & { } uint32_t CXXMethodDecl::size_overridden_methods(void) const { - return impl->reader.getVal169(); + return impl->reader.getVal170(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXNamedCastExpr.cpp b/lib/AST/CXXNamedCastExpr.cpp index adff17897..0e4c8a092 100644 --- a/lib/AST/CXXNamedCastExpr.cpp +++ b/lib/AST/CXXNamedCastExpr.cpp @@ -199,20 +199,20 @@ std::optional CXXNamedCastExpr::from(const TokenContext &t) { } TokenRange CXXNamedCastExpr::angle_brackets(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal43(), impl->reader.getVal44()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal44(), impl->reader.getVal45()); } std::string_view CXXNamedCastExpr::cast_name(void) const { - capnp::Text::Reader data = impl->reader.getVal66(); + capnp::Text::Reader data = impl->reader.getVal67(); return std::string_view(data.cStr(), data.size()); } Token CXXNamedCastExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal46()); } Token CXXNamedCastExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal46()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal47()); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXNewExpr.cpp b/lib/AST/CXXNewExpr.cpp index d34acfcda..1f962b486 100644 --- a/lib/AST/CXXNewExpr.cpp +++ b/lib/AST/CXXNewExpr.cpp @@ -187,17 +187,17 @@ std::optional CXXNewExpr::from(const TokenContext &t) { } bool CXXNewExpr::does_usual_array_delete_want_size(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } Type CXXNewExpr::allocated_type(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Type(impl->ep->TypeFor(impl->ep, eid)); } std::optional CXXNewExpr::array_size(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -210,7 +210,7 @@ std::optional CXXNewExpr::array_size(void) const { std::optional CXXNewExpr::construct_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -222,16 +222,16 @@ std::optional CXXNewExpr::construct_expression(void) const { } TokenRange CXXNewExpr::direct_initializer_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal41(), impl->reader.getVal42()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal42(), impl->reader.getVal43()); } CXXNewInitializationStyle CXXNewExpr::initialization_style(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } std::optional CXXNewExpr::initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -244,7 +244,7 @@ std::optional CXXNewExpr::initializer(void) const { std::optional CXXNewExpr::operator_delete(void) const { if (true) { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -257,7 +257,7 @@ std::optional CXXNewExpr::operator_delete(void) const { std::optional CXXNewExpr::operator_new(void) const { if (true) { - RawEntityId eid = impl->reader.getVal45(); + RawEntityId eid = impl->reader.getVal46(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -269,35 +269,35 @@ std::optional CXXNewExpr::operator_new(void) const { } TokenRange CXXNewExpr::type_id_parentheses(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal46(), impl->reader.getVal47()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal47(), impl->reader.getVal48()); } bool CXXNewExpr::has_initializer(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool CXXNewExpr::is_array(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool CXXNewExpr::is_global_new(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool CXXNewExpr::is_parenthesis_type_id(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool CXXNewExpr::pass_alignment(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } unsigned CXXNewExpr::num_placement_arguments(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional CXXNewExpr::nth_placement_argument(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -311,12 +311,12 @@ std::optional CXXNewExpr::nth_placement_argument(unsigned n) const { } gap::generator CXXNewExpr::placement_arguments(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/CXXNoexceptExpr.cpp b/lib/AST/CXXNoexceptExpr.cpp index 2acc124b9..bed7e8d83 100644 --- a/lib/AST/CXXNoexceptExpr.cpp +++ b/lib/AST/CXXNoexceptExpr.cpp @@ -183,12 +183,12 @@ std::optional CXXNoexceptExpr::from(const TokenContext &t) { } Expr CXXNoexceptExpr::operand(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool CXXNoexceptExpr::value(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXNullPtrLiteralExpr.cpp b/lib/AST/CXXNullPtrLiteralExpr.cpp index a872cd1d4..fcbb39ea4 100644 --- a/lib/AST/CXXNullPtrLiteralExpr.cpp +++ b/lib/AST/CXXNullPtrLiteralExpr.cpp @@ -183,7 +183,7 @@ std::optional CXXNullPtrLiteralExpr::from(const TokenCont } Token CXXNullPtrLiteralExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXOperatorCallExpr.cpp b/lib/AST/CXXOperatorCallExpr.cpp index 405cd356b..575a75d3e 100644 --- a/lib/AST/CXXOperatorCallExpr.cpp +++ b/lib/AST/CXXOperatorCallExpr.cpp @@ -184,23 +184,23 @@ std::optional CXXOperatorCallExpr::from(const TokenContext } OverloadedOperatorKind CXXOperatorCallExpr::operator_(void) const { - return static_cast(impl->reader.getVal91()); + return static_cast(impl->reader.getVal92()); } Token CXXOperatorCallExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } bool CXXOperatorCallExpr::is_assignment_operation(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool CXXOperatorCallExpr::is_comparison_operation(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool CXXOperatorCallExpr::is_infix_binary_operation(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXParenListInitExpr.cpp b/lib/AST/CXXParenListInitExpr.cpp index 77fccb657..73ad3cfd1 100644 --- a/lib/AST/CXXParenListInitExpr.cpp +++ b/lib/AST/CXXParenListInitExpr.cpp @@ -184,16 +184,16 @@ std::optional CXXParenListInitExpr::from(const TokenContex } Expr CXXParenListInitExpr::array_filler(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token CXXParenListInitExpr::initializer_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } FieldDecl CXXParenListInitExpr::initialized_field_in_union(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return FieldDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } diff --git a/lib/AST/CXXPseudoDestructorExpr.cpp b/lib/AST/CXXPseudoDestructorExpr.cpp index 632ca919b..2fd735209 100644 --- a/lib/AST/CXXPseudoDestructorExpr.cpp +++ b/lib/AST/CXXPseudoDestructorExpr.cpp @@ -184,17 +184,17 @@ std::optional CXXPseudoDestructorExpr::from(const Token } Expr CXXPseudoDestructorExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token CXXPseudoDestructorExpr::colon_colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } std::optional CXXPseudoDestructorExpr::destroyed_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -206,23 +206,23 @@ std::optional CXXPseudoDestructorExpr::destroyed_type(void) const { } Token CXXPseudoDestructorExpr::destroyed_type_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Token CXXPseudoDestructorExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } Token CXXPseudoDestructorExpr::tilde_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } bool CXXPseudoDestructorExpr::has_qualifier(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool CXXPseudoDestructorExpr::is_arrow(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXRecordDecl.cpp b/lib/AST/CXXRecordDecl.cpp index 9be62e5e6..d67bfc7fd 100644 --- a/lib/AST/CXXRecordDecl.cpp +++ b/lib/AST/CXXRecordDecl.cpp @@ -230,46 +230,46 @@ std::optional CXXRecordDecl::from(const TokenContext &t) { } std::optional CXXRecordDecl::allow_const_default_initializer(void) const { - if (!impl->reader.getVal123()) { + if (!impl->reader.getVal124()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal122()); + return static_cast(impl->reader.getVal123()); } return std::nullopt; } std::optional> CXXRecordDecl::bases(void) const { - if (!impl->reader.getVal124()) { + if (!impl->reader.getVal125()) { return std::nullopt; } - auto list = impl->reader.getVal153(); + auto list = impl->reader.getVal154(); std::vector vec; vec.reserve(list.size()); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d153 = ep->CXXBaseSpecifierFor(ep, v)) { - vec.emplace_back(std::move(d153)); + if (auto d154 = ep->CXXBaseSpecifierFor(ep, v)) { + vec.emplace_back(std::move(d154)); } } return vec; } std::optional CXXRecordDecl::inheritance_model(void) const { - if (!impl->reader.getVal125()) { + if (!impl->reader.getVal126()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal77()); + return static_cast(impl->reader.getVal78()); } return std::nullopt; } unsigned CXXRecordDecl::num_constructors(void) const { - return impl->reader.getVal168().size(); + return impl->reader.getVal169().size(); } std::optional CXXRecordDecl::nth_constructor(unsigned n) const { - auto list = impl->reader.getVal168(); + auto list = impl->reader.getVal169(); if (n >= list.size()) { return std::nullopt; } @@ -283,12 +283,12 @@ std::optional CXXRecordDecl::nth_constructor(unsigned n) con } gap::generator CXXRecordDecl::constructors(void) const & { - auto list = impl->reader.getVal168(); + auto list = impl->reader.getVal169(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d168 = ep->DeclFor(ep, v)) { - if (auto e = CXXConstructorDecl::from_base(std::move(d168))) { + if (auto d169 = ep->DeclFor(ep, v)) { + if (auto e = CXXConstructorDecl::from_base(std::move(d169))) { co_yield std::move(*e); } } @@ -297,17 +297,17 @@ gap::generator CXXRecordDecl::constructors(void) const & { } std::optional> CXXRecordDecl::friends(void) const { - if (!impl->reader.getVal126()) { + if (!impl->reader.getVal127()) { return std::nullopt; } - auto list = impl->reader.getVal174(); + auto list = impl->reader.getVal175(); std::vector vec; vec.reserve(list.size()); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d174 = ep->DeclFor(ep, v)) { - if (auto e = FriendDecl::from_base(std::move(d174))) { + if (auto d175 = ep->DeclFor(ep, v)) { + if (auto e = FriendDecl::from_base(std::move(d175))) { vec.emplace_back(std::move(*e)); } } @@ -317,7 +317,7 @@ std::optional> CXXRecordDecl::friends(void) const { std::optional CXXRecordDecl::dependent_lambda_call_operator(void) const { if (true) { - RawEntityId eid = impl->reader.getVal74(); + RawEntityId eid = impl->reader.getVal75(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -330,7 +330,7 @@ std::optional CXXRecordDecl::dependent_lambda_call_operato std::optional CXXRecordDecl::described_class_template(void) const { if (true) { - RawEntityId eid = impl->reader.getVal75(); + RawEntityId eid = impl->reader.getVal76(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -343,7 +343,7 @@ std::optional CXXRecordDecl::described_class_template(void) c std::optional CXXRecordDecl::destructor(void) const { if (true) { - RawEntityId eid = impl->reader.getVal113(); + RawEntityId eid = impl->reader.getVal114(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -356,7 +356,7 @@ std::optional CXXRecordDecl::destructor(void) const { std::optional CXXRecordDecl::generic_lambda_template_parameter_list(void) const { if (true) { - RawEntityId eid = impl->reader.getVal114(); + RawEntityId eid = impl->reader.getVal115(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -369,7 +369,7 @@ std::optional CXXRecordDecl::generic_lambda_template_para std::optional CXXRecordDecl::instantiated_from_member_class(void) const { if (true) { - RawEntityId eid = impl->reader.getVal115(); + RawEntityId eid = impl->reader.getVal116(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -382,7 +382,7 @@ std::optional CXXRecordDecl::instantiated_from_member_class(void) std::optional CXXRecordDecl::lambda_call_operator(void) const { if (true) { - RawEntityId eid = impl->reader.getVal116(); + RawEntityId eid = impl->reader.getVal117(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -394,17 +394,17 @@ std::optional CXXRecordDecl::lambda_call_operator(void) const { } std::optional CXXRecordDecl::lambda_capture_default(void) const { - if (!impl->reader.getVal127()) { + if (!impl->reader.getVal128()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal78()); + return static_cast(impl->reader.getVal79()); } return std::nullopt; } std::optional CXXRecordDecl::lambda_context_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal119(); + RawEntityId eid = impl->reader.getVal120(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -416,21 +416,21 @@ std::optional CXXRecordDecl::lambda_context_declaration(void) const { } uint32_t CXXRecordDecl::lambda_dependency_kind(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } std::optional> CXXRecordDecl::lambda_explicit_template_parameters(void) const { - if (!impl->reader.getVal128()) { + if (!impl->reader.getVal129()) { return std::nullopt; } - auto list = impl->reader.getVal178(); + auto list = impl->reader.getVal179(); std::vector vec; vec.reserve(list.size()); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d178 = ep->DeclFor(ep, v)) { - if (auto e = NamedDecl::from_base(std::move(d178))) { + if (auto d179 = ep->DeclFor(ep, v)) { + if (auto e = NamedDecl::from_base(std::move(d179))) { vec.emplace_back(std::move(*e)); } } @@ -439,17 +439,17 @@ std::optional> CXXRecordDecl::lambda_explicit_template_pa } std::optional CXXRecordDecl::lambda_mangling_number(void) const { - if (!impl->reader.getVal131()) { + if (!impl->reader.getVal132()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal117()); + return static_cast(impl->reader.getVal118()); } return std::nullopt; } std::optional CXXRecordDecl::lambda_static_invoker(void) const { if (true) { - RawEntityId eid = impl->reader.getVal120(); + RawEntityId eid = impl->reader.getVal121(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -461,636 +461,636 @@ std::optional CXXRecordDecl::lambda_static_invoker(void) const { } std::optional CXXRecordDecl::ms_inheritance_model(void) const { - if (!impl->reader.getVal132()) { + if (!impl->reader.getVal133()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal79()); + return static_cast(impl->reader.getVal80()); } return std::nullopt; } MSVtorDispMode CXXRecordDecl::ms_vtor_disp_mode(void) const { - return static_cast(impl->reader.getVal80()); + return static_cast(impl->reader.getVal81()); } std::optional CXXRecordDecl::has_any_dependent_bases(void) const { - if (!impl->reader.getVal134()) { + if (!impl->reader.getVal135()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal133()); + return static_cast(impl->reader.getVal134()); } return std::nullopt; } std::optional CXXRecordDecl::has_constexpr_default_constructor(void) const { - if (!impl->reader.getVal136()) { + if (!impl->reader.getVal137()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal135()); + return static_cast(impl->reader.getVal136()); } return std::nullopt; } std::optional CXXRecordDecl::has_constexpr_destructor(void) const { - if (!impl->reader.getVal138()) { + if (!impl->reader.getVal139()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal137()); + return static_cast(impl->reader.getVal138()); } return std::nullopt; } std::optional CXXRecordDecl::has_constexpr_non_copy_move_constructor(void) const { - if (!impl->reader.getVal140()) { + if (!impl->reader.getVal141()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal139()); + return static_cast(impl->reader.getVal140()); } return std::nullopt; } std::optional CXXRecordDecl::has_copy_assignment_with_const_parameter(void) const { - if (!impl->reader.getVal142()) { + if (!impl->reader.getVal143()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal141()); + return static_cast(impl->reader.getVal142()); } return std::nullopt; } std::optional CXXRecordDecl::has_copy_constructor_with_const_parameter(void) const { - if (!impl->reader.getVal144()) { + if (!impl->reader.getVal145()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal143()); + return static_cast(impl->reader.getVal144()); } return std::nullopt; } std::optional CXXRecordDecl::has_default_constructor(void) const { - if (!impl->reader.getVal146()) { + if (!impl->reader.getVal147()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal145()); + return static_cast(impl->reader.getVal146()); } return std::nullopt; } std::optional CXXRecordDecl::has_definition(void) const { - if (!impl->reader.getVal148()) { + if (!impl->reader.getVal149()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal147()); + return static_cast(impl->reader.getVal148()); } return std::nullopt; } std::optional CXXRecordDecl::has_direct_fields(void) const { - if (!impl->reader.getVal150()) { + if (!impl->reader.getVal151()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal149()); + return static_cast(impl->reader.getVal150()); } return std::nullopt; } std::optional CXXRecordDecl::has_friends(void) const { - if (!impl->reader.getVal158()) { + if (!impl->reader.getVal159()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal151()); + return static_cast(impl->reader.getVal152()); } return std::nullopt; } std::optional CXXRecordDecl::has_in_class_initializer(void) const { - if (!impl->reader.getVal160()) { + if (!impl->reader.getVal161()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal159()); + return static_cast(impl->reader.getVal160()); } return std::nullopt; } std::optional CXXRecordDecl::has_inherited_assignment(void) const { - if (!impl->reader.getVal162()) { + if (!impl->reader.getVal163()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal161()); + return static_cast(impl->reader.getVal162()); } return std::nullopt; } std::optional CXXRecordDecl::has_inherited_constructor(void) const { - if (!impl->reader.getVal164()) { + if (!impl->reader.getVal165()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal163()); + return static_cast(impl->reader.getVal164()); } return std::nullopt; } std::optional CXXRecordDecl::has_initializer_method(void) const { - if (!impl->reader.getVal166()) { + if (!impl->reader.getVal167()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal165()); + return static_cast(impl->reader.getVal166()); } return std::nullopt; } std::optional CXXRecordDecl::has_irrelevant_destructor(void) const { - if (!impl->reader.getVal172()) { + if (!impl->reader.getVal173()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal167()); + return static_cast(impl->reader.getVal168()); } return std::nullopt; } std::optional CXXRecordDecl::has_known_lambda_internal_linkage(void) const { - if (!impl->reader.getVal175()) { + if (!impl->reader.getVal176()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal173()); + return static_cast(impl->reader.getVal174()); } return std::nullopt; } std::optional CXXRecordDecl::has_move_assignment(void) const { - if (!impl->reader.getVal177()) { + if (!impl->reader.getVal178()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal176()); + return static_cast(impl->reader.getVal177()); } return std::nullopt; } std::optional CXXRecordDecl::has_move_constructor(void) const { - if (!impl->reader.getVal180()) { + if (!impl->reader.getVal181()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal179()); + return static_cast(impl->reader.getVal180()); } return std::nullopt; } std::optional CXXRecordDecl::has_mutable_fields(void) const { - if (!impl->reader.getVal182()) { + if (!impl->reader.getVal183()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal181()); + return static_cast(impl->reader.getVal182()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_literal_type_fields_or_bases(void) const { - if (!impl->reader.getVal184()) { + if (!impl->reader.getVal185()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal183()); + return static_cast(impl->reader.getVal184()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_copy_assignment(void) const { - if (!impl->reader.getVal186()) { + if (!impl->reader.getVal187()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal185()); + return static_cast(impl->reader.getVal186()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_copy_constructor(void) const { - if (!impl->reader.getVal188()) { + if (!impl->reader.getVal189()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal187()); + return static_cast(impl->reader.getVal188()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_copy_constructor_for_call(void) const { - if (!impl->reader.getVal190()) { + if (!impl->reader.getVal191()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal189()); + return static_cast(impl->reader.getVal190()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_default_constructor(void) const { - if (!impl->reader.getVal192()) { + if (!impl->reader.getVal193()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal191()); + return static_cast(impl->reader.getVal192()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_destructor(void) const { - if (!impl->reader.getVal194()) { + if (!impl->reader.getVal195()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal193()); + return static_cast(impl->reader.getVal194()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_destructor_for_call(void) const { - if (!impl->reader.getVal196()) { + if (!impl->reader.getVal197()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal195()); + return static_cast(impl->reader.getVal196()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_move_assignment(void) const { - if (!impl->reader.getVal198()) { + if (!impl->reader.getVal199()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal197()); + return static_cast(impl->reader.getVal198()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_move_constructor(void) const { - if (!impl->reader.getVal200()) { + if (!impl->reader.getVal201()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal199()); + return static_cast(impl->reader.getVal200()); } return std::nullopt; } std::optional CXXRecordDecl::has_non_trivial_move_constructor_for_call(void) const { - if (!impl->reader.getVal202()) { + if (!impl->reader.getVal203()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal201()); + return static_cast(impl->reader.getVal202()); } return std::nullopt; } std::optional CXXRecordDecl::has_private_fields(void) const { - if (!impl->reader.getVal204()) { + if (!impl->reader.getVal205()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal203()); + return static_cast(impl->reader.getVal204()); } return std::nullopt; } std::optional CXXRecordDecl::has_protected_fields(void) const { - if (!impl->reader.getVal206()) { + if (!impl->reader.getVal207()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal205()); + return static_cast(impl->reader.getVal206()); } return std::nullopt; } std::optional CXXRecordDecl::has_simple_copy_assignment(void) const { - if (!impl->reader.getVal208()) { + if (!impl->reader.getVal209()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal207()); + return static_cast(impl->reader.getVal208()); } return std::nullopt; } std::optional CXXRecordDecl::has_simple_copy_constructor(void) const { - if (!impl->reader.getVal210()) { + if (!impl->reader.getVal211()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal209()); + return static_cast(impl->reader.getVal210()); } return std::nullopt; } std::optional CXXRecordDecl::has_simple_destructor(void) const { - if (!impl->reader.getVal212()) { + if (!impl->reader.getVal213()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal211()); + return static_cast(impl->reader.getVal212()); } return std::nullopt; } std::optional CXXRecordDecl::has_simple_move_assignment(void) const { - if (!impl->reader.getVal214()) { + if (!impl->reader.getVal215()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal213()); + return static_cast(impl->reader.getVal214()); } return std::nullopt; } std::optional CXXRecordDecl::has_simple_move_constructor(void) const { - if (!impl->reader.getVal216()) { + if (!impl->reader.getVal217()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal215()); + return static_cast(impl->reader.getVal216()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_copy_assignment(void) const { - if (!impl->reader.getVal218()) { + if (!impl->reader.getVal219()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal217()); + return static_cast(impl->reader.getVal218()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_copy_constructor(void) const { - if (!impl->reader.getVal220()) { + if (!impl->reader.getVal221()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal219()); + return static_cast(impl->reader.getVal220()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_copy_constructor_for_call(void) const { - if (!impl->reader.getVal222()) { + if (!impl->reader.getVal223()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal221()); + return static_cast(impl->reader.getVal222()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_default_constructor(void) const { - if (!impl->reader.getVal224()) { + if (!impl->reader.getVal225()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal223()); + return static_cast(impl->reader.getVal224()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_destructor(void) const { - if (!impl->reader.getVal226()) { + if (!impl->reader.getVal227()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal225()); + return static_cast(impl->reader.getVal226()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_destructor_for_call(void) const { - if (!impl->reader.getVal228()) { + if (!impl->reader.getVal229()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal227()); + return static_cast(impl->reader.getVal228()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_move_assignment(void) const { - if (!impl->reader.getVal230()) { + if (!impl->reader.getVal231()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal229()); + return static_cast(impl->reader.getVal230()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_move_constructor(void) const { - if (!impl->reader.getVal232()) { + if (!impl->reader.getVal233()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal231()); + return static_cast(impl->reader.getVal232()); } return std::nullopt; } std::optional CXXRecordDecl::has_trivial_move_constructor_for_call(void) const { - if (!impl->reader.getVal234()) { + if (!impl->reader.getVal235()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal233()); + return static_cast(impl->reader.getVal234()); } return std::nullopt; } std::optional CXXRecordDecl::has_uninitialized_reference_member(void) const { - if (!impl->reader.getVal236()) { + if (!impl->reader.getVal237()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal235()); + return static_cast(impl->reader.getVal236()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_declared_constructor(void) const { - if (!impl->reader.getVal238()) { + if (!impl->reader.getVal239()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal237()); + return static_cast(impl->reader.getVal238()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_declared_copy_assignment(void) const { - if (!impl->reader.getVal240()) { + if (!impl->reader.getVal241()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal239()); + return static_cast(impl->reader.getVal240()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_declared_copy_constructor(void) const { - if (!impl->reader.getVal242()) { + if (!impl->reader.getVal243()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal241()); + return static_cast(impl->reader.getVal242()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_declared_destructor(void) const { - if (!impl->reader.getVal244()) { + if (!impl->reader.getVal245()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal243()); + return static_cast(impl->reader.getVal244()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_declared_move_assignment(void) const { - if (!impl->reader.getVal246()) { + if (!impl->reader.getVal247()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal245()); + return static_cast(impl->reader.getVal246()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_declared_move_constructor(void) const { - if (!impl->reader.getVal248()) { + if (!impl->reader.getVal249()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal247()); + return static_cast(impl->reader.getVal248()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_declared_move_operation(void) const { - if (!impl->reader.getVal250()) { + if (!impl->reader.getVal251()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal249()); + return static_cast(impl->reader.getVal250()); } return std::nullopt; } std::optional CXXRecordDecl::has_user_provided_default_constructor(void) const { - if (!impl->reader.getVal252()) { + if (!impl->reader.getVal253()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal251()); + return static_cast(impl->reader.getVal252()); } return std::nullopt; } std::optional CXXRecordDecl::has_variant_members(void) const { - if (!impl->reader.getVal254()) { + if (!impl->reader.getVal255()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal253()); + return static_cast(impl->reader.getVal254()); } return std::nullopt; } std::optional CXXRecordDecl::implicit_copy_assignment_has_const_parameter(void) const { - if (!impl->reader.getVal256()) { + if (!impl->reader.getVal257()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal255()); + return static_cast(impl->reader.getVal256()); } return std::nullopt; } std::optional CXXRecordDecl::implicit_copy_constructor_has_const_parameter(void) const { - if (!impl->reader.getVal258()) { + if (!impl->reader.getVal259()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal257()); + return static_cast(impl->reader.getVal258()); } return std::nullopt; } std::optional CXXRecordDecl::is_abstract(void) const { - if (!impl->reader.getVal260()) { + if (!impl->reader.getVal261()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal259()); + return static_cast(impl->reader.getVal260()); } return std::nullopt; } std::optional CXXRecordDecl::is_aggregate(void) const { - if (!impl->reader.getVal262()) { + if (!impl->reader.getVal263()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal261()); + return static_cast(impl->reader.getVal262()); } return std::nullopt; } std::optional CXXRecordDecl::is_any_destructor_no_return(void) const { - if (!impl->reader.getVal264()) { + if (!impl->reader.getVal265()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal263()); + return static_cast(impl->reader.getVal264()); } return std::nullopt; } std::optional CXXRecordDecl::is_c_like(void) const { - if (!impl->reader.getVal266()) { + if (!impl->reader.getVal267()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal265()); + return static_cast(impl->reader.getVal266()); } return std::nullopt; } std::optional CXXRecordDecl::is_cxx11_standard_layout(void) const { - if (!impl->reader.getVal268()) { + if (!impl->reader.getVal269()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal267()); + return static_cast(impl->reader.getVal268()); } return std::nullopt; } bool CXXRecordDecl::is_captureless_lambda(void) const { - return impl->reader.getVal269(); + return impl->reader.getVal270(); } bool CXXRecordDecl::is_dependent_lambda(void) const { - return impl->reader.getVal270(); + return impl->reader.getVal271(); } std::optional CXXRecordDecl::is_dynamic_class(void) const { - if (!impl->reader.getVal272()) { + if (!impl->reader.getVal273()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal271()); + return static_cast(impl->reader.getVal272()); } return std::nullopt; } std::optional CXXRecordDecl::is_effectively_final(void) const { - if (!impl->reader.getVal274()) { + if (!impl->reader.getVal275()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal273()); + return static_cast(impl->reader.getVal274()); } return std::nullopt; } std::optional CXXRecordDecl::is_empty(void) const { - if (!impl->reader.getVal276()) { + if (!impl->reader.getVal277()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal275()); + return static_cast(impl->reader.getVal276()); } return std::nullopt; } bool CXXRecordDecl::is_generic_lambda(void) const { - return impl->reader.getVal277(); + return impl->reader.getVal278(); } std::optional CXXRecordDecl::is_interface_like(void) const { - if (!impl->reader.getVal279()) { + if (!impl->reader.getVal280()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal278()); + return static_cast(impl->reader.getVal279()); } return std::nullopt; } std::optional CXXRecordDecl::is_literal(void) const { - if (!impl->reader.getVal281()) { + if (!impl->reader.getVal282()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal280()); + return static_cast(impl->reader.getVal281()); } return std::nullopt; } std::optional CXXRecordDecl::is_local_class(void) const { if (true) { - RawEntityId eid = impl->reader.getVal152(); + RawEntityId eid = impl->reader.getVal153(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -1102,245 +1102,245 @@ std::optional CXXRecordDecl::is_local_class(void) const { } bool CXXRecordDecl::is_never_dependent_lambda(void) const { - return impl->reader.getVal282(); + return impl->reader.getVal283(); } std::optional CXXRecordDecl::is_pod(void) const { - if (!impl->reader.getVal284()) { + if (!impl->reader.getVal285()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal283()); + return static_cast(impl->reader.getVal284()); } return std::nullopt; } std::optional CXXRecordDecl::is_polymorphic(void) const { - if (!impl->reader.getVal286()) { + if (!impl->reader.getVal287()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal285()); + return static_cast(impl->reader.getVal286()); } return std::nullopt; } std::optional CXXRecordDecl::is_standard_layout(void) const { - if (!impl->reader.getVal288()) { + if (!impl->reader.getVal289()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal287()); + return static_cast(impl->reader.getVal288()); } return std::nullopt; } std::optional CXXRecordDecl::is_structural(void) const { - if (!impl->reader.getVal290()) { + if (!impl->reader.getVal291()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal289()); + return static_cast(impl->reader.getVal290()); } return std::nullopt; } std::optional CXXRecordDecl::is_trivial(void) const { - if (!impl->reader.getVal292()) { + if (!impl->reader.getVal293()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal291()); + return static_cast(impl->reader.getVal292()); } return std::nullopt; } std::optional CXXRecordDecl::is_trivially_copy_constructible(void) const { - if (!impl->reader.getVal294()) { + if (!impl->reader.getVal295()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal293()); + return static_cast(impl->reader.getVal294()); } return std::nullopt; } std::optional CXXRecordDecl::is_trivially_copyable(void) const { - if (!impl->reader.getVal296()) { + if (!impl->reader.getVal297()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal295()); + return static_cast(impl->reader.getVal296()); } return std::nullopt; } std::optional CXXRecordDecl::lambda_is_default_constructible_and_assignable(void) const { - if (!impl->reader.getVal298()) { + if (!impl->reader.getVal299()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal297()); + return static_cast(impl->reader.getVal298()); } return std::nullopt; } std::optional CXXRecordDecl::may_be_abstract(void) const { - if (!impl->reader.getVal300()) { + if (!impl->reader.getVal301()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal299()); + return static_cast(impl->reader.getVal300()); } return std::nullopt; } std::optional CXXRecordDecl::may_be_dynamic_class(void) const { - if (!impl->reader.getVal302()) { + if (!impl->reader.getVal303()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal301()); + return static_cast(impl->reader.getVal302()); } return std::nullopt; } std::optional CXXRecordDecl::may_be_non_dynamic_class(void) const { - if (!impl->reader.getVal304()) { + if (!impl->reader.getVal305()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal303()); + return static_cast(impl->reader.getVal304()); } return std::nullopt; } std::optional CXXRecordDecl::needs_implicit_copy_assignment(void) const { - if (!impl->reader.getVal306()) { + if (!impl->reader.getVal307()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal305()); + return static_cast(impl->reader.getVal306()); } return std::nullopt; } std::optional CXXRecordDecl::needs_implicit_copy_constructor(void) const { - if (!impl->reader.getVal308()) { + if (!impl->reader.getVal309()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal307()); + return static_cast(impl->reader.getVal308()); } return std::nullopt; } std::optional CXXRecordDecl::needs_implicit_default_constructor(void) const { - if (!impl->reader.getVal310()) { + if (!impl->reader.getVal311()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal309()); + return static_cast(impl->reader.getVal310()); } return std::nullopt; } std::optional CXXRecordDecl::needs_implicit_destructor(void) const { - if (!impl->reader.getVal312()) { + if (!impl->reader.getVal313()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal311()); + return static_cast(impl->reader.getVal312()); } return std::nullopt; } std::optional CXXRecordDecl::needs_implicit_move_assignment(void) const { - if (!impl->reader.getVal314()) { + if (!impl->reader.getVal315()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal313()); + return static_cast(impl->reader.getVal314()); } return std::nullopt; } std::optional CXXRecordDecl::needs_implicit_move_constructor(void) const { - if (!impl->reader.getVal316()) { + if (!impl->reader.getVal317()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal315()); + return static_cast(impl->reader.getVal316()); } return std::nullopt; } std::optional CXXRecordDecl::needs_overload_resolution_for_copy_assignment(void) const { - if (!impl->reader.getVal318()) { + if (!impl->reader.getVal319()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal317()); + return static_cast(impl->reader.getVal318()); } return std::nullopt; } std::optional CXXRecordDecl::needs_overload_resolution_for_copy_constructor(void) const { - if (!impl->reader.getVal320()) { + if (!impl->reader.getVal321()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal319()); + return static_cast(impl->reader.getVal320()); } return std::nullopt; } std::optional CXXRecordDecl::needs_overload_resolution_for_destructor(void) const { - if (!impl->reader.getVal322()) { + if (!impl->reader.getVal323()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal321()); + return static_cast(impl->reader.getVal322()); } return std::nullopt; } std::optional CXXRecordDecl::needs_overload_resolution_for_move_assignment(void) const { - if (!impl->reader.getVal324()) { + if (!impl->reader.getVal325()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal323()); + return static_cast(impl->reader.getVal324()); } return std::nullopt; } std::optional CXXRecordDecl::needs_overload_resolution_for_move_constructor(void) const { - if (!impl->reader.getVal326()) { + if (!impl->reader.getVal327()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal325()); + return static_cast(impl->reader.getVal326()); } return std::nullopt; } std::optional CXXRecordDecl::null_field_offset_is_zero(void) const { - if (!impl->reader.getVal328()) { + if (!impl->reader.getVal329()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal327()); + return static_cast(impl->reader.getVal328()); } return std::nullopt; } std::optional> CXXRecordDecl::virtual_bases(void) const { - if (!impl->reader.getVal330()) { + if (!impl->reader.getVal331()) { return std::nullopt; } - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); std::vector vec; vec.reserve(list.size()); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d329 = ep->CXXBaseSpecifierFor(ep, v)) { - vec.emplace_back(std::move(d329)); + if (auto d330 = ep->CXXBaseSpecifierFor(ep, v)) { + vec.emplace_back(std::move(d330)); } } return vec; } std::optional CXXRecordDecl::size_without_virtual_bases(void) const { - if (!impl->reader.getVal331()) { + if (!impl->reader.getVal332()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal154()); + return static_cast(impl->reader.getVal155()); } return std::nullopt; } std::optional CXXRecordDecl::primary_base(void) const { if (true) { - RawEntityId eid = impl->reader.getVal155(); + RawEntityId eid = impl->reader.getVal156(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -1352,37 +1352,37 @@ std::optional CXXRecordDecl::primary_base(void) const { } std::optional CXXRecordDecl::has_own_virtual_function_table_pointer(void) const { - if (!impl->reader.getVal333()) { + if (!impl->reader.getVal334()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal332()); + return static_cast(impl->reader.getVal333()); } return std::nullopt; } std::optional CXXRecordDecl::has_extendable_virtual_function_table_pointer(void) const { - if (!impl->reader.getVal335()) { + if (!impl->reader.getVal336()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal334()); + return static_cast(impl->reader.getVal335()); } return std::nullopt; } std::optional CXXRecordDecl::has_virtual_base_table_pointer(void) const { - if (!impl->reader.getVal337()) { + if (!impl->reader.getVal338()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal336()); + return static_cast(impl->reader.getVal337()); } return std::nullopt; } std::optional CXXRecordDecl::has_own_virtual_base_table_pointer(void) const { - if (!impl->reader.getVal339()) { + if (!impl->reader.getVal340()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal338()); + return static_cast(impl->reader.getVal339()); } return std::nullopt; } diff --git a/lib/AST/CXXRewrittenBinaryOperator.cpp b/lib/AST/CXXRewrittenBinaryOperator.cpp index f86e3ad26..129c844f7 100644 --- a/lib/AST/CXXRewrittenBinaryOperator.cpp +++ b/lib/AST/CXXRewrittenBinaryOperator.cpp @@ -183,47 +183,47 @@ std::optional CXXRewrittenBinaryOperator::from(const } Expr CXXRewrittenBinaryOperator::lhs(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } BinaryOperatorKind CXXRewrittenBinaryOperator::opcode(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } std::string_view CXXRewrittenBinaryOperator::opcode_string(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } BinaryOperatorKind CXXRewrittenBinaryOperator::operator_(void) const { - return static_cast(impl->reader.getVal91()); + return static_cast(impl->reader.getVal92()); } Token CXXRewrittenBinaryOperator::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Expr CXXRewrittenBinaryOperator::rhs(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CXXRewrittenBinaryOperator::semantic_form(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool CXXRewrittenBinaryOperator::is_assignment_operation(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool CXXRewrittenBinaryOperator::is_comparison_operation(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool CXXRewrittenBinaryOperator::is_reversed(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXScalarValueInitExpr.cpp b/lib/AST/CXXScalarValueInitExpr.cpp index 9d8345439..0812ea35c 100644 --- a/lib/AST/CXXScalarValueInitExpr.cpp +++ b/lib/AST/CXXScalarValueInitExpr.cpp @@ -183,7 +183,7 @@ std::optional CXXScalarValueInitExpr::from(const TokenCo } Token CXXScalarValueInitExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXStdInitializerListExpr.cpp b/lib/AST/CXXStdInitializerListExpr.cpp index 39f01a4a2..2c74b7055 100644 --- a/lib/AST/CXXStdInitializerListExpr.cpp +++ b/lib/AST/CXXStdInitializerListExpr.cpp @@ -183,7 +183,7 @@ std::optional CXXStdInitializerListExpr::from(const T } Expr CXXStdInitializerListExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/CXXThisExpr.cpp b/lib/AST/CXXThisExpr.cpp index 076d905f5..03a78d930 100644 --- a/lib/AST/CXXThisExpr.cpp +++ b/lib/AST/CXXThisExpr.cpp @@ -183,11 +183,11 @@ std::optional CXXThisExpr::from(const TokenContext &t) { } Token CXXThisExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } bool CXXThisExpr::is_implicit(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXThrowExpr.cpp b/lib/AST/CXXThrowExpr.cpp index 56a26cb3d..d56551228 100644 --- a/lib/AST/CXXThrowExpr.cpp +++ b/lib/AST/CXXThrowExpr.cpp @@ -184,7 +184,7 @@ std::optional CXXThrowExpr::from(const TokenContext &t) { std::optional CXXThrowExpr::sub_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -196,11 +196,11 @@ std::optional CXXThrowExpr::sub_expression(void) const { } Token CXXThrowExpr::throw_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } bool CXXThrowExpr::is_thrown_variable_in_scope(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXTryStmt.cpp b/lib/AST/CXXTryStmt.cpp index 49d5f04e3..7c6628449 100644 --- a/lib/AST/CXXTryStmt.cpp +++ b/lib/AST/CXXTryStmt.cpp @@ -183,20 +183,20 @@ std::optional CXXTryStmt::from(const TokenContext &t) { } CompoundStmt CXXTryStmt::try_block(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token CXXTryStmt::try_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } unsigned CXXTryStmt::num_handlers(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional CXXTryStmt::nth_handler(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -210,12 +210,12 @@ std::optional CXXTryStmt::nth_handler(unsigned n) const { } gap::generator CXXTryStmt::handlers(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = CXXCatchStmt::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = CXXCatchStmt::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/CXXTypeidExpr.cpp b/lib/AST/CXXTypeidExpr.cpp index e7b6a8feb..778ed94a3 100644 --- a/lib/AST/CXXTypeidExpr.cpp +++ b/lib/AST/CXXTypeidExpr.cpp @@ -185,7 +185,7 @@ std::optional CXXTypeidExpr::from(const TokenContext &t) { std::optional CXXTypeidExpr::expression_operand(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -198,7 +198,7 @@ std::optional CXXTypeidExpr::expression_operand(void) const { std::optional CXXTypeidExpr::type_operand(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -211,7 +211,7 @@ std::optional CXXTypeidExpr::type_operand(void) const { std::optional CXXTypeidExpr::type_operand_source_info(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -223,20 +223,20 @@ std::optional CXXTypeidExpr::type_operand_source_info(void) const { } std::optional CXXTypeidExpr::is_most_derived(void) const { - if (!impl->reader.getVal85()) { + if (!impl->reader.getVal86()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal84()); + return static_cast(impl->reader.getVal85()); } return std::nullopt; } bool CXXTypeidExpr::is_potentially_evaluated(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool CXXTypeidExpr::is_type_operand(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXUnresolvedConstructExpr.cpp b/lib/AST/CXXUnresolvedConstructExpr.cpp index 65df9b7cd..f006eed6a 100644 --- a/lib/AST/CXXUnresolvedConstructExpr.cpp +++ b/lib/AST/CXXUnresolvedConstructExpr.cpp @@ -184,11 +184,11 @@ std::optional CXXUnresolvedConstructExpr::from(const } unsigned CXXUnresolvedConstructExpr::num_arguments(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional CXXUnresolvedConstructExpr::nth_argument(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -202,12 +202,12 @@ std::optional CXXUnresolvedConstructExpr::nth_argument(unsigned n) const { } gap::generator CXXUnresolvedConstructExpr::arguments(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -216,20 +216,20 @@ gap::generator CXXUnresolvedConstructExpr::arguments(void) const & { } Token CXXUnresolvedConstructExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token CXXUnresolvedConstructExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Type CXXUnresolvedConstructExpr::type_as_written(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool CXXUnresolvedConstructExpr::is_list_initialization(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CXXUuidofExpr.cpp b/lib/AST/CXXUuidofExpr.cpp index 89294f16b..6c4361834 100644 --- a/lib/AST/CXXUuidofExpr.cpp +++ b/lib/AST/CXXUuidofExpr.cpp @@ -186,7 +186,7 @@ std::optional CXXUuidofExpr::from(const TokenContext &t) { std::optional CXXUuidofExpr::expression_operand(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -198,13 +198,13 @@ std::optional CXXUuidofExpr::expression_operand(void) const { } MSGuidDecl CXXUuidofExpr::guid_declaration(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return MSGuidDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional CXXUuidofExpr::type_operand(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -216,12 +216,12 @@ std::optional CXXUuidofExpr::type_operand(void) const { } Type CXXUuidofExpr::type_operand_source_info(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool CXXUuidofExpr::is_type_operand(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CallExpr.cpp b/lib/AST/CallExpr.cpp index 154bbaf93..f2aa087f9 100644 --- a/lib/AST/CallExpr.cpp +++ b/lib/AST/CallExpr.cpp @@ -198,11 +198,11 @@ std::optional CallExpr::from(const TokenContext &t) { } unsigned CallExpr::num_arguments(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional CallExpr::nth_argument(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -216,12 +216,12 @@ std::optional CallExpr::nth_argument(unsigned n) const { } gap::generator CallExpr::arguments(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -230,26 +230,26 @@ gap::generator CallExpr::arguments(void) const & { } CallExprADLCallKind CallExpr::adl_call_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } uint32_t CallExpr::builtin_callee(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } Type CallExpr::call_return_type(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Expr CallExpr::callee(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional CallExpr::callee_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -262,7 +262,7 @@ std::optional CallExpr::callee_declaration(void) const { std::optional CallExpr::direct_callee(void) const { if (true) { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -274,31 +274,31 @@ std::optional CallExpr::direct_callee(void) const { } Token CallExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } bool CallExpr::has_stored_fp_features(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool CallExpr::has_unused_result_attribute(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool CallExpr::is_builtin_assume_false(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool CallExpr::is_call_to_std_move(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool CallExpr::is_unevaluated_builtin_call(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool CallExpr::uses_adl(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CapturedDecl.cpp b/lib/AST/CapturedDecl.cpp index c2fa0528c..361ca7408 100644 --- a/lib/AST/CapturedDecl.cpp +++ b/lib/AST/CapturedDecl.cpp @@ -212,24 +212,24 @@ std::optional CapturedDecl::from(const TokenContext &t) { } ImplicitParamDecl CapturedDecl::context_parameter(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return ImplicitParamDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } uint32_t CapturedDecl::context_parameter_position(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } bool CapturedDecl::is_nothrow(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } unsigned CapturedDecl::num_parameters(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional CapturedDecl::nth_parameter(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -243,12 +243,12 @@ std::optional CapturedDecl::nth_parameter(unsigned n) const { } gap::generator CapturedDecl::parameters(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->DeclFor(ep, v)) { - if (auto e = ImplicitParamDecl::from_base(std::move(d43))) { + if (auto d44 = ep->DeclFor(ep, v)) { + if (auto e = ImplicitParamDecl::from_base(std::move(d44))) { co_yield std::move(*e); } } diff --git a/lib/AST/CapturedStmt.cpp b/lib/AST/CapturedStmt.cpp index 26756785a..9ba556f5c 100644 --- a/lib/AST/CapturedStmt.cpp +++ b/lib/AST/CapturedStmt.cpp @@ -183,21 +183,21 @@ std::optional CapturedStmt::from(const TokenContext &t) { } CapturedDecl CapturedStmt::captured_declaration(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return CapturedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } RecordDecl CapturedStmt::captured_record_declaration(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return RecordDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } CapturedRegionKind CapturedStmt::captured_region_kind(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } Stmt CapturedStmt::captured_statement(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/CaseStmt.cpp b/lib/AST/CaseStmt.cpp index aa038b267..53802014d 100644 --- a/lib/AST/CaseStmt.cpp +++ b/lib/AST/CaseStmt.cpp @@ -183,25 +183,25 @@ std::optional CaseStmt::from(const TokenContext &t) { } bool CaseStmt::case_statement_is_gnu_range(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } Token CaseStmt::case_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } Token CaseStmt::ellipsis_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal17()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal18()); } Expr CaseStmt::lhs(void) const { - RawEntityId eid = impl->reader.getVal18(); + RawEntityId eid = impl->reader.getVal19(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional CaseStmt::rhs(void) const { if (true) { - RawEntityId eid = impl->reader.getVal19(); + RawEntityId eid = impl->reader.getVal20(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/CastExpr.cpp b/lib/AST/CastExpr.cpp index ce0c32b65..042c208f4 100644 --- a/lib/AST/CastExpr.cpp +++ b/lib/AST/CastExpr.cpp @@ -213,21 +213,21 @@ std::optional CastExpr::from(const TokenContext &t) { } bool CastExpr::changes_volatile_qualification(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } CastKind CastExpr::cast_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } std::string_view CastExpr::cast_kind_name(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } std::optional CastExpr::conversion_function(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -239,18 +239,18 @@ std::optional CastExpr::conversion_function(void) const { } Expr CastExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CastExpr::sub_expression_as_written(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional CastExpr::target_union_field(void) const { if (true) { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -262,7 +262,7 @@ std::optional CastExpr::target_union_field(void) const { } bool CastExpr::has_stored_fp_features(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CharacterLiteral.cpp b/lib/AST/CharacterLiteral.cpp index f0a11d083..a94d3e20b 100644 --- a/lib/AST/CharacterLiteral.cpp +++ b/lib/AST/CharacterLiteral.cpp @@ -183,15 +183,15 @@ std::optional CharacterLiteral::from(const TokenContext &t) { } CharacterLiteralKind CharacterLiteral::literal_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } Token CharacterLiteral::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } uint32_t CharacterLiteral::value(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ChooseExpr.cpp b/lib/AST/ChooseExpr.cpp index 8d68865cd..475ffe92e 100644 --- a/lib/AST/ChooseExpr.cpp +++ b/lib/AST/ChooseExpr.cpp @@ -183,39 +183,39 @@ std::optional ChooseExpr::from(const TokenContext &t) { } Token ChooseExpr::builtin_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Expr ChooseExpr::chosen_sub_expression(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ChooseExpr::condition(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ChooseExpr::lhs(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ChooseExpr::rhs(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token ChooseExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } bool ChooseExpr::is_condition_dependent(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool ChooseExpr::is_condition_true(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ClassTemplateDecl.cpp b/lib/AST/ClassTemplateDecl.cpp index fdc8f55cb..6e2c00da7 100644 --- a/lib/AST/ClassTemplateDecl.cpp +++ b/lib/AST/ClassTemplateDecl.cpp @@ -213,7 +213,7 @@ std::optional ClassTemplateDecl::from(const TokenContext &t) } bool ClassTemplateDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ClassTemplatePartialSpecializationDecl.cpp b/lib/AST/ClassTemplatePartialSpecializationDecl.cpp index f226e9250..bc19f623b 100644 --- a/lib/AST/ClassTemplatePartialSpecializationDecl.cpp +++ b/lib/AST/ClassTemplatePartialSpecializationDecl.cpp @@ -219,17 +219,17 @@ std::optional ClassTemplatePartialSpecia } Type ClassTemplatePartialSpecializationDecl::injected_specialization_type(void) const { - RawEntityId eid = impl->reader.getVal344(); + RawEntityId eid = impl->reader.getVal345(); return Type(impl->ep->TypeFor(impl->ep, eid)); } TemplateParameterList ClassTemplatePartialSpecializationDecl::template_parameters(void) const { - RawEntityId eid = impl->reader.getVal345(); + RawEntityId eid = impl->reader.getVal346(); return TemplateParameterList(impl->ep->TemplateParameterListFor(impl->ep, eid)); } bool ClassTemplatePartialSpecializationDecl::has_associated_constraints(void) const { - return impl->reader.getVal346(); + return impl->reader.getVal347(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ClassTemplateSpecializationDecl.cpp b/lib/AST/ClassTemplateSpecializationDecl.cpp index 44b8537a0..ee9f51b00 100644 --- a/lib/AST/ClassTemplateSpecializationDecl.cpp +++ b/lib/AST/ClassTemplateSpecializationDecl.cpp @@ -221,24 +221,24 @@ std::optional ClassTemplateSpecializationDecl:: } Token ClassTemplateSpecializationDecl::extern_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal157()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal158()); } TemplateSpecializationKind ClassTemplateSpecializationDecl::specialization_kind(void) const { - return static_cast(impl->reader.getVal118()); + return static_cast(impl->reader.getVal119()); } ClassTemplateDecl ClassTemplateSpecializationDecl::specialized_template(void) const { - RawEntityId eid = impl->reader.getVal170(); + RawEntityId eid = impl->reader.getVal171(); return ClassTemplateDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } unsigned ClassTemplateSpecializationDecl::num_template_arguments(void) const { - return impl->reader.getVal340().size(); + return impl->reader.getVal341().size(); } std::optional ClassTemplateSpecializationDecl::nth_template_argument(unsigned n) const { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); if (n >= list.size()) { return std::nullopt; } @@ -252,31 +252,31 @@ std::optional ClassTemplateSpecializationDecl::nth_template_ar } gap::generator ClassTemplateSpecializationDecl::template_arguments(void) const & { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d340 = ep->TemplateArgumentFor(ep, v)) { - co_yield TemplateArgument(std::move(d340)); + if (auto d341 = ep->TemplateArgumentFor(ep, v)) { + co_yield TemplateArgument(std::move(d341)); } } co_return; } Token ClassTemplateSpecializationDecl::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal171()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal172()); } bool ClassTemplateSpecializationDecl::is_class_scope_explicit_specialization(void) const { - return impl->reader.getVal341(); + return impl->reader.getVal342(); } bool ClassTemplateSpecializationDecl::is_explicit_instantiation_or_specialization(void) const { - return impl->reader.getVal342(); + return impl->reader.getVal343(); } bool ClassTemplateSpecializationDecl::is_explicit_specialization(void) const { - return impl->reader.getVal343(); + return impl->reader.getVal344(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CoawaitExpr.cpp b/lib/AST/CoawaitExpr.cpp index 4edc5acb1..237f1bdcb 100644 --- a/lib/AST/CoawaitExpr.cpp +++ b/lib/AST/CoawaitExpr.cpp @@ -184,7 +184,7 @@ std::optional CoawaitExpr::from(const TokenContext &t) { } bool CoawaitExpr::is_implicit(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CompoundAssignOperator.cpp b/lib/AST/CompoundAssignOperator.cpp index fd61985b9..a4e6066e3 100644 --- a/lib/AST/CompoundAssignOperator.cpp +++ b/lib/AST/CompoundAssignOperator.cpp @@ -185,12 +185,12 @@ std::optional CompoundAssignOperator::from(const TokenCo } Type CompoundAssignOperator::computation_lhs_type(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Type CompoundAssignOperator::computation_result_type(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Type(impl->ep->TypeFor(impl->ep, eid)); } diff --git a/lib/AST/CompoundLiteralExpr.cpp b/lib/AST/CompoundLiteralExpr.cpp index fdb6f946f..5ef64d7ae 100644 --- a/lib/AST/CompoundLiteralExpr.cpp +++ b/lib/AST/CompoundLiteralExpr.cpp @@ -183,16 +183,16 @@ std::optional CompoundLiteralExpr::from(const TokenContext } Expr CompoundLiteralExpr::initializer(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token CompoundLiteralExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } bool CompoundLiteralExpr::is_file_scope(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CompoundStmt.cpp b/lib/AST/CompoundStmt.cpp index fec3f6b70..afde5c0fd 100644 --- a/lib/AST/CompoundStmt.cpp +++ b/lib/AST/CompoundStmt.cpp @@ -181,16 +181,16 @@ std::optional CompoundStmt::from(const TokenContext &t) { } Token CompoundStmt::left_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } Token CompoundStmt::right_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } std::optional CompoundStmt::statement_expression_result(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -202,11 +202,11 @@ std::optional CompoundStmt::statement_expression_result(void) const { } bool CompoundStmt::has_stored_fp_features(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } uint32_t CompoundStmt::size(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ConceptDecl.cpp b/lib/AST/ConceptDecl.cpp index f25399d01..f70c81032 100644 --- a/lib/AST/ConceptDecl.cpp +++ b/lib/AST/ConceptDecl.cpp @@ -213,12 +213,12 @@ std::optional ConceptDecl::from(const TokenContext &t) { } Expr ConceptDecl::constraint_expression(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool ConceptDecl::is_type_concept(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ConceptSpecializationExpr.cpp b/lib/AST/ConceptSpecializationExpr.cpp index b29c1efd0..1dc9d795f 100644 --- a/lib/AST/ConceptSpecializationExpr.cpp +++ b/lib/AST/ConceptSpecializationExpr.cpp @@ -187,30 +187,30 @@ std::optional ConceptSpecializationExpr::from(const T } Token ConceptSpecializationExpr::concept_name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } NamedDecl ConceptSpecializationExpr::found_declaration(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return NamedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ConceptDecl ConceptSpecializationExpr::named_concept(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return ConceptDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ImplicitConceptSpecializationDecl ConceptSpecializationExpr::specialization_declaration(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return ImplicitConceptSpecializationDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } unsigned ConceptSpecializationExpr::num_template_arguments(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional ConceptSpecializationExpr::nth_template_argument(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -224,23 +224,23 @@ std::optional ConceptSpecializationExpr::nth_template_argument } gap::generator ConceptSpecializationExpr::template_arguments(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->TemplateArgumentFor(ep, v)) { - co_yield TemplateArgument(std::move(d15)); + if (auto d16 = ep->TemplateArgumentFor(ep, v)) { + co_yield TemplateArgument(std::move(d16)); } } co_return; } Token ConceptSpecializationExpr::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } bool ConceptSpecializationExpr::has_explicit_template_arguments(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ConditionalOperator.cpp b/lib/AST/ConditionalOperator.cpp index 3f843e0bc..784b56fc3 100644 --- a/lib/AST/ConditionalOperator.cpp +++ b/lib/AST/ConditionalOperator.cpp @@ -184,12 +184,12 @@ std::optional ConditionalOperator::from(const TokenContext } Expr ConditionalOperator::lhs(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ConditionalOperator::rhs(void) const { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ConstantExpr.cpp b/lib/AST/ConstantExpr.cpp index 405d25fa2..f04143fa8 100644 --- a/lib/AST/ConstantExpr.cpp +++ b/lib/AST/ConstantExpr.cpp @@ -184,15 +184,15 @@ std::optional ConstantExpr::from(const TokenContext &t) { } ConstantResultStorageKind ConstantExpr::result_storage_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } bool ConstantExpr::has_ap_value_result(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool ConstantExpr::is_immediate_invocation(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ConstructorUsingShadowDecl.cpp b/lib/AST/ConstructorUsingShadowDecl.cpp index a9c59b9cd..05d3a857f 100644 --- a/lib/AST/ConstructorUsingShadowDecl.cpp +++ b/lib/AST/ConstructorUsingShadowDecl.cpp @@ -213,17 +213,17 @@ std::optional ConstructorUsingShadowDecl::from(const } bool ConstructorUsingShadowDecl::constructs_virtual_base(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } CXXRecordDecl ConstructorUsingShadowDecl::constructed_base_class(void) const { - RawEntityId eid = impl->reader.getVal58(); + RawEntityId eid = impl->reader.getVal59(); return CXXRecordDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional ConstructorUsingShadowDecl::constructed_base_class_shadow_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -235,13 +235,13 @@ std::optional ConstructorUsingShadowDecl::constructe } CXXRecordDecl ConstructorUsingShadowDecl::nominated_base_class(void) const { - RawEntityId eid = impl->reader.getVal60(); + RawEntityId eid = impl->reader.getVal61(); return CXXRecordDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional ConstructorUsingShadowDecl::nominated_base_class_shadow_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal70(); + RawEntityId eid = impl->reader.getVal71(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/ContinueStmt.cpp b/lib/AST/ContinueStmt.cpp index c36811cab..65e039600 100644 --- a/lib/AST/ContinueStmt.cpp +++ b/lib/AST/ContinueStmt.cpp @@ -181,7 +181,7 @@ std::optional ContinueStmt::from(const TokenContext &t) { } Token ContinueStmt::continue_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ConvertVectorExpr.cpp b/lib/AST/ConvertVectorExpr.cpp index b7b9b1086..bdfa9bf56 100644 --- a/lib/AST/ConvertVectorExpr.cpp +++ b/lib/AST/ConvertVectorExpr.cpp @@ -183,15 +183,15 @@ std::optional ConvertVectorExpr::from(const TokenContext &t) } Token ConvertVectorExpr::builtin_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token ConvertVectorExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Expr ConvertVectorExpr::src_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/CoreturnStmt.cpp b/lib/AST/CoreturnStmt.cpp index 16114c533..53ceddaee 100644 --- a/lib/AST/CoreturnStmt.cpp +++ b/lib/AST/CoreturnStmt.cpp @@ -182,12 +182,12 @@ std::optional CoreturnStmt::from(const TokenContext &t) { } Token CoreturnStmt::keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } std::optional CoreturnStmt::operand(void) const { if (true) { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -199,12 +199,12 @@ std::optional CoreturnStmt::operand(void) const { } Expr CoreturnStmt::promise_call(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool CoreturnStmt::is_implicit(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CoroutineBodyStmt.cpp b/lib/AST/CoroutineBodyStmt.cpp index 9f0d1a22d..e022c117d 100644 --- a/lib/AST/CoroutineBodyStmt.cpp +++ b/lib/AST/CoroutineBodyStmt.cpp @@ -184,58 +184,58 @@ std::optional CoroutineBodyStmt::from(const TokenContext &t) } gap::generator CoroutineBodyStmt::children_excl_body(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - co_yield Stmt(std::move(d15)); + if (auto d16 = ep->StmtFor(ep, v)) { + co_yield Stmt(std::move(d16)); } } co_return; } Expr CoroutineBodyStmt::allocate(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } CompoundStmt CoroutineBodyStmt::body(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CoroutineBodyStmt::deallocate(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Stmt CoroutineBodyStmt::exception_handler(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Stmt CoroutineBodyStmt::fallthrough_handler(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Stmt CoroutineBodyStmt::final_suspend_statement(void) const { - RawEntityId eid = impl->reader.getVal17(); + RawEntityId eid = impl->reader.getVal18(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Stmt CoroutineBodyStmt::initializer_suspend_statement(void) const { - RawEntityId eid = impl->reader.getVal18(); + RawEntityId eid = impl->reader.getVal19(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } unsigned CoroutineBodyStmt::num_parameter_moves(void) const { - return impl->reader.getVal27().size(); + return impl->reader.getVal28().size(); } std::optional CoroutineBodyStmt::nth_parameter_move(unsigned n) const { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); if (n >= list.size()) { return std::nullopt; } @@ -249,30 +249,30 @@ std::optional CoroutineBodyStmt::nth_parameter_move(unsigned n) const { } gap::generator CoroutineBodyStmt::parameter_moves(void) const & { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d27 = ep->StmtFor(ep, v)) { - co_yield Stmt(std::move(d27)); + if (auto d28 = ep->StmtFor(ep, v)) { + co_yield Stmt(std::move(d28)); } } co_return; } VarDecl CoroutineBodyStmt::promise_declaration(void) const { - RawEntityId eid = impl->reader.getVal19(); + RawEntityId eid = impl->reader.getVal20(); return VarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Stmt CoroutineBodyStmt::promise_declaration_statement(void) const { - RawEntityId eid = impl->reader.getVal20(); + RawEntityId eid = impl->reader.getVal21(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } std::optional CoroutineBodyStmt::result_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal21(); + RawEntityId eid = impl->reader.getVal22(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -284,13 +284,13 @@ std::optional CoroutineBodyStmt::result_declaration(void) const { } Stmt CoroutineBodyStmt::return_statement(void) const { - RawEntityId eid = impl->reader.getVal22(); + RawEntityId eid = impl->reader.getVal23(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } std::optional CoroutineBodyStmt::return_statement_on_alloc_failure(void) const { if (true) { - RawEntityId eid = impl->reader.getVal31(); + RawEntityId eid = impl->reader.getVal32(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -302,17 +302,17 @@ std::optional CoroutineBodyStmt::return_statement_on_alloc_failure(void) c } Expr CoroutineBodyStmt::return_value(void) const { - RawEntityId eid = impl->reader.getVal32(); + RawEntityId eid = impl->reader.getVal33(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CoroutineBodyStmt::return_value_initializer(void) const { - RawEntityId eid = impl->reader.getVal33(); + RawEntityId eid = impl->reader.getVal34(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool CoroutineBodyStmt::has_dependent_promise_type(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } #pragma GCC diagnostic pop diff --git a/lib/AST/CoroutineSuspendExpr.cpp b/lib/AST/CoroutineSuspendExpr.cpp index b6f6e587f..9a064e77d 100644 --- a/lib/AST/CoroutineSuspendExpr.cpp +++ b/lib/AST/CoroutineSuspendExpr.cpp @@ -188,36 +188,36 @@ std::optional CoroutineSuspendExpr::from(const TokenContex } Expr CoroutineSuspendExpr::common_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token CoroutineSuspendExpr::keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } OpaqueValueExpr CoroutineSuspendExpr::opaque_value(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return OpaqueValueExpr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CoroutineSuspendExpr::operand(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CoroutineSuspendExpr::ready_expression(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CoroutineSuspendExpr::resume_expression(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr CoroutineSuspendExpr::suspend_expression(void) const { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp index dd51704ee..79fdff253 100644 --- a/lib/AST/Decl.cpp +++ b/lib/AST/Decl.cpp @@ -43,8 +43,54 @@ std::optional Decl::parent_statement(void) const { return std::nullopt; } +static std::optional IrFromRaw( + const EntityProvider::Ptr &ep, RawEntityId raw) { + if (raw == kInvalidEntityId) return std::nullopt; + auto vid = EntityId(raw).Unpack(); + if (auto *p = std::get_if(&vid)) { + if (auto ptr = ep->IRFunctionFor(ep, raw)) { + return IRFunction(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = ep->IRBlockFor(ep, raw)) { + return IRBlock(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = ep->IRInstructionFor(ep, raw)) { + return IRInstruction(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = ep->IRObjectFor(ep, raw)) { + return IRObject(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = ep->IRStructureFor(ep, raw)) { + return IRStructure(std::move(ptr)); + } + } + return std::nullopt; +} + +std::optional Decl::ir(void) const { + // Try this specific declaration. + if (auto result = IrFromRaw(impl->ep, impl->reader.getVal2())) { + return result; + } + + // If this declaration has no IR, try redeclarations (e.g., a forward + // declaration of a function whose definition has IR). + for (Decl redecl : redeclarations()) { + if (auto result = IrFromRaw(redecl.impl->ep, + redecl.impl->reader.getVal2())) { + return result; + } + } + + return std::nullopt; +} + bool Decl::is_definition(void) const { - return impl->reader.getVal2(); + return impl->reader.getVal3(); } std::shared_ptr Decl::entity_provider_of(const Index &index_) { @@ -205,11 +251,11 @@ std::optional Decl::from(const TokenContext &t) { } unsigned Decl::num_attributes(void) const { - return impl->reader.getVal3().size(); + return impl->reader.getVal4().size(); } std::optional Decl::nth_attribute(unsigned n) const { - auto list = impl->reader.getVal3(); + auto list = impl->reader.getVal4(); if (n >= list.size()) { return std::nullopt; } @@ -223,24 +269,24 @@ std::optional Decl::nth_attribute(unsigned n) const { } gap::generator Decl::attributes(void) const & { - auto list = impl->reader.getVal3(); + auto list = impl->reader.getVal4(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d3 = ep->AttrFor(ep, v)) { - co_yield Attr(std::move(d3)); + if (auto d4 = ep->AttrFor(ep, v)) { + co_yield Attr(std::move(d4)); } } co_return; } AvailabilityResult Decl::availability(void) const { - return static_cast(impl->reader.getVal4()); + return static_cast(impl->reader.getVal5()); } std::optional Decl::defining_attribute(void) const { if (true) { - RawEntityId eid = impl->reader.getVal5(); + RawEntityId eid = impl->reader.getVal6(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -253,7 +299,7 @@ std::optional Decl::defining_attribute(void) const { std::optional Decl::external_source_symbol_attribute(void) const { if (true) { - RawEntityId eid = impl->reader.getVal6(); + RawEntityId eid = impl->reader.getVal7(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -265,25 +311,25 @@ std::optional Decl::external_source_symbol_attribute(v } DeclFriendObjectKind Decl::friend_object_kind(void) const { - return static_cast(impl->reader.getVal7()); + return static_cast(impl->reader.getVal8()); } std::optional Decl::max_alignment(void) const { - if (!impl->reader.getVal9()) { + if (!impl->reader.getVal10()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal8()); + return static_cast(impl->reader.getVal9()); } return std::nullopt; } DeclModuleOwnershipKind Decl::module_ownership_kind(void) const { - return static_cast(impl->reader.getVal10()); + return static_cast(impl->reader.getVal11()); } std::optional Decl::non_closure_context(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -295,111 +341,111 @@ std::optional Decl::non_closure_context(void) const { } uint32_t Decl::owning_module_id(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } uint32_t Decl::template_depth(void) const { - return impl->reader.getVal13(); + return impl->reader.getVal14(); } bool Decl::is_deprecated(void) const { - return impl->reader.getVal14(); + return impl->reader.getVal15(); } bool Decl::is_file_context_declaration(void) const { - return impl->reader.getVal15(); + return impl->reader.getVal16(); } bool Decl::is_function_or_function_template(void) const { - return impl->reader.getVal16(); + return impl->reader.getVal17(); } bool Decl::is_implicit(void) const { - return impl->reader.getVal17(); + return impl->reader.getVal18(); } bool Decl::is_in_anonymous_namespace(void) const { - return impl->reader.getVal18(); + return impl->reader.getVal19(); } bool Decl::is_in_another_module_unit(void) const { - return impl->reader.getVal19(); + return impl->reader.getVal20(); } bool Decl::is_in_export_declaration_context(void) const { - return impl->reader.getVal20(); + return impl->reader.getVal21(); } bool Decl::is_in_std_namespace(void) const { - return impl->reader.getVal21(); + return impl->reader.getVal22(); } bool Decl::is_invisible_outside_the_owning_module(void) const { - return impl->reader.getVal22(); + return impl->reader.getVal23(); } bool Decl::is_local_extern_declaration(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } bool Decl::is_module_private(void) const { - return impl->reader.getVal24(); + return impl->reader.getVal25(); } bool Decl::is_out_of_line(void) const { - return impl->reader.getVal25(); + return impl->reader.getVal26(); } bool Decl::is_parameter_pack(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } bool Decl::is_template_declaration(void) const { - return impl->reader.getVal27(); + return impl->reader.getVal28(); } bool Decl::is_template_parameter(void) const { - return impl->reader.getVal28(); + return impl->reader.getVal29(); } bool Decl::is_template_parameter_pack(void) const { - return impl->reader.getVal29(); + return impl->reader.getVal30(); } bool Decl::is_templated(void) const { - return impl->reader.getVal30(); + return impl->reader.getVal31(); } bool Decl::is_top_level_declaration_in_obj_c_container(void) const { - return impl->reader.getVal31(); + return impl->reader.getVal32(); } bool Decl::is_unavailable(void) const { - return impl->reader.getVal32(); + return impl->reader.getVal33(); } bool Decl::is_unconditionally_visible(void) const { - return impl->reader.getVal33(); + return impl->reader.getVal34(); } bool Decl::is_weak_imported(void) const { - return impl->reader.getVal34(); + return impl->reader.getVal35(); } DeclKind Decl::kind(void) const { - return static_cast(impl->reader.getVal35()); + return static_cast(impl->reader.getVal36()); } DeclCategory Decl::category(void) const { - return static_cast(impl->reader.getVal36()); + return static_cast(impl->reader.getVal37()); } Token Decl::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal37()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); } TokenRange Decl::tokens(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal38(), impl->reader.getVal39()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal39(), impl->reader.getVal40()); } #pragma GCC diagnostic pop diff --git a/lib/AST/DeclRefExpr.cpp b/lib/AST/DeclRefExpr.cpp index 679785d2d..21d4e7734 100644 --- a/lib/AST/DeclRefExpr.cpp +++ b/lib/AST/DeclRefExpr.cpp @@ -184,48 +184,48 @@ std::optional DeclRefExpr::from(const TokenContext &t) { } ValueDecl DeclRefExpr::declaration(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return ValueDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token DeclRefExpr::l_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Token DeclRefExpr::r_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token DeclRefExpr::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } bool DeclRefExpr::had_multiple_candidates(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool DeclRefExpr::has_explicit_template_arguments(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool DeclRefExpr::has_qualifier(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool DeclRefExpr::is_captured_by_copy_in_lambda_with_explicit_object_parameter(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool DeclRefExpr::is_immediate_escalating(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } NonOdrUseReason DeclRefExpr::is_non_odr_use(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } bool DeclRefExpr::refers_to_enclosing_variable_or_capture(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } #pragma GCC diagnostic pop diff --git a/lib/AST/DeclStmt.cpp b/lib/AST/DeclStmt.cpp index 28502d28f..9b0a31db5 100644 --- a/lib/AST/DeclStmt.cpp +++ b/lib/AST/DeclStmt.cpp @@ -181,11 +181,11 @@ std::optional DeclStmt::from(const TokenContext &t) { } unsigned DeclStmt::num_declarations(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional DeclStmt::nth_declaration(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -199,12 +199,12 @@ std::optional DeclStmt::nth_declaration(unsigned n) const { } gap::generator DeclStmt::declarations(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->DeclFor(ep, v)) { - co_yield Decl(std::move(d15)); + if (auto d16 = ep->DeclFor(ep, v)) { + co_yield Decl(std::move(d16)); } } co_return; @@ -212,7 +212,7 @@ gap::generator DeclStmt::declarations(void) const & { std::optional DeclStmt::single_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -224,7 +224,7 @@ std::optional DeclStmt::single_declaration(void) const { } bool DeclStmt::is_single_declaration(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } #pragma GCC diagnostic pop diff --git a/lib/AST/DeclaratorDecl.cpp b/lib/AST/DeclaratorDecl.cpp index 26a5d3ee6..7ea30266c 100644 --- a/lib/AST/DeclaratorDecl.cpp +++ b/lib/AST/DeclaratorDecl.cpp @@ -266,16 +266,16 @@ std::optional DeclaratorDecl::from(const TokenContext &t) { } Token DeclaratorDecl::first_inner_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal51()); } Token DeclaratorDecl::first_outer_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } std::optional DeclaratorDecl::trailing_requires_clause(void) const { if (true) { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -287,19 +287,19 @@ std::optional DeclaratorDecl::trailing_requires_clause(void) const { } Token DeclaratorDecl::type_spec_end_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal61()); } Token DeclaratorDecl::type_spec_start_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal70()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal71()); } unsigned DeclaratorDecl::num_template_parameter_lists(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional DeclaratorDecl::nth_template_parameter_list(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -313,12 +313,12 @@ std::optional DeclaratorDecl::nth_template_parameter_list } gap::generator DeclaratorDecl::template_parameter_lists(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->TemplateParameterListFor(ep, v)) { - co_yield TemplateParameterList(std::move(d43)); + if (auto d44 = ep->TemplateParameterListFor(ep, v)) { + co_yield TemplateParameterList(std::move(d44)); } } co_return; diff --git a/lib/AST/DecompositionDecl.cpp b/lib/AST/DecompositionDecl.cpp index 34e5a63a0..ff0bc024d 100644 --- a/lib/AST/DecompositionDecl.cpp +++ b/lib/AST/DecompositionDecl.cpp @@ -215,11 +215,11 @@ std::optional DecompositionDecl::from(const TokenContext &t) } unsigned DecompositionDecl::num_bindings(void) const { - return impl->reader.getVal44().size(); + return impl->reader.getVal45().size(); } std::optional DecompositionDecl::nth_binding(unsigned n) const { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); if (n >= list.size()) { return std::nullopt; } @@ -233,12 +233,12 @@ std::optional DecompositionDecl::nth_binding(unsigned n) const { } gap::generator DecompositionDecl::bindings(void) const & { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d44 = ep->DeclFor(ep, v)) { - if (auto e = BindingDecl::from_base(std::move(d44))) { + if (auto d45 = ep->DeclFor(ep, v)) { + if (auto e = BindingDecl::from_base(std::move(d45))) { co_yield std::move(*e); } } diff --git a/lib/AST/DefaultStmt.cpp b/lib/AST/DefaultStmt.cpp index 5d06d0a33..17f233094 100644 --- a/lib/AST/DefaultStmt.cpp +++ b/lib/AST/DefaultStmt.cpp @@ -182,7 +182,7 @@ std::optional DefaultStmt::from(const TokenContext &t) { } Token DefaultStmt::default_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } #pragma GCC diagnostic pop diff --git a/lib/AST/DependentCoawaitExpr.cpp b/lib/AST/DependentCoawaitExpr.cpp index 7d8a95308..eab1695ad 100644 --- a/lib/AST/DependentCoawaitExpr.cpp +++ b/lib/AST/DependentCoawaitExpr.cpp @@ -184,16 +184,16 @@ std::optional DependentCoawaitExpr::from(const TokenContex } Token DependentCoawaitExpr::keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Expr DependentCoawaitExpr::operand(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } UnresolvedLookupExpr DependentCoawaitExpr::operator_coawait_lookup(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return UnresolvedLookupExpr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/DependentScopeDeclRefExpr.cpp b/lib/AST/DependentScopeDeclRefExpr.cpp index ce24c181a..e04a7dc85 100644 --- a/lib/AST/DependentScopeDeclRefExpr.cpp +++ b/lib/AST/DependentScopeDeclRefExpr.cpp @@ -183,23 +183,23 @@ std::optional DependentScopeDeclRefExpr::from(const T } Token DependentScopeDeclRefExpr::l_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token DependentScopeDeclRefExpr::r_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Token DependentScopeDeclRefExpr::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } bool DependentScopeDeclRefExpr::has_explicit_template_arguments(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool DependentScopeDeclRefExpr::has_template_keyword(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/DesignatedInitExpr.cpp b/lib/AST/DesignatedInitExpr.cpp index 3ea0f0572..3295e9499 100644 --- a/lib/AST/DesignatedInitExpr.cpp +++ b/lib/AST/DesignatedInitExpr.cpp @@ -185,11 +185,11 @@ std::optional DesignatedInitExpr::from(const TokenContext &t } unsigned DesignatedInitExpr::num_designators(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional DesignatedInitExpr::nth_designator(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -203,48 +203,48 @@ std::optional DesignatedInitExpr::nth_designator(unsigned n) const { } gap::generator DesignatedInitExpr::designators(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->DesignatorFor(ep, v)) { - co_yield Designator(std::move(d15)); + if (auto d16 = ep->DesignatorFor(ep, v)) { + co_yield Designator(std::move(d16)); } } co_return; } TokenRange DesignatedInitExpr::designators_tokens(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal38(), impl->reader.getVal39()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal39(), impl->reader.getVal40()); } Token DesignatedInitExpr::equal_or_colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Expr DesignatedInitExpr::initializer(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool DesignatedInitExpr::is_direct_initializer(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } uint32_t DesignatedInitExpr::size(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } bool DesignatedInitExpr::uses_gnu_syntax(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } unsigned DesignatedInitExpr::num_sub_expressions(void) const { - return impl->reader.getVal27().size(); + return impl->reader.getVal28().size(); } std::optional DesignatedInitExpr::nth_sub_expression(unsigned n) const { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); if (n >= list.size()) { return std::nullopt; } @@ -258,12 +258,12 @@ std::optional DesignatedInitExpr::nth_sub_expression(unsigned n) const { } gap::generator DesignatedInitExpr::sub_expressions(void) const & { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d27 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d27))) { + if (auto d28 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d28))) { co_yield std::move(*e); } } diff --git a/lib/AST/DesignatedInitUpdateExpr.cpp b/lib/AST/DesignatedInitUpdateExpr.cpp index e23a5c535..8c138d8ec 100644 --- a/lib/AST/DesignatedInitUpdateExpr.cpp +++ b/lib/AST/DesignatedInitUpdateExpr.cpp @@ -184,12 +184,12 @@ std::optional DesignatedInitUpdateExpr::from(const Tok } Expr DesignatedInitUpdateExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } InitListExpr DesignatedInitUpdateExpr::updater(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return InitListExpr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/DoStmt.cpp b/lib/AST/DoStmt.cpp index 3ba46d7d7..21850829e 100644 --- a/lib/AST/DoStmt.cpp +++ b/lib/AST/DoStmt.cpp @@ -182,25 +182,25 @@ std::optional DoStmt::from(const TokenContext &t) { } Stmt DoStmt::body(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Expr DoStmt::condition(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token DoStmt::do_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal12()); } Token DoStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal13()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); } Token DoStmt::while_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } #pragma GCC diagnostic pop diff --git a/lib/AST/EnumConstantDecl.cpp b/lib/AST/EnumConstantDecl.cpp index 5dc6b73d7..2517fa695 100644 --- a/lib/AST/EnumConstantDecl.cpp +++ b/lib/AST/EnumConstantDecl.cpp @@ -214,7 +214,7 @@ std::optional EnumConstantDecl::from(const TokenContext &t) { std::optional EnumConstantDecl::initializer_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/EnumDecl.cpp b/lib/AST/EnumDecl.cpp index 196919964..b5f065de2 100644 --- a/lib/AST/EnumDecl.cpp +++ b/lib/AST/EnumDecl.cpp @@ -217,11 +217,11 @@ std::optional EnumDecl::from(const TokenContext &t) { } unsigned EnumDecl::num_enumerators(void) const { - return impl->reader.getVal54().size(); + return impl->reader.getVal55().size(); } std::optional EnumDecl::nth_enumerator(unsigned n) const { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); if (n >= list.size()) { return std::nullopt; } @@ -235,12 +235,12 @@ std::optional EnumDecl::nth_enumerator(unsigned n) const { } gap::generator EnumDecl::enumerators(void) const & { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d54 = ep->DeclFor(ep, v)) { - if (auto e = EnumConstantDecl::from_base(std::move(d54))) { + if (auto d55 = ep->DeclFor(ep, v)) { + if (auto e = EnumConstantDecl::from_base(std::move(d55))) { co_yield std::move(*e); } } @@ -250,7 +250,7 @@ gap::generator EnumDecl::enumerators(void) const & { std::optional EnumDecl::integer_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal70(); + RawEntityId eid = impl->reader.getVal71(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -262,12 +262,12 @@ std::optional EnumDecl::integer_type(void) const { } TokenRange EnumDecl::integer_type_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal71(), impl->reader.getVal73()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal72(), impl->reader.getVal74()); } std::optional EnumDecl::promotion_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal74(); + RawEntityId eid = impl->reader.getVal75(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -279,31 +279,31 @@ std::optional EnumDecl::promotion_type(void) const { } bool EnumDecl::is_closed(void) const { - return impl->reader.getVal91(); + return impl->reader.getVal92(); } bool EnumDecl::is_closed_flag(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool EnumDecl::is_closed_non_flag(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool EnumDecl::is_complete(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } bool EnumDecl::is_fixed(void) const { - return impl->reader.getVal95(); + return impl->reader.getVal96(); } bool EnumDecl::is_scoped(void) const { - return impl->reader.getVal96(); + return impl->reader.getVal97(); } bool EnumDecl::is_scoped_using_class_tag(void) const { - return impl->reader.getVal97(); + return impl->reader.getVal98(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ExplicitCastExpr.cpp b/lib/AST/ExplicitCastExpr.cpp index f9c10eb03..f6c41b156 100644 --- a/lib/AST/ExplicitCastExpr.cpp +++ b/lib/AST/ExplicitCastExpr.cpp @@ -210,7 +210,7 @@ std::optional ExplicitCastExpr::from(const TokenContext &t) { } Type ExplicitCastExpr::type_as_written(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Type(impl->ep->TypeFor(impl->ep, eid)); } diff --git a/lib/AST/ExportDecl.cpp b/lib/AST/ExportDecl.cpp index 8c4a3b667..18d87b6e4 100644 --- a/lib/AST/ExportDecl.cpp +++ b/lib/AST/ExportDecl.cpp @@ -211,15 +211,15 @@ std::optional ExportDecl::from(const TokenContext &t) { } Token ExportDecl::export_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token ExportDecl::r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } bool ExportDecl::has_braces(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } gap::generator ExportDecl::contained_declarations(void) const & { diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index c0738c8f2..fbcf60dce 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -555,53 +555,53 @@ std::optional Expr::from(const TokenContext &t) { } Expr Expr::ignore_casts(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_conversion_operator_single_step(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_implicit_casts(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_implicit(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_implicit_as_written(void) const { - RawEntityId eid = impl->reader.getVal17(); + RawEntityId eid = impl->reader.getVal18(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_parenthesis_base_casts(void) const { - RawEntityId eid = impl->reader.getVal18(); + RawEntityId eid = impl->reader.getVal19(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_parenthesis_casts(void) const { - RawEntityId eid = impl->reader.getVal19(); + RawEntityId eid = impl->reader.getVal20(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_parenthesis_implicit_casts(void) const { - RawEntityId eid = impl->reader.getVal20(); + RawEntityId eid = impl->reader.getVal21(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_parenthesis_l_value_casts(void) const { - RawEntityId eid = impl->reader.getVal21(); + RawEntityId eid = impl->reader.getVal22(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional Expr::ignore_parenthesis_noop_casts(void) const { if (true) { - RawEntityId eid = impl->reader.getVal22(); + RawEntityId eid = impl->reader.getVal23(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -613,30 +613,30 @@ std::optional Expr::ignore_parenthesis_noop_casts(void) const { } Expr Expr::ignore_parentheses(void) const { - RawEntityId eid = impl->reader.getVal31(); + RawEntityId eid = impl->reader.getVal32(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr Expr::ignore_unless_spelled_in_source(void) const { - RawEntityId eid = impl->reader.getVal32(); + RawEntityId eid = impl->reader.getVal33(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool Expr::contains_errors(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } bool Expr::contains_unexpanded_parameter_pack(void) const { - return impl->reader.getVal16(); + return impl->reader.getVal17(); } Token Expr::expression_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal33()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal34()); } std::optional Expr::obj_c_property(void) const { if (true) { - RawEntityId eid = impl->reader.getVal34(); + RawEntityId eid = impl->reader.getVal35(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -648,12 +648,12 @@ std::optional Expr::obj_c_property(void) const { } ExprObjectKind Expr::object_kind(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } std::optional Expr::referenced_declaration_of_callee(void) const { if (true) { - RawEntityId eid = impl->reader.getVal35(); + RawEntityId eid = impl->reader.getVal36(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -666,7 +666,7 @@ std::optional Expr::referenced_declaration_of_callee(void) const { std::optional Expr::source_bit_field(void) const { if (true) { - RawEntityId eid = impl->reader.getVal36(); + RawEntityId eid = impl->reader.getVal37(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -679,7 +679,7 @@ std::optional Expr::source_bit_field(void) const { std::optional Expr::type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal37(); + RawEntityId eid = impl->reader.getVal38(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -691,84 +691,84 @@ std::optional Expr::type(void) const { } ExprValueKind Expr::value_kind(void) const { - return static_cast(impl->reader.getVal70()); + return static_cast(impl->reader.getVal71()); } bool Expr::has_non_trivial_call(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } bool Expr::is_default_argument(void) const { - return impl->reader.getVal24(); + return impl->reader.getVal25(); } bool Expr::is_gl_value(void) const { - return impl->reader.getVal25(); + return impl->reader.getVal26(); } bool Expr::is_implicit_cxx_this(void) const { - return impl->reader.getVal58(); + return impl->reader.getVal59(); } bool Expr::is_instantiation_dependent(void) const { - return impl->reader.getVal59(); + return impl->reader.getVal60(); } bool Expr::is_l_value(void) const { - return impl->reader.getVal60(); + return impl->reader.getVal61(); } bool Expr::is_objcgc_candidate(void) const { - return impl->reader.getVal71(); + return impl->reader.getVal72(); } bool Expr::is_obj_c_self_expression(void) const { - return impl->reader.getVal72(); + return impl->reader.getVal73(); } bool Expr::is_ordinary_or_bit_field_object(void) const { - return impl->reader.getVal73(); + return impl->reader.getVal74(); } bool Expr::is_pr_value(void) const { - return impl->reader.getVal74(); + return impl->reader.getVal75(); } std::optional Expr::is_read_if_discarded_in_c_plus_plus11(void) const { - if (!impl->reader.getVal76()) { + if (!impl->reader.getVal77()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal75()); + return static_cast(impl->reader.getVal76()); } return std::nullopt; } bool Expr::is_type_dependent(void) const { - return impl->reader.getVal77(); + return impl->reader.getVal78(); } bool Expr::is_value_dependent(void) const { - return impl->reader.getVal78(); + return impl->reader.getVal79(); } bool Expr::is_x_value(void) const { - return impl->reader.getVal79(); + return impl->reader.getVal80(); } bool Expr::refers_to_bit_field(void) const { - return impl->reader.getVal80(); + return impl->reader.getVal81(); } bool Expr::refers_to_global_register_variable(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool Expr::refers_to_matrix_element(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } bool Expr::refers_to_vector_element(void) const { - return impl->reader.getVal83(); + return impl->reader.getVal84(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ExprWithCleanups.cpp b/lib/AST/ExprWithCleanups.cpp index 702f41024..c07eef04a 100644 --- a/lib/AST/ExprWithCleanups.cpp +++ b/lib/AST/ExprWithCleanups.cpp @@ -184,7 +184,7 @@ std::optional ExprWithCleanups::from(const TokenContext &t) { } bool ExprWithCleanups::cleanups_have_side_effects(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ExpressionTraitExpr.cpp b/lib/AST/ExpressionTraitExpr.cpp index 83bee505c..71bb53e7f 100644 --- a/lib/AST/ExpressionTraitExpr.cpp +++ b/lib/AST/ExpressionTraitExpr.cpp @@ -183,16 +183,16 @@ std::optional ExpressionTraitExpr::from(const TokenContext } Expr ExpressionTraitExpr::queried_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } ExpressionTrait ExpressionTraitExpr::trait(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } bool ExpressionTraitExpr::value(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ExtVectorElementExpr.cpp b/lib/AST/ExtVectorElementExpr.cpp index a543173d6..2126bc430 100644 --- a/lib/AST/ExtVectorElementExpr.cpp +++ b/lib/AST/ExtVectorElementExpr.cpp @@ -183,20 +183,20 @@ std::optional ExtVectorElementExpr::from(const TokenContex } bool ExtVectorElementExpr::contains_duplicate_elements(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } Token ExtVectorElementExpr::accessor_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Expr ExtVectorElementExpr::base(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool ExtVectorElementExpr::is_arrow(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/FieldDecl.cpp b/lib/AST/FieldDecl.cpp index 21fe1808f..7e5396e16 100644 --- a/lib/AST/FieldDecl.cpp +++ b/lib/AST/FieldDecl.cpp @@ -222,7 +222,7 @@ std::optional FieldDecl::from(const TokenContext &t) { std::optional FieldDecl::bit_width(void) const { if (true) { - RawEntityId eid = impl->reader.getVal71(); + RawEntityId eid = impl->reader.getVal72(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -235,7 +235,7 @@ std::optional FieldDecl::bit_width(void) const { std::optional FieldDecl::captured_vla_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal73(); + RawEntityId eid = impl->reader.getVal74(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -247,16 +247,16 @@ std::optional FieldDecl::captured_vla_type(void) const { } uint32_t FieldDecl::field_index(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } InClassInitStyle FieldDecl::in_class_initializer_style(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } std::optional FieldDecl::in_class_initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal74(); + RawEntityId eid = impl->reader.getVal75(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -268,50 +268,50 @@ std::optional FieldDecl::in_class_initializer(void) const { } bool FieldDecl::has_captured_vla_type(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool FieldDecl::has_in_class_initializer(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool FieldDecl::has_non_null_in_class_initializer(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool FieldDecl::is_anonymous_struct_or_union(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } bool FieldDecl::is_bit_field(void) const { - return impl->reader.getVal83(); + return impl->reader.getVal84(); } bool FieldDecl::is_mutable(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool FieldDecl::is_potentially_overlapping(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool FieldDecl::is_unnamed_bitfield(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool FieldDecl::is_zero_length_bit_field(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool FieldDecl::is_zero_size(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } std::optional FieldDecl::offset_in_bits(void) const { - if (!impl->reader.getVal89()) { + if (!impl->reader.getVal90()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal75()); + return static_cast(impl->reader.getVal76()); } return std::nullopt; } diff --git a/lib/AST/FileScopeAsmDecl.cpp b/lib/AST/FileScopeAsmDecl.cpp index acc02b92d..065420899 100644 --- a/lib/AST/FileScopeAsmDecl.cpp +++ b/lib/AST/FileScopeAsmDecl.cpp @@ -211,16 +211,16 @@ std::optional FileScopeAsmDecl::from(const TokenContext &t) { } Token FileScopeAsmDecl::assembly_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } StringLiteral FileScopeAsmDecl::assembly_string(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return StringLiteral::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token FileScopeAsmDecl::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); } #pragma GCC diagnostic pop diff --git a/lib/AST/FixedPointLiteral.cpp b/lib/AST/FixedPointLiteral.cpp index f5ad22846..9191a17f5 100644 --- a/lib/AST/FixedPointLiteral.cpp +++ b/lib/AST/FixedPointLiteral.cpp @@ -183,11 +183,11 @@ std::optional FixedPointLiteral::from(const TokenContext &t) } Token FixedPointLiteral::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } uint32_t FixedPointLiteral::scale(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } #pragma GCC diagnostic pop diff --git a/lib/AST/FloatingLiteral.cpp b/lib/AST/FloatingLiteral.cpp index 02c8a9b14..1441206dc 100644 --- a/lib/AST/FloatingLiteral.cpp +++ b/lib/AST/FloatingLiteral.cpp @@ -183,11 +183,11 @@ std::optional FloatingLiteral::from(const TokenContext &t) { } Token FloatingLiteral::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } bool FloatingLiteral::is_exact(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ForStmt.cpp b/lib/AST/ForStmt.cpp index 2937abac8..ca72ac185 100644 --- a/lib/AST/ForStmt.cpp +++ b/lib/AST/ForStmt.cpp @@ -184,13 +184,13 @@ std::optional ForStmt::from(const TokenContext &t) { } Stmt ForStmt::body(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } std::optional ForStmt::condition(void) const { if (true) { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -203,7 +203,7 @@ std::optional ForStmt::condition(void) const { std::optional ForStmt::condition_variable(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -216,7 +216,7 @@ std::optional ForStmt::condition_variable(void) const { std::optional ForStmt::condition_variable_declaration_statement(void) const { if (true) { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -228,12 +228,12 @@ std::optional ForStmt::condition_variable_declaration_statement(void) } Token ForStmt::for_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } std::optional ForStmt::increment(void) const { if (true) { - RawEntityId eid = impl->reader.getVal17(); + RawEntityId eid = impl->reader.getVal18(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -246,7 +246,7 @@ std::optional ForStmt::increment(void) const { std::optional ForStmt::initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal18(); + RawEntityId eid = impl->reader.getVal19(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -258,11 +258,11 @@ std::optional ForStmt::initializer(void) const { } Token ForStmt::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal19()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal20()); } Token ForStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal20()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal21()); } #pragma GCC diagnostic pop diff --git a/lib/AST/FriendDecl.cpp b/lib/AST/FriendDecl.cpp index 0d40d9162..23a447278 100644 --- a/lib/AST/FriendDecl.cpp +++ b/lib/AST/FriendDecl.cpp @@ -214,7 +214,7 @@ std::optional FriendDecl::from(const TokenContext &t) { std::optional FriendDecl::friend_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -226,12 +226,12 @@ std::optional FriendDecl::friend_declaration(void) const { } Token FriendDecl::friend_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } std::optional FriendDecl::friend_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -243,19 +243,19 @@ std::optional FriendDecl::friend_type(void) const { } uint32_t FriendDecl::friend_type_num_template_parameter_lists(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } bool FriendDecl::is_unsupported_friend(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } unsigned FriendDecl::num_friend_type_template_parameter_lists(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional FriendDecl::nth_friend_type_template_parameter_list(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -269,12 +269,12 @@ std::optional FriendDecl::nth_friend_type_template_parame } gap::generator FriendDecl::friend_type_template_parameter_lists(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->TemplateParameterListFor(ep, v)) { - co_yield TemplateParameterList(std::move(d43)); + if (auto d44 = ep->TemplateParameterListFor(ep, v)) { + co_yield TemplateParameterList(std::move(d44)); } } co_return; diff --git a/lib/AST/FriendTemplateDecl.cpp b/lib/AST/FriendTemplateDecl.cpp index 633055400..bb8da976e 100644 --- a/lib/AST/FriendTemplateDecl.cpp +++ b/lib/AST/FriendTemplateDecl.cpp @@ -213,25 +213,25 @@ std::optional FriendTemplateDecl::from(const TokenContext &t } NamedDecl FriendTemplateDecl::friend_declaration(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return NamedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token FriendTemplateDecl::friend_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } Type FriendTemplateDecl::friend_type(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return Type(impl->ep->TypeFor(impl->ep, eid)); } unsigned FriendTemplateDecl::num_template_parameter_lists(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional FriendTemplateDecl::nth_template_parameter_list(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -245,12 +245,12 @@ std::optional FriendTemplateDecl::nth_template_parameter_ } gap::generator FriendTemplateDecl::template_parameter_lists(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->TemplateParameterListFor(ep, v)) { - co_yield TemplateParameterList(std::move(d43)); + if (auto d44 = ep->TemplateParameterListFor(ep, v)) { + co_yield TemplateParameterList(std::move(d44)); } } co_return; diff --git a/lib/AST/FullExpr.cpp b/lib/AST/FullExpr.cpp index cc873e994..f076e19e0 100644 --- a/lib/AST/FullExpr.cpp +++ b/lib/AST/FullExpr.cpp @@ -187,7 +187,7 @@ std::optional FullExpr::from(const TokenContext &t) { } Expr FullExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/FunctionDecl.cpp b/lib/AST/FunctionDecl.cpp index 7e1747f13..90c42a84b 100644 --- a/lib/AST/FunctionDecl.cpp +++ b/lib/AST/FunctionDecl.cpp @@ -234,55 +234,55 @@ std::optional FunctionDecl::from(const TokenContext &t) { } bool FunctionDecl::body_contains_immediate_escalating_expressions(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool FunctionDecl::friend_constraint_refers_to_enclosing_template(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool FunctionDecl::uses_fp_intrin(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } std::optional FunctionDecl::does_declaration_force_externally_visible_definition(void) const { - if (!impl->reader.getVal83()) { + if (!impl->reader.getVal84()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal82()); + return static_cast(impl->reader.getVal83()); } return std::nullopt; } bool FunctionDecl::does_this_declaration_have_a_body(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } uint32_t FunctionDecl::builtin_id(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } Type FunctionDecl::call_result_type(void) const { - RawEntityId eid = impl->reader.getVal71(); + RawEntityId eid = impl->reader.getVal72(); return Type(impl->ep->TypeFor(impl->ep, eid)); } ConstexprSpecKind FunctionDecl::constexpr_kind(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } Type FunctionDecl::declared_return_type(void) const { - RawEntityId eid = impl->reader.getVal73(); + RawEntityId eid = impl->reader.getVal74(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Token FunctionDecl::default_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal74()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal75()); } std::optional FunctionDecl::described_function_template(void) const { if (true) { - RawEntityId eid = impl->reader.getVal75(); + RawEntityId eid = impl->reader.getVal76(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -294,291 +294,291 @@ std::optional FunctionDecl::described_function_template(vo } Token FunctionDecl::ellipsis_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal113()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal114()); } TokenRange FunctionDecl::exception_spec_tokens(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal114(), impl->reader.getVal115()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal115(), impl->reader.getVal116()); } ExceptionSpecificationType FunctionDecl::exception_spec_type(void) const { - return static_cast(impl->reader.getVal76()); + return static_cast(impl->reader.getVal77()); } LanguageLinkage FunctionDecl::language_linkage(void) const { - return static_cast(impl->reader.getVal77()); + return static_cast(impl->reader.getVal78()); } uint32_t FunctionDecl::memory_function_kind(void) const { - return impl->reader.getVal117(); + return impl->reader.getVal118(); } uint32_t FunctionDecl::min_required_arguments(void) const { - return impl->reader.getVal129(); + return impl->reader.getVal130(); } uint32_t FunctionDecl::min_required_explicit_arguments(void) const { - return impl->reader.getVal130(); + return impl->reader.getVal131(); } MultiVersionKind FunctionDecl::multi_version_kind(void) const { - return static_cast(impl->reader.getVal78()); + return static_cast(impl->reader.getVal79()); } OverloadedOperatorKind FunctionDecl::overloaded_operator(void) const { - return static_cast(impl->reader.getVal79()); + return static_cast(impl->reader.getVal80()); } TokenRange FunctionDecl::parameters_tokens(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal116(), impl->reader.getVal119()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal117(), impl->reader.getVal120()); } Type FunctionDecl::return_type(void) const { - RawEntityId eid = impl->reader.getVal120(); + RawEntityId eid = impl->reader.getVal121(); return Type(impl->ep->TypeFor(impl->ep, eid)); } StorageClass FunctionDecl::storage_class(void) const { - return static_cast(impl->reader.getVal80()); + return static_cast(impl->reader.getVal81()); } FunctionDeclTemplatedKind FunctionDecl::templated_kind(void) const { - return static_cast(impl->reader.getVal118()); + return static_cast(impl->reader.getVal119()); } bool FunctionDecl::has_cxx_explicit_function_object_parameter(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool FunctionDecl::has_implicit_return_zero(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool FunctionDecl::has_inherited_prototype(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool FunctionDecl::has_one_parameter_or_default_arguments(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool FunctionDecl::has_prototype(void) const { - return impl->reader.getVal89(); + return impl->reader.getVal90(); } bool FunctionDecl::has_skipped_body(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool FunctionDecl::has_trivial_body(void) const { - return impl->reader.getVal91(); + return impl->reader.getVal92(); } bool FunctionDecl::has_written_prototype(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool FunctionDecl::instantiation_is_pending(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool FunctionDecl::is_cpu_dispatch_multi_version(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } bool FunctionDecl::is_cpu_specific_multi_version(void) const { - return impl->reader.getVal95(); + return impl->reader.getVal96(); } bool FunctionDecl::is_consteval(void) const { - return impl->reader.getVal96(); + return impl->reader.getVal97(); } bool FunctionDecl::is_constexpr(void) const { - return impl->reader.getVal97(); + return impl->reader.getVal98(); } bool FunctionDecl::is_constexpr_specified(void) const { - return impl->reader.getVal98(); + return impl->reader.getVal99(); } bool FunctionDecl::is_defaulted(void) const { - return impl->reader.getVal99(); + return impl->reader.getVal100(); } bool FunctionDecl::is_deleted(void) const { - return impl->reader.getVal100(); + return impl->reader.getVal101(); } bool FunctionDecl::is_deleted_as_written(void) const { - return impl->reader.getVal101(); + return impl->reader.getVal102(); } bool FunctionDecl::is_destroying_operator_delete(void) const { - return impl->reader.getVal102(); + return impl->reader.getVal103(); } bool FunctionDecl::is_explicitly_defaulted(void) const { - return impl->reader.getVal103(); + return impl->reader.getVal104(); } bool FunctionDecl::is_extern_c(void) const { - return impl->reader.getVal104(); + return impl->reader.getVal105(); } bool FunctionDecl::is_function_template_specialization(void) const { - return impl->reader.getVal105(); + return impl->reader.getVal106(); } bool FunctionDecl::is_global(void) const { - return impl->reader.getVal106(); + return impl->reader.getVal107(); } bool FunctionDecl::is_immediate_escalating(void) const { - return impl->reader.getVal107(); + return impl->reader.getVal108(); } bool FunctionDecl::is_immediate_function(void) const { - return impl->reader.getVal108(); + return impl->reader.getVal109(); } bool FunctionDecl::is_implicitly_instantiable(void) const { - return impl->reader.getVal109(); + return impl->reader.getVal110(); } bool FunctionDecl::is_in_extern_c_context(void) const { - return impl->reader.getVal110(); + return impl->reader.getVal111(); } bool FunctionDecl::is_in_extern_cxx_context(void) const { - return impl->reader.getVal111(); + return impl->reader.getVal112(); } bool FunctionDecl::is_ineligible_or_not_selected(void) const { - return impl->reader.getVal112(); + return impl->reader.getVal113(); } bool FunctionDecl::is_inline_builtin_declaration(void) const { - return impl->reader.getVal121(); + return impl->reader.getVal122(); } std::optional FunctionDecl::is_inline_definition_externally_visible(void) const { - if (!impl->reader.getVal123()) { + if (!impl->reader.getVal124()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal122()); + return static_cast(impl->reader.getVal123()); } return std::nullopt; } bool FunctionDecl::is_inline_specified(void) const { - return impl->reader.getVal124(); + return impl->reader.getVal125(); } bool FunctionDecl::is_inlined(void) const { - return impl->reader.getVal125(); + return impl->reader.getVal126(); } bool FunctionDecl::is_late_template_parsed(void) const { - return impl->reader.getVal126(); + return impl->reader.getVal127(); } std::optional FunctionDecl::is_ms_extern_inline(void) const { - if (!impl->reader.getVal128()) { + if (!impl->reader.getVal129()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal127()); + return static_cast(impl->reader.getVal128()); } return std::nullopt; } bool FunctionDecl::is_msvcrt_entry_point(void) const { - return impl->reader.getVal131(); + return impl->reader.getVal132(); } bool FunctionDecl::is_main(void) const { - return impl->reader.getVal132(); + return impl->reader.getVal133(); } bool FunctionDecl::is_member_like_constrained_friend(void) const { - return impl->reader.getVal133(); + return impl->reader.getVal134(); } bool FunctionDecl::is_multi_version(void) const { - return impl->reader.getVal134(); + return impl->reader.getVal135(); } bool FunctionDecl::is_no_return(void) const { - return impl->reader.getVal135(); + return impl->reader.getVal136(); } bool FunctionDecl::is_overloaded_operator(void) const { - return impl->reader.getVal136(); + return impl->reader.getVal137(); } bool FunctionDecl::is_pure_virtual(void) const { - return impl->reader.getVal137(); + return impl->reader.getVal138(); } bool FunctionDecl::is_replaceable_global_allocation_function(void) const { - return impl->reader.getVal138(); + return impl->reader.getVal139(); } std::optional FunctionDecl::is_reserved_global_placement_operator(void) const { - if (!impl->reader.getVal140()) { + if (!impl->reader.getVal141()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal139()); + return static_cast(impl->reader.getVal140()); } return std::nullopt; } bool FunctionDecl::is_static(void) const { - return impl->reader.getVal141(); + return impl->reader.getVal142(); } bool FunctionDecl::is_target_clones_multi_version(void) const { - return impl->reader.getVal142(); + return impl->reader.getVal143(); } bool FunctionDecl::is_target_multi_version(void) const { - return impl->reader.getVal143(); + return impl->reader.getVal144(); } bool FunctionDecl::is_template_instantiation(void) const { - return impl->reader.getVal144(); + return impl->reader.getVal145(); } bool FunctionDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal145(); + return impl->reader.getVal146(); } bool FunctionDecl::is_trivial(void) const { - return impl->reader.getVal146(); + return impl->reader.getVal147(); } bool FunctionDecl::is_trivial_for_call(void) const { - return impl->reader.getVal147(); + return impl->reader.getVal148(); } bool FunctionDecl::is_user_provided(void) const { - return impl->reader.getVal148(); + return impl->reader.getVal149(); } bool FunctionDecl::is_variadic(void) const { - return impl->reader.getVal149(); + return impl->reader.getVal150(); } bool FunctionDecl::is_virtual_as_written(void) const { - return impl->reader.getVal150(); + return impl->reader.getVal151(); } unsigned FunctionDecl::num_parameters(void) const { - return impl->reader.getVal44().size(); + return impl->reader.getVal45().size(); } std::optional FunctionDecl::nth_parameter(unsigned n) const { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); if (n >= list.size()) { return std::nullopt; } @@ -592,12 +592,12 @@ std::optional FunctionDecl::nth_parameter(unsigned n) const { } gap::generator FunctionDecl::parameters(void) const & { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d44 = ep->DeclFor(ep, v)) { - if (auto e = ParmVarDecl::from_base(std::move(d44))) { + if (auto d45 = ep->DeclFor(ep, v)) { + if (auto e = ParmVarDecl::from_base(std::move(d45))) { co_yield std::move(*e); } } @@ -606,12 +606,12 @@ gap::generator FunctionDecl::parameters(void) const & { } bool FunctionDecl::uses_seh_try(void) const { - return impl->reader.getVal151(); + return impl->reader.getVal152(); } std::optional FunctionDecl::body(void) const { if (true) { - RawEntityId eid = impl->reader.getVal152(); + RawEntityId eid = impl->reader.getVal153(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -623,11 +623,11 @@ std::optional FunctionDecl::body(void) const { } unsigned FunctionDecl::num_template_arguments(void) const { - return impl->reader.getVal54().size(); + return impl->reader.getVal55().size(); } std::optional FunctionDecl::nth_template_argument(unsigned n) const { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); if (n >= list.size()) { return std::nullopt; } @@ -641,12 +641,12 @@ std::optional FunctionDecl::nth_template_argument(unsigned n) } gap::generator FunctionDecl::template_arguments(void) const & { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d54 = ep->TemplateArgumentFor(ep, v)) { - co_yield TemplateArgument(std::move(d54)); + if (auto d55 = ep->TemplateArgumentFor(ep, v)) { + co_yield TemplateArgument(std::move(d55)); } } co_return; diff --git a/lib/AST/FunctionParmPackExpr.cpp b/lib/AST/FunctionParmPackExpr.cpp index 47fbb75b0..a8224db95 100644 --- a/lib/AST/FunctionParmPackExpr.cpp +++ b/lib/AST/FunctionParmPackExpr.cpp @@ -184,20 +184,20 @@ std::optional FunctionParmPackExpr::from(const TokenContex } VarDecl FunctionParmPackExpr::parameter_pack(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return VarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token FunctionParmPackExpr::parameter_pack_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } unsigned FunctionParmPackExpr::num_expansions(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional FunctionParmPackExpr::nth_expansion(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -211,12 +211,12 @@ std::optional FunctionParmPackExpr::nth_expansion(unsigned n) const { } gap::generator FunctionParmPackExpr::expansions(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->DeclFor(ep, v)) { - if (auto e = VarDecl::from_base(std::move(d15))) { + if (auto d16 = ep->DeclFor(ep, v)) { + if (auto e = VarDecl::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/FunctionTemplateDecl.cpp b/lib/AST/FunctionTemplateDecl.cpp index 271e59895..5c3bd318d 100644 --- a/lib/AST/FunctionTemplateDecl.cpp +++ b/lib/AST/FunctionTemplateDecl.cpp @@ -213,11 +213,11 @@ std::optional FunctionTemplateDecl::from(const TokenContex } bool FunctionTemplateDecl::is_abbreviated(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool FunctionTemplateDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } #pragma GCC diagnostic pop diff --git a/lib/AST/GCCAsmStmt.cpp b/lib/AST/GCCAsmStmt.cpp index fbea5f10e..47113d6c9 100644 --- a/lib/AST/GCCAsmStmt.cpp +++ b/lib/AST/GCCAsmStmt.cpp @@ -184,24 +184,24 @@ std::optional GCCAsmStmt::from(const TokenContext &t) { } StringLiteral GCCAsmStmt::assembly_string(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return StringLiteral::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token GCCAsmStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal12()); } bool GCCAsmStmt::is_assembly_goto(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } unsigned GCCAsmStmt::num_labels(void) const { - return impl->reader.getVal30().size(); + return impl->reader.getVal31().size(); } std::optional GCCAsmStmt::nth_label(unsigned n) const { - auto list = impl->reader.getVal30(); + auto list = impl->reader.getVal31(); if (n >= list.size()) { return std::nullopt; } @@ -215,12 +215,12 @@ std::optional GCCAsmStmt::nth_label(unsigned n) const { } gap::generator GCCAsmStmt::labels(void) const & { - auto list = impl->reader.getVal30(); + auto list = impl->reader.getVal31(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d30 = ep->StmtFor(ep, v)) { - if (auto e = AddrLabelExpr::from_base(std::move(d30))) { + if (auto d31 = ep->StmtFor(ep, v)) { + if (auto e = AddrLabelExpr::from_base(std::move(d31))) { co_yield std::move(*e); } } @@ -229,11 +229,11 @@ gap::generator GCCAsmStmt::labels(void) const & { } unsigned GCCAsmStmt::num_output_constraint_literals(void) const { - return impl->reader.getVal53().size(); + return impl->reader.getVal54().size(); } std::optional GCCAsmStmt::nth_output_constraint_literal(unsigned n) const { - auto list = impl->reader.getVal53(); + auto list = impl->reader.getVal54(); if (n >= list.size()) { return std::nullopt; } @@ -247,12 +247,12 @@ std::optional GCCAsmStmt::nth_output_constraint_literal(unsigned } gap::generator GCCAsmStmt::output_constraint_literals(void) const & { - auto list = impl->reader.getVal53(); + auto list = impl->reader.getVal54(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d53 = ep->StmtFor(ep, v)) { - if (auto e = StringLiteral::from_base(std::move(d53))) { + if (auto d54 = ep->StmtFor(ep, v)) { + if (auto e = StringLiteral::from_base(std::move(d54))) { co_yield std::move(*e); } } @@ -261,7 +261,7 @@ gap::generator GCCAsmStmt::output_constraint_literals(void) const } gap::generator GCCAsmStmt::output_names(void) const & { - auto list = impl->reader.getVal65(); + auto list = impl->reader.getVal66(); EntityProviderPtr ep = impl->ep; for (auto v : list) { co_yield std::string_view(v.cStr(), v.size()); @@ -270,11 +270,11 @@ co_yield std::string_view(v.cStr(), v.size()); } unsigned GCCAsmStmt::num_input_constraint_literals(void) const { - return impl->reader.getVal54().size(); + return impl->reader.getVal55().size(); } std::optional GCCAsmStmt::nth_input_constraint_literal(unsigned n) const { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); if (n >= list.size()) { return std::nullopt; } @@ -288,12 +288,12 @@ std::optional GCCAsmStmt::nth_input_constraint_literal(unsigned n } gap::generator GCCAsmStmt::input_constraint_literals(void) const & { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d54 = ep->StmtFor(ep, v)) { - if (auto e = StringLiteral::from_base(std::move(d54))) { + if (auto d55 = ep->StmtFor(ep, v)) { + if (auto e = StringLiteral::from_base(std::move(d55))) { co_yield std::move(*e); } } @@ -302,7 +302,7 @@ gap::generator GCCAsmStmt::input_constraint_literals(void) const } gap::generator GCCAsmStmt::input_names(void) const & { - auto list = impl->reader.getVal67(); + auto list = impl->reader.getVal68(); EntityProviderPtr ep = impl->ep; for (auto v : list) { co_yield std::string_view(v.cStr(), v.size()); @@ -311,11 +311,11 @@ co_yield std::string_view(v.cStr(), v.size()); } unsigned GCCAsmStmt::num_clobber_string_literals(void) const { - return impl->reader.getVal55().size(); + return impl->reader.getVal56().size(); } std::optional GCCAsmStmt::nth_clobber_string_literal(unsigned n) const { - auto list = impl->reader.getVal55(); + auto list = impl->reader.getVal56(); if (n >= list.size()) { return std::nullopt; } @@ -329,12 +329,12 @@ std::optional GCCAsmStmt::nth_clobber_string_literal(unsigned n) } gap::generator GCCAsmStmt::clobber_string_literals(void) const & { - auto list = impl->reader.getVal55(); + auto list = impl->reader.getVal56(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d55 = ep->StmtFor(ep, v)) { - if (auto e = StringLiteral::from_base(std::move(d55))) { + if (auto d56 = ep->StmtFor(ep, v)) { + if (auto e = StringLiteral::from_base(std::move(d56))) { co_yield std::move(*e); } } @@ -343,11 +343,11 @@ gap::generator GCCAsmStmt::clobber_string_literals(void) const & } unsigned GCCAsmStmt::num_label_expressions(void) const { - return impl->reader.getVal68().size(); + return impl->reader.getVal69().size(); } std::optional GCCAsmStmt::nth_label_expression(unsigned n) const { - auto list = impl->reader.getVal68(); + auto list = impl->reader.getVal69(); if (n >= list.size()) { return std::nullopt; } @@ -361,12 +361,12 @@ std::optional GCCAsmStmt::nth_label_expression(unsigned n) const } gap::generator GCCAsmStmt::label_expressions(void) const & { - auto list = impl->reader.getVal68(); + auto list = impl->reader.getVal69(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d68 = ep->StmtFor(ep, v)) { - if (auto e = AddrLabelExpr::from_base(std::move(d68))) { + if (auto d69 = ep->StmtFor(ep, v)) { + if (auto e = AddrLabelExpr::from_base(std::move(d69))) { co_yield std::move(*e); } } @@ -375,7 +375,7 @@ gap::generator GCCAsmStmt::label_expressions(void) const & { } gap::generator GCCAsmStmt::label_names(void) const & { - auto list = impl->reader.getVal69(); + auto list = impl->reader.getVal70(); EntityProviderPtr ep = impl->ep; for (auto v : list) { co_yield std::string_view(v.cStr(), v.size()); diff --git a/lib/AST/GNUNullExpr.cpp b/lib/AST/GNUNullExpr.cpp index 4bdb3c4a9..e85a654bc 100644 --- a/lib/AST/GNUNullExpr.cpp +++ b/lib/AST/GNUNullExpr.cpp @@ -183,7 +183,7 @@ std::optional GNUNullExpr::from(const TokenContext &t) { } Token GNUNullExpr::token_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } #pragma GCC diagnostic pop diff --git a/lib/AST/GenericSelectionExpr.cpp b/lib/AST/GenericSelectionExpr.cpp index 4be9b2616..12ac59fe6 100644 --- a/lib/AST/GenericSelectionExpr.cpp +++ b/lib/AST/GenericSelectionExpr.cpp @@ -184,11 +184,11 @@ std::optional GenericSelectionExpr::from(const TokenContex } unsigned GenericSelectionExpr::num_association_expressions(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional GenericSelectionExpr::nth_association_expression(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -202,12 +202,12 @@ std::optional GenericSelectionExpr::nth_association_expression(unsigned n) } gap::generator GenericSelectionExpr::association_expressions(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -217,7 +217,7 @@ gap::generator GenericSelectionExpr::association_expressions(void) const & std::optional GenericSelectionExpr::controlling_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -230,7 +230,7 @@ std::optional GenericSelectionExpr::controlling_expression(void) const { std::optional GenericSelectionExpr::controlling_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -242,20 +242,20 @@ std::optional GenericSelectionExpr::controlling_type(void) const { } Token GenericSelectionExpr::default_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token GenericSelectionExpr::generic_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Token GenericSelectionExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } std::optional GenericSelectionExpr::result_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -267,19 +267,19 @@ std::optional GenericSelectionExpr::result_expression(void) const { } uint32_t GenericSelectionExpr::result_index(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } bool GenericSelectionExpr::is_expression_predicate(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool GenericSelectionExpr::is_result_dependent(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool GenericSelectionExpr::is_type_predicate(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } #pragma GCC diagnostic pop diff --git a/lib/AST/GotoStmt.cpp b/lib/AST/GotoStmt.cpp index 03db9b894..6552476a7 100644 --- a/lib/AST/GotoStmt.cpp +++ b/lib/AST/GotoStmt.cpp @@ -182,16 +182,16 @@ std::optional GotoStmt::from(const TokenContext &t) { } Token GotoStmt::goto_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } LabelDecl GotoStmt::label(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return LabelDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token GotoStmt::label_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal12()); } #pragma GCC diagnostic pop diff --git a/lib/AST/HLSLBufferDecl.cpp b/lib/AST/HLSLBufferDecl.cpp index 73b5caf12..c573e61df 100644 --- a/lib/AST/HLSLBufferDecl.cpp +++ b/lib/AST/HLSLBufferDecl.cpp @@ -211,19 +211,19 @@ std::optional HLSLBufferDecl::from(const TokenContext &t) { } Token HLSLBufferDecl::l_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } Token HLSLBufferDecl::token_start(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); } Token HLSLBufferDecl::r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal51()); } bool HLSLBufferDecl::is_c_buffer(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } #pragma GCC diagnostic pop diff --git a/lib/AST/IfStmt.cpp b/lib/AST/IfStmt.cpp index bdd2f82cf..fb046db34 100644 --- a/lib/AST/IfStmt.cpp +++ b/lib/AST/IfStmt.cpp @@ -184,13 +184,13 @@ std::optional IfStmt::from(const TokenContext &t) { } Expr IfStmt::condition(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional IfStmt::condition_variable(void) const { if (true) { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -203,7 +203,7 @@ std::optional IfStmt::condition_variable(void) const { std::optional IfStmt::condition_variable_declaration_statement(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -216,7 +216,7 @@ std::optional IfStmt::condition_variable_declaration_statement(void) c std::optional IfStmt::else_(void) const { if (true) { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -228,16 +228,16 @@ std::optional IfStmt::else_(void) const { } Token IfStmt::else_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } Token IfStmt::if_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal17()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal18()); } std::optional IfStmt::initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal18(); + RawEntityId eid = impl->reader.getVal19(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -249,12 +249,12 @@ std::optional IfStmt::initializer(void) const { } Token IfStmt::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal19()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal20()); } std::optional IfStmt::nondiscarded_case(void) const { if (true) { - RawEntityId eid = impl->reader.getVal20(); + RawEntityId eid = impl->reader.getVal21(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -266,48 +266,48 @@ std::optional IfStmt::nondiscarded_case(void) const { } Token IfStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal21()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal22()); } IfStatementKind IfStmt::statement_kind(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } Stmt IfStmt::then(void) const { - RawEntityId eid = impl->reader.getVal22(); + RawEntityId eid = impl->reader.getVal23(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } bool IfStmt::has_else_storage(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } bool IfStmt::has_initializer_storage(void) const { - return impl->reader.getVal16(); + return impl->reader.getVal17(); } bool IfStmt::has_variable_storage(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } bool IfStmt::is_consteval(void) const { - return impl->reader.getVal24(); + return impl->reader.getVal25(); } bool IfStmt::is_constexpr(void) const { - return impl->reader.getVal25(); + return impl->reader.getVal26(); } bool IfStmt::is_negated_consteval(void) const { - return impl->reader.getVal58(); + return impl->reader.getVal59(); } bool IfStmt::is_non_negated_consteval(void) const { - return impl->reader.getVal59(); + return impl->reader.getVal60(); } bool IfStmt::is_obj_c_availability_check(void) const { - return impl->reader.getVal60(); + return impl->reader.getVal61(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ImaginaryLiteral.cpp b/lib/AST/ImaginaryLiteral.cpp index 9c3b6cbbc..a0b0e66b9 100644 --- a/lib/AST/ImaginaryLiteral.cpp +++ b/lib/AST/ImaginaryLiteral.cpp @@ -183,7 +183,7 @@ std::optional ImaginaryLiteral::from(const TokenContext &t) { } Expr ImaginaryLiteral::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ImplicitCastExpr.cpp b/lib/AST/ImplicitCastExpr.cpp index 02cc0df6f..b355ead9d 100644 --- a/lib/AST/ImplicitCastExpr.cpp +++ b/lib/AST/ImplicitCastExpr.cpp @@ -184,7 +184,7 @@ std::optional ImplicitCastExpr::from(const TokenContext &t) { } bool ImplicitCastExpr::is_part_of_explicit_cast(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ImplicitConceptSpecializationDecl.cpp b/lib/AST/ImplicitConceptSpecializationDecl.cpp index 658365d10..b9dbbbb0b 100644 --- a/lib/AST/ImplicitConceptSpecializationDecl.cpp +++ b/lib/AST/ImplicitConceptSpecializationDecl.cpp @@ -211,11 +211,11 @@ std::optional ImplicitConceptSpecializationDe } unsigned ImplicitConceptSpecializationDecl::num_template_arguments(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional ImplicitConceptSpecializationDecl::nth_template_argument(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -229,12 +229,12 @@ std::optional ImplicitConceptSpecializationDecl::nth_template_ } gap::generator ImplicitConceptSpecializationDecl::template_arguments(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->TemplateArgumentFor(ep, v)) { - co_yield TemplateArgument(std::move(d43)); + if (auto d44 = ep->TemplateArgumentFor(ep, v)) { + co_yield TemplateArgument(std::move(d44)); } } co_return; diff --git a/lib/AST/ImplicitParamDecl.cpp b/lib/AST/ImplicitParamDecl.cpp index da66cd422..192c01f4e 100644 --- a/lib/AST/ImplicitParamDecl.cpp +++ b/lib/AST/ImplicitParamDecl.cpp @@ -214,7 +214,7 @@ std::optional ImplicitParamDecl::from(const TokenContext &t) } ImplicitParamKind ImplicitParamDecl::parameter_kind(void) const { - return static_cast(impl->reader.getVal118()); + return static_cast(impl->reader.getVal119()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ImportDecl.cpp b/lib/AST/ImportDecl.cpp index 0622b6fa2..8e74bd8fd 100644 --- a/lib/AST/ImportDecl.cpp +++ b/lib/AST/ImportDecl.cpp @@ -211,11 +211,11 @@ std::optional ImportDecl::from(const TokenContext &t) { } unsigned ImportDecl::num_identifier_tokens(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional ImportDecl::nth_identifier_token(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -229,7 +229,7 @@ std::optional ImportDecl::nth_identifier_token(unsigned n) const { } gap::generator ImportDecl::identifier_tokens(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; auto fragment = ep->FragmentFor(ep, impl->fragment_id); if (!fragment) { @@ -239,8 +239,8 @@ gap::generator ImportDecl::identifier_tokens(void) const & { auto tok_reader = fragment->ParsedTokenReader(fragment); for (auto v : list) { EntityId id(v); - if (auto t43 = ep->TokenFor(ep, tok_reader, v)) { - co_yield t43; + if (auto t44 = ep->TokenFor(ep, tok_reader, v)) { + co_yield t44; } } co_return; diff --git a/lib/AST/IndirectFieldDecl.cpp b/lib/AST/IndirectFieldDecl.cpp index 7314520ea..c300dcfbc 100644 --- a/lib/AST/IndirectFieldDecl.cpp +++ b/lib/AST/IndirectFieldDecl.cpp @@ -214,12 +214,12 @@ std::optional IndirectFieldDecl::from(const TokenContext &t) } gap::generator IndirectFieldDecl::chain(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->DeclFor(ep, v)) { - if (auto e = NamedDecl::from_base(std::move(d43))) { + if (auto d44 = ep->DeclFor(ep, v)) { + if (auto e = NamedDecl::from_base(std::move(d44))) { co_yield std::move(*e); } } @@ -229,7 +229,7 @@ gap::generator IndirectFieldDecl::chain(void) const & { std::optional IndirectFieldDecl::anonymous_field(void) const { if (true) { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -241,12 +241,12 @@ std::optional IndirectFieldDecl::anonymous_field(void) const { } uint32_t IndirectFieldDecl::chaining_size(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } std::optional IndirectFieldDecl::variable_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal58(); + RawEntityId eid = impl->reader.getVal59(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/IndirectGotoStmt.cpp b/lib/AST/IndirectGotoStmt.cpp index 1beb3d898..a76948e8f 100644 --- a/lib/AST/IndirectGotoStmt.cpp +++ b/lib/AST/IndirectGotoStmt.cpp @@ -184,7 +184,7 @@ std::optional IndirectGotoStmt::from(const TokenContext &t) { std::optional IndirectGotoStmt::constant_target(void) const { if (true) { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -196,15 +196,15 @@ std::optional IndirectGotoStmt::constant_target(void) const { } Token IndirectGotoStmt::goto_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } Token IndirectGotoStmt::star_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal12()); } Expr IndirectGotoStmt::target(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/InitListExpr.cpp b/lib/AST/InitListExpr.cpp index 397f3dbdf..f34cef077 100644 --- a/lib/AST/InitListExpr.cpp +++ b/lib/AST/InitListExpr.cpp @@ -185,7 +185,7 @@ std::optional InitListExpr::from(const TokenContext &t) { std::optional InitListExpr::array_filler(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -198,7 +198,7 @@ std::optional InitListExpr::array_filler(void) const { std::optional InitListExpr::initialized_field_in_union(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -210,16 +210,16 @@ std::optional InitListExpr::initialized_field_in_union(void) const { } Token InitListExpr::l_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token InitListExpr::r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } std::optional InitListExpr::semantic_form(void) const { if (true) { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -232,7 +232,7 @@ std::optional InitListExpr::semantic_form(void) const { std::optional InitListExpr::syntactic_form(void) const { if (true) { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -244,23 +244,23 @@ std::optional InitListExpr::syntactic_form(void) const { } bool InitListExpr::had_array_range_designator(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool InitListExpr::has_array_filler(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool InitListExpr::has_designated_initializer(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } unsigned InitListExpr::num_initializers(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional InitListExpr::nth_initializer(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -274,12 +274,12 @@ std::optional InitListExpr::nth_initializer(unsigned n) const { } gap::generator InitListExpr::initializers(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -288,26 +288,26 @@ gap::generator InitListExpr::initializers(void) const & { } bool InitListExpr::is_explicit(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool InitListExpr::is_semantic_form(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool InitListExpr::is_string_literal_initializer(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool InitListExpr::is_syntactic_form(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } std::optional InitListExpr::is_transparent(void) const { - if (!impl->reader.getVal94()) { + if (!impl->reader.getVal95()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal93()); + return static_cast(impl->reader.getVal94()); } return std::nullopt; } diff --git a/lib/AST/IntegerLiteral.cpp b/lib/AST/IntegerLiteral.cpp index 1a7569e3a..c7e87704f 100644 --- a/lib/AST/IntegerLiteral.cpp +++ b/lib/AST/IntegerLiteral.cpp @@ -183,7 +183,7 @@ std::optional IntegerLiteral::from(const TokenContext &t) { } Token IntegerLiteral::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } #pragma GCC diagnostic pop diff --git a/lib/AST/LabelDecl.cpp b/lib/AST/LabelDecl.cpp index a308a1c3c..8a1a53005 100644 --- a/lib/AST/LabelDecl.cpp +++ b/lib/AST/LabelDecl.cpp @@ -212,25 +212,25 @@ std::optional LabelDecl::from(const TokenContext &t) { } std::string_view LabelDecl::ms_assembly_label(void) const { - capnp::Text::Reader data = impl->reader.getVal56(); + capnp::Text::Reader data = impl->reader.getVal57(); return std::string_view(data.cStr(), data.size()); } LabelStmt LabelDecl::statement(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return LabelStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool LabelDecl::is_gnu_local(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool LabelDecl::is_ms_assembly_label(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool LabelDecl::is_resolved_ms_assembly_label(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } #pragma GCC diagnostic pop diff --git a/lib/AST/LabelStmt.cpp b/lib/AST/LabelStmt.cpp index a502a78e3..4802d77b8 100644 --- a/lib/AST/LabelStmt.cpp +++ b/lib/AST/LabelStmt.cpp @@ -183,26 +183,26 @@ std::optional LabelStmt::from(const TokenContext &t) { } LabelDecl LabelStmt::declaration(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return LabelDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token LabelStmt::identifier_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal12()); } std::string_view LabelStmt::name(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } Stmt LabelStmt::sub_statement(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } bool LabelStmt::is_side_entry(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } #pragma GCC diagnostic pop diff --git a/lib/AST/LambdaExpr.cpp b/lib/AST/LambdaExpr.cpp index f3829ac6a..5304d2eb0 100644 --- a/lib/AST/LambdaExpr.cpp +++ b/lib/AST/LambdaExpr.cpp @@ -190,31 +190,31 @@ std::optional LambdaExpr::from(const TokenContext &t) { } Stmt LambdaExpr::body(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } CXXMethodDecl LambdaExpr::call_operator(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return CXXMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } LambdaCaptureDefault LambdaExpr::capture_default(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } Token LambdaExpr::capture_default_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } CompoundStmt LambdaExpr::compound_statement_body(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional LambdaExpr::dependent_call_operator(void) const { if (true) { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -226,11 +226,11 @@ std::optional LambdaExpr::dependent_call_operator(void) co } unsigned LambdaExpr::num_explicit_template_parameters(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional LambdaExpr::nth_explicit_template_parameter(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -244,12 +244,12 @@ std::optional LambdaExpr::nth_explicit_template_parameter(unsigned n) } gap::generator LambdaExpr::explicit_template_parameters(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->DeclFor(ep, v)) { - if (auto e = NamedDecl::from_base(std::move(d15))) { + if (auto d16 = ep->DeclFor(ep, v)) { + if (auto e = NamedDecl::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -258,17 +258,17 @@ gap::generator LambdaExpr::explicit_template_parameters(void) const & } TokenRange LambdaExpr::introducer_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal43(), impl->reader.getVal44()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal44(), impl->reader.getVal45()); } CXXRecordDecl LambdaExpr::lambda_class(void) const { - RawEntityId eid = impl->reader.getVal45(); + RawEntityId eid = impl->reader.getVal46(); return CXXRecordDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional LambdaExpr::template_parameter_list(void) const { if (true) { - RawEntityId eid = impl->reader.getVal46(); + RawEntityId eid = impl->reader.getVal47(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -281,7 +281,7 @@ std::optional LambdaExpr::template_parameter_list(void) c std::optional LambdaExpr::trailing_requires_clause(void) const { if (true) { - RawEntityId eid = impl->reader.getVal47(); + RawEntityId eid = impl->reader.getVal48(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -293,19 +293,19 @@ std::optional LambdaExpr::trailing_requires_clause(void) const { } bool LambdaExpr::has_explicit_parameters(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool LambdaExpr::has_explicit_result_type(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool LambdaExpr::is_generic_lambda(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool LambdaExpr::is_mutable(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } #pragma GCC diagnostic pop diff --git a/lib/AST/LifetimeExtendedTemporaryDecl.cpp b/lib/AST/LifetimeExtendedTemporaryDecl.cpp index b0caf2e37..827f32491 100644 --- a/lib/AST/LifetimeExtendedTemporaryDecl.cpp +++ b/lib/AST/LifetimeExtendedTemporaryDecl.cpp @@ -212,32 +212,32 @@ std::optional LifetimeExtendedTemporaryDecl::from } gap::generator LifetimeExtendedTemporaryDecl::children(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->StmtFor(ep, v)) { - co_yield Stmt(std::move(d43)); + if (auto d44 = ep->StmtFor(ep, v)) { + co_yield Stmt(std::move(d44)); } } co_return; } ValueDecl LifetimeExtendedTemporaryDecl::extending_declaration(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return ValueDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } uint32_t LifetimeExtendedTemporaryDecl::mangling_number(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } StorageDuration LifetimeExtendedTemporaryDecl::storage_duration(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } Expr LifetimeExtendedTemporaryDecl::temporary_expression(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/LinkageSpecDecl.cpp b/lib/AST/LinkageSpecDecl.cpp index 35325525f..1ce3d0a5f 100644 --- a/lib/AST/LinkageSpecDecl.cpp +++ b/lib/AST/LinkageSpecDecl.cpp @@ -211,19 +211,19 @@ std::optional LinkageSpecDecl::from(const TokenContext &t) { } Token LinkageSpecDecl::extern_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } LinkageSpecLanguageIDs LinkageSpecDecl::language(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } Token LinkageSpecDecl::r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } bool LinkageSpecDecl::has_braces(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } gap::generator LinkageSpecDecl::contained_declarations(void) const & { diff --git a/lib/AST/MSAsmStmt.cpp b/lib/AST/MSAsmStmt.cpp index 2713ea8a6..d8627c18c 100644 --- a/lib/AST/MSAsmStmt.cpp +++ b/lib/AST/MSAsmStmt.cpp @@ -183,7 +183,7 @@ std::optional MSAsmStmt::from(const TokenContext &t) { } gap::generator MSAsmStmt::all_constraints(void) const & { - auto list = impl->reader.getVal65(); + auto list = impl->reader.getVal66(); EntityProviderPtr ep = impl->ep; for (auto v : list) { co_yield std::string_view(v.cStr(), v.size()); @@ -192,11 +192,11 @@ co_yield std::string_view(v.cStr(), v.size()); } unsigned MSAsmStmt::num_all_expressions(void) const { - return impl->reader.getVal30().size(); + return impl->reader.getVal31().size(); } std::optional MSAsmStmt::nth_all_expression(unsigned n) const { - auto list = impl->reader.getVal30(); + auto list = impl->reader.getVal31(); if (n >= list.size()) { return std::nullopt; } @@ -210,12 +210,12 @@ std::optional MSAsmStmt::nth_all_expression(unsigned n) const { } gap::generator MSAsmStmt::all_expressions(void) const & { - auto list = impl->reader.getVal30(); + auto list = impl->reader.getVal31(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d30 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d30))) { + if (auto d31 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d31))) { co_yield std::move(*e); } } @@ -224,16 +224,16 @@ gap::generator MSAsmStmt::all_expressions(void) const & { } std::string_view MSAsmStmt::assembly_string(void) const { - capnp::Text::Reader data = impl->reader.getVal66(); + capnp::Text::Reader data = impl->reader.getVal67(); return std::string_view(data.cStr(), data.size()); } Token MSAsmStmt::l_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } bool MSAsmStmt::has_braces(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/MSDependentExistsStmt.cpp b/lib/AST/MSDependentExistsStmt.cpp index c371deeac..54863ad4d 100644 --- a/lib/AST/MSDependentExistsStmt.cpp +++ b/lib/AST/MSDependentExistsStmt.cpp @@ -182,20 +182,20 @@ std::optional MSDependentExistsStmt::from(const TokenCont } Token MSDependentExistsStmt::keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } CompoundStmt MSDependentExistsStmt::sub_statement(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool MSDependentExistsStmt::is_if_exists(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } bool MSDependentExistsStmt::is_if_not_exists(void) const { - return impl->reader.getVal16(); + return impl->reader.getVal17(); } #pragma GCC diagnostic pop diff --git a/lib/AST/MSPropertyDecl.cpp b/lib/AST/MSPropertyDecl.cpp index 3163a74ac..c6ba45570 100644 --- a/lib/AST/MSPropertyDecl.cpp +++ b/lib/AST/MSPropertyDecl.cpp @@ -213,11 +213,11 @@ std::optional MSPropertyDecl::from(const TokenContext &t) { } bool MSPropertyDecl::has_getter(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool MSPropertyDecl::has_setter(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } #pragma GCC diagnostic pop diff --git a/lib/AST/MSPropertyRefExpr.cpp b/lib/AST/MSPropertyRefExpr.cpp index 9897b447b..a777ac870 100644 --- a/lib/AST/MSPropertyRefExpr.cpp +++ b/lib/AST/MSPropertyRefExpr.cpp @@ -184,25 +184,25 @@ std::optional MSPropertyRefExpr::from(const TokenContext &t) } Expr MSPropertyRefExpr::base_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token MSPropertyRefExpr::member_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } MSPropertyDecl MSPropertyRefExpr::property_declaration(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return MSPropertyDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } bool MSPropertyRefExpr::is_arrow(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool MSPropertyRefExpr::is_implicit_access(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/MSPropertySubscriptExpr.cpp b/lib/AST/MSPropertySubscriptExpr.cpp index 808720108..9a74c910e 100644 --- a/lib/AST/MSPropertySubscriptExpr.cpp +++ b/lib/AST/MSPropertySubscriptExpr.cpp @@ -183,17 +183,17 @@ std::optional MSPropertySubscriptExpr::from(const Token } Expr MSPropertySubscriptExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr MSPropertySubscriptExpr::index(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token MSPropertySubscriptExpr::r_bracket_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } #pragma GCC diagnostic pop diff --git a/lib/AST/MaterializeTemporaryExpr.cpp b/lib/AST/MaterializeTemporaryExpr.cpp index f9779db07..094a71dbb 100644 --- a/lib/AST/MaterializeTemporaryExpr.cpp +++ b/lib/AST/MaterializeTemporaryExpr.cpp @@ -186,7 +186,7 @@ std::optional MaterializeTemporaryExpr::from(const Tok std::optional MaterializeTemporaryExpr::extending_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -199,7 +199,7 @@ std::optional MaterializeTemporaryExpr::extending_declaration(void) c std::optional MaterializeTemporaryExpr::lifetime_extended_temporary_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -211,24 +211,24 @@ std::optional MaterializeTemporaryExpr::lifetime_ } uint32_t MaterializeTemporaryExpr::mangling_number(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } StorageDuration MaterializeTemporaryExpr::storage_duration(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } Expr MaterializeTemporaryExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool MaterializeTemporaryExpr::is_bound_to_lvalue_reference(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool MaterializeTemporaryExpr::is_usable_in_constant_expressions(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/MatrixSubscriptExpr.cpp b/lib/AST/MatrixSubscriptExpr.cpp index c7cf3cf50..2f8414b35 100644 --- a/lib/AST/MatrixSubscriptExpr.cpp +++ b/lib/AST/MatrixSubscriptExpr.cpp @@ -183,26 +183,26 @@ std::optional MatrixSubscriptExpr::from(const TokenContext } Expr MatrixSubscriptExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr MatrixSubscriptExpr::column_index(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token MatrixSubscriptExpr::r_bracket_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Expr MatrixSubscriptExpr::row_index(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool MatrixSubscriptExpr::is_incomplete(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/MemberExpr.cpp b/lib/AST/MemberExpr.cpp index 32973ab15..a851c194c 100644 --- a/lib/AST/MemberExpr.cpp +++ b/lib/AST/MemberExpr.cpp @@ -184,61 +184,61 @@ std::optional MemberExpr::from(const TokenContext &t) { } Expr MemberExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token MemberExpr::l_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } ValueDecl MemberExpr::member_declaration(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return ValueDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token MemberExpr::member_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Token MemberExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } Token MemberExpr::r_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } Token MemberExpr::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } bool MemberExpr::had_multiple_candidates(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool MemberExpr::has_explicit_template_arguments(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool MemberExpr::has_qualifier(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool MemberExpr::has_template_keyword(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool MemberExpr::is_arrow(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool MemberExpr::is_implicit_access(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } NonOdrUseReason MemberExpr::is_non_odr_use(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } #pragma GCC diagnostic pop diff --git a/lib/AST/NamedDecl.cpp b/lib/AST/NamedDecl.cpp index 442f9d8b7..6152777b8 100644 --- a/lib/AST/NamedDecl.cpp +++ b/lib/AST/NamedDecl.cpp @@ -397,67 +397,67 @@ std::optional NamedDecl::from(const TokenContext &t) { } Linkage NamedDecl::formal_linkage(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } std::string_view NamedDecl::name(void) const { - capnp::Text::Reader data = impl->reader.getVal55(); + capnp::Text::Reader data = impl->reader.getVal56(); return std::string_view(data.cStr(), data.size()); } std::optional NamedDecl::obj_cf_string_formatting_family(void) const { - if (!impl->reader.getVal42()) { + if (!impl->reader.getVal43()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal61()); + return static_cast(impl->reader.getVal62()); } return std::nullopt; } NamedDecl NamedDecl::underlying_declaration(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return NamedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional NamedDecl::visibility(void) const { - if (!impl->reader.getVal45()) { + if (!impl->reader.getVal46()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal62()); + return static_cast(impl->reader.getVal63()); } return std::nullopt; } bool NamedDecl::has_external_formal_linkage(void) const { - return impl->reader.getVal46(); + return impl->reader.getVal47(); } bool NamedDecl::has_linkage(void) const { - return impl->reader.getVal47(); + return impl->reader.getVal48(); } bool NamedDecl::has_linkage_been_computed(void) const { - return impl->reader.getVal51(); + return impl->reader.getVal52(); } bool NamedDecl::is_cxx_class_member(void) const { - return impl->reader.getVal52(); + return impl->reader.getVal53(); } bool NamedDecl::is_cxx_instance_member(void) const { - return impl->reader.getVal53(); + return impl->reader.getVal54(); } bool NamedDecl::is_externally_declarable(void) const { - return impl->reader.getVal63(); + return impl->reader.getVal64(); } bool NamedDecl::is_externally_visible(void) const { - return impl->reader.getVal64(); + return impl->reader.getVal65(); } bool NamedDecl::is_linkage_valid(void) const { - return impl->reader.getVal65(); + return impl->reader.getVal66(); } #pragma GCC diagnostic pop diff --git a/lib/AST/NamespaceAliasDecl.cpp b/lib/AST/NamespaceAliasDecl.cpp index 52ecf641a..ef39884a5 100644 --- a/lib/AST/NamespaceAliasDecl.cpp +++ b/lib/AST/NamespaceAliasDecl.cpp @@ -212,25 +212,25 @@ std::optional NamespaceAliasDecl::from(const TokenContext &t } Token NamespaceAliasDecl::alias_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } NamedDecl NamespaceAliasDecl::aliased_namespace(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return NamedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } NamespaceDecl NamespaceAliasDecl::namespace_(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return NamespaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token NamespaceAliasDecl::namespace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } Token NamespaceAliasDecl::target_name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); } #pragma GCC diagnostic pop diff --git a/lib/AST/NamespaceDecl.cpp b/lib/AST/NamespaceDecl.cpp index 7da4931f6..50be14e10 100644 --- a/lib/AST/NamespaceDecl.cpp +++ b/lib/AST/NamespaceDecl.cpp @@ -212,19 +212,19 @@ std::optional NamespaceDecl::from(const TokenContext &t) { } Token NamespaceDecl::r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } bool NamespaceDecl::is_anonymous_namespace(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool NamespaceDecl::is_inline(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool NamespaceDecl::is_nested(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } gap::generator NamespaceDecl::contained_declarations(void) const & { diff --git a/lib/AST/NonTypeTemplateParmDecl.cpp b/lib/AST/NonTypeTemplateParmDecl.cpp index 268cf393c..5ec3205a5 100644 --- a/lib/AST/NonTypeTemplateParmDecl.cpp +++ b/lib/AST/NonTypeTemplateParmDecl.cpp @@ -215,12 +215,12 @@ std::optional NonTypeTemplateParmDecl::from(const Token } bool NonTypeTemplateParmDecl::default_argument_was_inherited(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } std::optional NonTypeTemplateParmDecl::default_argument(void) const { if (true) { - RawEntityId eid = impl->reader.getVal71(); + RawEntityId eid = impl->reader.getVal72(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -232,12 +232,12 @@ std::optional NonTypeTemplateParmDecl::default_argument(void) const { } Token NonTypeTemplateParmDecl::default_argument_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal73()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal74()); } std::optional NonTypeTemplateParmDecl::placeholder_type_constraint(void) const { if (true) { - RawEntityId eid = impl->reader.getVal74(); + RawEntityId eid = impl->reader.getVal75(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -249,27 +249,27 @@ std::optional NonTypeTemplateParmDecl::placeholder_type_constraint(void) c } bool NonTypeTemplateParmDecl::has_default_argument(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool NonTypeTemplateParmDecl::has_placeholder_type_constraint(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool NonTypeTemplateParmDecl::is_expanded_parameter_pack(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } bool NonTypeTemplateParmDecl::is_pack_expansion(void) const { - return impl->reader.getVal83(); + return impl->reader.getVal84(); } unsigned NonTypeTemplateParmDecl::num_expansion_types(void) const { - return impl->reader.getVal44().size(); + return impl->reader.getVal45().size(); } std::optional NonTypeTemplateParmDecl::nth_expansion_type(unsigned n) const { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); if (n >= list.size()) { return std::nullopt; } @@ -283,12 +283,12 @@ std::optional NonTypeTemplateParmDecl::nth_expansion_type(unsigned n) cons } gap::generator NonTypeTemplateParmDecl::expansion_types(void) const & { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d44 = ep->TypeFor(ep, v)) { - co_yield Type(std::move(d44)); + if (auto d45 = ep->TypeFor(ep, v)) { + co_yield Type(std::move(d45)); } } co_return; diff --git a/lib/AST/NullStmt.cpp b/lib/AST/NullStmt.cpp index 8498842c7..7d46d13f3 100644 --- a/lib/AST/NullStmt.cpp +++ b/lib/AST/NullStmt.cpp @@ -181,11 +181,11 @@ std::optional NullStmt::from(const TokenContext &t) { } Token NullStmt::semi_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } bool NullStmt::has_leading_empty_macro(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPAllocateDecl.cpp b/lib/AST/OMPAllocateDecl.cpp index 37b808845..e074c4c24 100644 --- a/lib/AST/OMPAllocateDecl.cpp +++ b/lib/AST/OMPAllocateDecl.cpp @@ -212,11 +212,11 @@ std::optional OMPAllocateDecl::from(const TokenContext &t) { } unsigned OMPAllocateDecl::num_varlists(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional OMPAllocateDecl::nth_varlist(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -230,12 +230,12 @@ std::optional OMPAllocateDecl::nth_varlist(unsigned n) const { } gap::generator OMPAllocateDecl::varlists(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d43))) { + if (auto d44 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d44))) { co_yield std::move(*e); } } diff --git a/lib/AST/OMPArraySectionExpr.cpp b/lib/AST/OMPArraySectionExpr.cpp index 38d6092f9..2a1f6ba33 100644 --- a/lib/AST/OMPArraySectionExpr.cpp +++ b/lib/AST/OMPArraySectionExpr.cpp @@ -183,34 +183,34 @@ std::optional OMPArraySectionExpr::from(const TokenContext } Expr OMPArraySectionExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token OMPArraySectionExpr::first_colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Token OMPArraySectionExpr::second_colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Expr OMPArraySectionExpr::length(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPArraySectionExpr::lower_bound(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token OMPArraySectionExpr::r_bracket_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } Expr OMPArraySectionExpr::stride(void) const { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/OMPArrayShapingExpr.cpp b/lib/AST/OMPArrayShapingExpr.cpp index 2d64a198b..97727d3f2 100644 --- a/lib/AST/OMPArrayShapingExpr.cpp +++ b/lib/AST/OMPArrayShapingExpr.cpp @@ -183,16 +183,16 @@ std::optional OMPArrayShapingExpr::from(const TokenContext } Expr OMPArrayShapingExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } unsigned OMPArrayShapingExpr::num_dimensions(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional OMPArrayShapingExpr::nth_dimension(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -206,12 +206,12 @@ std::optional OMPArrayShapingExpr::nth_dimension(unsigned n) const { } gap::generator OMPArrayShapingExpr::dimensions(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -220,11 +220,11 @@ gap::generator OMPArrayShapingExpr::dimensions(void) const & { } Token OMPArrayShapingExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Token OMPArrayShapingExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPAtomicDirective.cpp b/lib/AST/OMPAtomicDirective.cpp index e930504da..21b6e29eb 100644 --- a/lib/AST/OMPAtomicDirective.cpp +++ b/lib/AST/OMPAtomicDirective.cpp @@ -183,50 +183,50 @@ std::optional OMPAtomicDirective::from(const TokenContext &t } Expr OMPAtomicDirective::condition_expression(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPAtomicDirective::d(void) const { - RawEntityId eid = impl->reader.getVal17(); + RawEntityId eid = impl->reader.getVal18(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPAtomicDirective::expression(void) const { - RawEntityId eid = impl->reader.getVal18(); + RawEntityId eid = impl->reader.getVal19(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPAtomicDirective::r(void) const { - RawEntityId eid = impl->reader.getVal19(); + RawEntityId eid = impl->reader.getVal20(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPAtomicDirective::update_expression(void) const { - RawEntityId eid = impl->reader.getVal20(); + RawEntityId eid = impl->reader.getVal21(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPAtomicDirective::v(void) const { - RawEntityId eid = impl->reader.getVal21(); + RawEntityId eid = impl->reader.getVal22(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPAtomicDirective::x(void) const { - RawEntityId eid = impl->reader.getVal22(); + RawEntityId eid = impl->reader.getVal23(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPAtomicDirective::is_fail_only(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } bool OMPAtomicDirective::is_postfix_update(void) const { - return impl->reader.getVal24(); + return impl->reader.getVal25(); } bool OMPAtomicDirective::is_xlhs_in_rhs_part(void) const { - return impl->reader.getVal25(); + return impl->reader.getVal26(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPCanonicalLoop.cpp b/lib/AST/OMPCanonicalLoop.cpp index 30f45c890..71c2d5920 100644 --- a/lib/AST/OMPCanonicalLoop.cpp +++ b/lib/AST/OMPCanonicalLoop.cpp @@ -183,22 +183,22 @@ std::optional OMPCanonicalLoop::from(const TokenContext &t) { } CapturedStmt OMPCanonicalLoop::distance_func(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return CapturedStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Stmt OMPCanonicalLoop::loop_statement(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } CapturedStmt OMPCanonicalLoop::loop_variable_func(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return CapturedStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } DeclRefExpr OMPCanonicalLoop::loop_variable_reference(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return DeclRefExpr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/OMPDeclareMapperDecl.cpp b/lib/AST/OMPDeclareMapperDecl.cpp index 40a8f781a..45bf2b031 100644 --- a/lib/AST/OMPDeclareMapperDecl.cpp +++ b/lib/AST/OMPDeclareMapperDecl.cpp @@ -215,7 +215,7 @@ std::optional OMPDeclareMapperDecl::from(const TokenContex } Expr OMPDeclareMapperDecl::mapper_variable_reference(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/OMPDeclareReductionDecl.cpp b/lib/AST/OMPDeclareReductionDecl.cpp index 9c42d1d15..f7273ee82 100644 --- a/lib/AST/OMPDeclareReductionDecl.cpp +++ b/lib/AST/OMPDeclareReductionDecl.cpp @@ -214,37 +214,37 @@ std::optional OMPDeclareReductionDecl::from(const Token } Expr OMPDeclareReductionDecl::combiner(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPDeclareReductionDecl::combiner_in(void) const { - RawEntityId eid = impl->reader.getVal58(); + RawEntityId eid = impl->reader.getVal59(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPDeclareReductionDecl::combiner_out(void) const { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPDeclareReductionDecl::initializer_original(void) const { - RawEntityId eid = impl->reader.getVal60(); + RawEntityId eid = impl->reader.getVal61(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPDeclareReductionDecl::initializer_private(void) const { - RawEntityId eid = impl->reader.getVal70(); + RawEntityId eid = impl->reader.getVal71(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPDeclareReductionDecl::initializer(void) const { - RawEntityId eid = impl->reader.getVal71(); + RawEntityId eid = impl->reader.getVal72(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } OMPDeclareReductionInitKind OMPDeclareReductionDecl::initializer_kind(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } gap::generator OMPDeclareReductionDecl::contained_declarations(void) const & { diff --git a/lib/AST/OMPDispatchDirective.cpp b/lib/AST/OMPDispatchDirective.cpp index c574ae679..5014a8c1a 100644 --- a/lib/AST/OMPDispatchDirective.cpp +++ b/lib/AST/OMPDispatchDirective.cpp @@ -182,7 +182,7 @@ std::optional OMPDispatchDirective::from(const TokenContex } Token OMPDispatchDirective::target_call_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPDistributeParallelForDirective.cpp b/lib/AST/OMPDistributeParallelForDirective.cpp index 9d70c5e14..07e72eab1 100644 --- a/lib/AST/OMPDistributeParallelForDirective.cpp +++ b/lib/AST/OMPDistributeParallelForDirective.cpp @@ -185,12 +185,12 @@ std::optional OMPDistributeParallelForDirecti } Expr OMPDistributeParallelForDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal56(); + RawEntityId eid = impl->reader.getVal57(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPDistributeParallelForDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPExecutableDirective.cpp b/lib/AST/OMPExecutableDirective.cpp index 07aae749f..ba83a8191 100644 --- a/lib/AST/OMPExecutableDirective.cpp +++ b/lib/AST/OMPExecutableDirective.cpp @@ -396,31 +396,31 @@ std::optional OMPExecutableDirective::from(const TokenCo } Stmt OMPExecutableDirective::associated_statement(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } CapturedStmt OMPExecutableDirective::innermost_captured_statement(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return CapturedStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Stmt OMPExecutableDirective::raw_statement(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Stmt OMPExecutableDirective::structured_block(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } bool OMPExecutableDirective::has_associated_statement(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } bool OMPExecutableDirective::is_standalone_directive(void) const { - return impl->reader.getVal16(); + return impl->reader.getVal17(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPForDirective.cpp b/lib/AST/OMPForDirective.cpp index 459ef5049..19450660d 100644 --- a/lib/AST/OMPForDirective.cpp +++ b/lib/AST/OMPForDirective.cpp @@ -185,12 +185,12 @@ std::optional OMPForDirective::from(const TokenContext &t) { } Expr OMPForDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal56(); + RawEntityId eid = impl->reader.getVal57(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPForDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPIteratorExpr.cpp b/lib/AST/OMPIteratorExpr.cpp index 5df9510fd..5127c821c 100644 --- a/lib/AST/OMPIteratorExpr.cpp +++ b/lib/AST/OMPIteratorExpr.cpp @@ -183,15 +183,15 @@ std::optional OMPIteratorExpr::from(const TokenContext &t) { } Token OMPIteratorExpr::iterator_kw_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token OMPIteratorExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Token OMPIteratorExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPLoopBasedDirective.cpp b/lib/AST/OMPLoopBasedDirective.cpp index 96e5511c0..f3d5ba2b9 100644 --- a/lib/AST/OMPLoopBasedDirective.cpp +++ b/lib/AST/OMPLoopBasedDirective.cpp @@ -291,7 +291,7 @@ std::optional OMPLoopBasedDirective::from(const TokenCont } uint32_t OMPLoopBasedDirective::loops_number(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPLoopDirective.cpp b/lib/AST/OMPLoopDirective.cpp index 0dc0318ab..1dddcc2a0 100644 --- a/lib/AST/OMPLoopDirective.cpp +++ b/lib/AST/OMPLoopDirective.cpp @@ -287,11 +287,11 @@ std::optional OMPLoopDirective::from(const TokenContext &t) { } unsigned OMPLoopDirective::num_counters(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional OMPLoopDirective::nth_counter(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -305,12 +305,12 @@ std::optional OMPLoopDirective::nth_counter(unsigned n) const { } gap::generator OMPLoopDirective::counters(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -319,11 +319,11 @@ gap::generator OMPLoopDirective::counters(void) const & { } unsigned OMPLoopDirective::num_dependent_counters(void) const { - return impl->reader.getVal27().size(); + return impl->reader.getVal28().size(); } std::optional OMPLoopDirective::nth_dependent_counter(unsigned n) const { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); if (n >= list.size()) { return std::nullopt; } @@ -337,12 +337,12 @@ std::optional OMPLoopDirective::nth_dependent_counter(unsigned n) const { } gap::generator OMPLoopDirective::dependent_counters(void) const & { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d27 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d27))) { + if (auto d28 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d28))) { co_yield std::move(*e); } } @@ -351,11 +351,11 @@ gap::generator OMPLoopDirective::dependent_counters(void) const & { } unsigned OMPLoopDirective::num_dependent_initializers(void) const { - return impl->reader.getVal28().size(); + return impl->reader.getVal29().size(); } std::optional OMPLoopDirective::nth_dependent_initializer(unsigned n) const { - auto list = impl->reader.getVal28(); + auto list = impl->reader.getVal29(); if (n >= list.size()) { return std::nullopt; } @@ -369,12 +369,12 @@ std::optional OMPLoopDirective::nth_dependent_initializer(unsigned n) cons } gap::generator OMPLoopDirective::dependent_initializers(void) const & { - auto list = impl->reader.getVal28(); + auto list = impl->reader.getVal29(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d28 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d28))) { + if (auto d29 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d29))) { co_yield std::move(*e); } } @@ -383,11 +383,11 @@ gap::generator OMPLoopDirective::dependent_initializers(void) const & { } unsigned OMPLoopDirective::num_finals(void) const { - return impl->reader.getVal29().size(); + return impl->reader.getVal30().size(); } std::optional OMPLoopDirective::nth_final(unsigned n) const { - auto list = impl->reader.getVal29(); + auto list = impl->reader.getVal30(); if (n >= list.size()) { return std::nullopt; } @@ -401,12 +401,12 @@ std::optional OMPLoopDirective::nth_final(unsigned n) const { } gap::generator OMPLoopDirective::finals(void) const & { - auto list = impl->reader.getVal29(); + auto list = impl->reader.getVal30(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d29 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d29))) { + if (auto d30 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d30))) { co_yield std::move(*e); } } @@ -415,11 +415,11 @@ gap::generator OMPLoopDirective::finals(void) const & { } unsigned OMPLoopDirective::num_finals_conditions(void) const { - return impl->reader.getVal30().size(); + return impl->reader.getVal31().size(); } std::optional OMPLoopDirective::nth_finals_condition(unsigned n) const { - auto list = impl->reader.getVal30(); + auto list = impl->reader.getVal31(); if (n >= list.size()) { return std::nullopt; } @@ -433,12 +433,12 @@ std::optional OMPLoopDirective::nth_finals_condition(unsigned n) const { } gap::generator OMPLoopDirective::finals_conditions(void) const & { - auto list = impl->reader.getVal30(); + auto list = impl->reader.getVal31(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d30 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d30))) { + if (auto d31 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d31))) { co_yield std::move(*e); } } @@ -447,156 +447,156 @@ gap::generator OMPLoopDirective::finals_conditions(void) const & { } Stmt OMPLoopDirective::body(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Expr OMPLoopDirective::calculate_last_iteration(void) const { - RawEntityId eid = impl->reader.getVal17(); + RawEntityId eid = impl->reader.getVal18(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_condition(void) const { - RawEntityId eid = impl->reader.getVal18(); + RawEntityId eid = impl->reader.getVal19(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_distance_condition(void) const { - RawEntityId eid = impl->reader.getVal19(); + RawEntityId eid = impl->reader.getVal20(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_ensure_upper_bound(void) const { - RawEntityId eid = impl->reader.getVal20(); + RawEntityId eid = impl->reader.getVal21(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_initializer(void) const { - RawEntityId eid = impl->reader.getVal21(); + RawEntityId eid = impl->reader.getVal22(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_lower_bound_variable(void) const { - RawEntityId eid = impl->reader.getVal22(); + RawEntityId eid = impl->reader.getVal23(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_next_lower_bound(void) const { - RawEntityId eid = impl->reader.getVal31(); + RawEntityId eid = impl->reader.getVal32(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_next_upper_bound(void) const { - RawEntityId eid = impl->reader.getVal32(); + RawEntityId eid = impl->reader.getVal33(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_parallel_for_in_distance_condition(void) const { - RawEntityId eid = impl->reader.getVal33(); + RawEntityId eid = impl->reader.getVal34(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::combined_upper_bound_variable(void) const { - RawEntityId eid = impl->reader.getVal34(); + RawEntityId eid = impl->reader.getVal35(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::condition(void) const { - RawEntityId eid = impl->reader.getVal35(); + RawEntityId eid = impl->reader.getVal36(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::distance_increment(void) const { - RawEntityId eid = impl->reader.getVal36(); + RawEntityId eid = impl->reader.getVal37(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::ensure_upper_bound(void) const { - RawEntityId eid = impl->reader.getVal37(); + RawEntityId eid = impl->reader.getVal38(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::increment(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::initializer(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::is_last_iteration_variable(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::iteration_variable(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::last_iteration(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::lower_bound_variable(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::next_lower_bound(void) const { - RawEntityId eid = impl->reader.getVal44(); + RawEntityId eid = impl->reader.getVal45(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::next_upper_bound(void) const { - RawEntityId eid = impl->reader.getVal45(); + RawEntityId eid = impl->reader.getVal46(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::pre_condition(void) const { - RawEntityId eid = impl->reader.getVal46(); + RawEntityId eid = impl->reader.getVal47(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Stmt OMPLoopDirective::pre_initializers(void) const { - RawEntityId eid = impl->reader.getVal47(); + RawEntityId eid = impl->reader.getVal48(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Expr OMPLoopDirective::prev_ensure_upper_bound(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::prev_lower_bound_variable(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::prev_upper_bound_variable(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::stride_variable(void) const { - RawEntityId eid = impl->reader.getVal51(); + RawEntityId eid = impl->reader.getVal52(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr OMPLoopDirective::upper_bound_variable(void) const { - RawEntityId eid = impl->reader.getVal52(); + RawEntityId eid = impl->reader.getVal53(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } unsigned OMPLoopDirective::num_initializers(void) const { - return impl->reader.getVal53().size(); + return impl->reader.getVal54().size(); } std::optional OMPLoopDirective::nth_initializer(unsigned n) const { - auto list = impl->reader.getVal53(); + auto list = impl->reader.getVal54(); if (n >= list.size()) { return std::nullopt; } @@ -610,12 +610,12 @@ std::optional OMPLoopDirective::nth_initializer(unsigned n) const { } gap::generator OMPLoopDirective::initializers(void) const & { - auto list = impl->reader.getVal53(); + auto list = impl->reader.getVal54(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d53 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d53))) { + if (auto d54 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d54))) { co_yield std::move(*e); } } @@ -624,11 +624,11 @@ gap::generator OMPLoopDirective::initializers(void) const & { } unsigned OMPLoopDirective::num_private_counters(void) const { - return impl->reader.getVal54().size(); + return impl->reader.getVal55().size(); } std::optional OMPLoopDirective::nth_private_counter(unsigned n) const { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); if (n >= list.size()) { return std::nullopt; } @@ -642,12 +642,12 @@ std::optional OMPLoopDirective::nth_private_counter(unsigned n) const { } gap::generator OMPLoopDirective::private_counters(void) const & { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d54 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d54))) { + if (auto d55 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d55))) { co_yield std::move(*e); } } @@ -656,11 +656,11 @@ gap::generator OMPLoopDirective::private_counters(void) const & { } unsigned OMPLoopDirective::num_updates(void) const { - return impl->reader.getVal55().size(); + return impl->reader.getVal56().size(); } std::optional OMPLoopDirective::nth_update(unsigned n) const { - auto list = impl->reader.getVal55(); + auto list = impl->reader.getVal56(); if (n >= list.size()) { return std::nullopt; } @@ -674,12 +674,12 @@ std::optional OMPLoopDirective::nth_update(unsigned n) const { } gap::generator OMPLoopDirective::updates(void) const & { - auto list = impl->reader.getVal55(); + auto list = impl->reader.getVal56(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d55 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d55))) { + if (auto d56 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d56))) { co_yield std::move(*e); } } diff --git a/lib/AST/OMPLoopTransformationDirective.cpp b/lib/AST/OMPLoopTransformationDirective.cpp index ab4ed33f5..463fd3f2c 100644 --- a/lib/AST/OMPLoopTransformationDirective.cpp +++ b/lib/AST/OMPLoopTransformationDirective.cpp @@ -187,12 +187,12 @@ std::optional OMPLoopTransformationDirective::fr } Stmt OMPLoopTransformationDirective::pre_initializers(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Stmt OMPLoopTransformationDirective::transformed_statement(void) const { - RawEntityId eid = impl->reader.getVal17(); + RawEntityId eid = impl->reader.getVal18(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/OMPMaskedTaskLoopDirective.cpp b/lib/AST/OMPMaskedTaskLoopDirective.cpp index d0d4cd378..93018a396 100644 --- a/lib/AST/OMPMaskedTaskLoopDirective.cpp +++ b/lib/AST/OMPMaskedTaskLoopDirective.cpp @@ -184,7 +184,7 @@ std::optional OMPMaskedTaskLoopDirective::from(const } bool OMPMaskedTaskLoopDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPMasterTaskLoopDirective.cpp b/lib/AST/OMPMasterTaskLoopDirective.cpp index 5a55f1dbe..c440e063f 100644 --- a/lib/AST/OMPMasterTaskLoopDirective.cpp +++ b/lib/AST/OMPMasterTaskLoopDirective.cpp @@ -184,7 +184,7 @@ std::optional OMPMasterTaskLoopDirective::from(const } bool OMPMasterTaskLoopDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPMetaDirective.cpp b/lib/AST/OMPMetaDirective.cpp index 9e11ef047..6f1d6c02e 100644 --- a/lib/AST/OMPMetaDirective.cpp +++ b/lib/AST/OMPMetaDirective.cpp @@ -182,7 +182,7 @@ std::optional OMPMetaDirective::from(const TokenContext &t) { } Stmt OMPMetaDirective::if_statement(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/OMPParallelDirective.cpp b/lib/AST/OMPParallelDirective.cpp index bc2c47c5f..3c0eb1838 100644 --- a/lib/AST/OMPParallelDirective.cpp +++ b/lib/AST/OMPParallelDirective.cpp @@ -183,12 +183,12 @@ std::optional OMPParallelDirective::from(const TokenContex } Expr OMPParallelDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPParallelDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPParallelForDirective.cpp b/lib/AST/OMPParallelForDirective.cpp index b15b5aa5e..034701697 100644 --- a/lib/AST/OMPParallelForDirective.cpp +++ b/lib/AST/OMPParallelForDirective.cpp @@ -185,12 +185,12 @@ std::optional OMPParallelForDirective::from(const Token } Expr OMPParallelForDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal56(); + RawEntityId eid = impl->reader.getVal57(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPParallelForDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPParallelMaskedDirective.cpp b/lib/AST/OMPParallelMaskedDirective.cpp index 9dc44c618..4676d7134 100644 --- a/lib/AST/OMPParallelMaskedDirective.cpp +++ b/lib/AST/OMPParallelMaskedDirective.cpp @@ -183,7 +183,7 @@ std::optional OMPParallelMaskedDirective::from(const } Expr OMPParallelMaskedDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp b/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp index 95a33bc32..fc975490a 100644 --- a/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp +++ b/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp @@ -184,7 +184,7 @@ std::optional OMPParallelMaskedTaskLoopDirec } bool OMPParallelMaskedTaskLoopDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPParallelMasterDirective.cpp b/lib/AST/OMPParallelMasterDirective.cpp index eab99b171..3c2171d03 100644 --- a/lib/AST/OMPParallelMasterDirective.cpp +++ b/lib/AST/OMPParallelMasterDirective.cpp @@ -183,7 +183,7 @@ std::optional OMPParallelMasterDirective::from(const } Expr OMPParallelMasterDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/OMPParallelMasterTaskLoopDirective.cpp b/lib/AST/OMPParallelMasterTaskLoopDirective.cpp index 7a3a73c3b..4779234d9 100644 --- a/lib/AST/OMPParallelMasterTaskLoopDirective.cpp +++ b/lib/AST/OMPParallelMasterTaskLoopDirective.cpp @@ -184,7 +184,7 @@ std::optional OMPParallelMasterTaskLoopDirec } bool OMPParallelMasterTaskLoopDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPParallelSectionsDirective.cpp b/lib/AST/OMPParallelSectionsDirective.cpp index 42769be3d..029ad0f77 100644 --- a/lib/AST/OMPParallelSectionsDirective.cpp +++ b/lib/AST/OMPParallelSectionsDirective.cpp @@ -183,12 +183,12 @@ std::optional OMPParallelSectionsDirective::from(c } Expr OMPParallelSectionsDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPParallelSectionsDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPSectionDirective.cpp b/lib/AST/OMPSectionDirective.cpp index 79dfb28b5..a4fb227f6 100644 --- a/lib/AST/OMPSectionDirective.cpp +++ b/lib/AST/OMPSectionDirective.cpp @@ -182,7 +182,7 @@ std::optional OMPSectionDirective::from(const TokenContext } bool OMPSectionDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPSectionsDirective.cpp b/lib/AST/OMPSectionsDirective.cpp index d24ec0978..9f33558c7 100644 --- a/lib/AST/OMPSectionsDirective.cpp +++ b/lib/AST/OMPSectionsDirective.cpp @@ -183,12 +183,12 @@ std::optional OMPSectionsDirective::from(const TokenContex } Expr OMPSectionsDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPSectionsDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPTargetParallelDirective.cpp b/lib/AST/OMPTargetParallelDirective.cpp index 353e42460..448a2515e 100644 --- a/lib/AST/OMPTargetParallelDirective.cpp +++ b/lib/AST/OMPTargetParallelDirective.cpp @@ -183,12 +183,12 @@ std::optional OMPTargetParallelDirective::from(const } Expr OMPTargetParallelDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPTargetParallelDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPTargetParallelForDirective.cpp b/lib/AST/OMPTargetParallelForDirective.cpp index e45ba4418..842b2f412 100644 --- a/lib/AST/OMPTargetParallelForDirective.cpp +++ b/lib/AST/OMPTargetParallelForDirective.cpp @@ -185,12 +185,12 @@ std::optional OMPTargetParallelForDirective::from } Expr OMPTargetParallelForDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal56(); + RawEntityId eid = impl->reader.getVal57(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPTargetParallelForDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp b/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp index 2c87ba9d5..d34fece49 100644 --- a/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp +++ b/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp @@ -185,12 +185,12 @@ std::optional OMPTargetTeamsDistri } Expr OMPTargetTeamsDistributeParallelForDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal56(); + RawEntityId eid = impl->reader.getVal57(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPTargetTeamsDistributeParallelForDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPTaskDirective.cpp b/lib/AST/OMPTaskDirective.cpp index 0024505f7..40e794a62 100644 --- a/lib/AST/OMPTaskDirective.cpp +++ b/lib/AST/OMPTaskDirective.cpp @@ -182,7 +182,7 @@ std::optional OMPTaskDirective::from(const TokenContext &t) { } bool OMPTaskDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPTaskLoopDirective.cpp b/lib/AST/OMPTaskLoopDirective.cpp index edfe69e85..72b2d4ce0 100644 --- a/lib/AST/OMPTaskLoopDirective.cpp +++ b/lib/AST/OMPTaskLoopDirective.cpp @@ -184,7 +184,7 @@ std::optional OMPTaskLoopDirective::from(const TokenContex } bool OMPTaskLoopDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPTaskgroupDirective.cpp b/lib/AST/OMPTaskgroupDirective.cpp index 5e9d64b58..545dd70ee 100644 --- a/lib/AST/OMPTaskgroupDirective.cpp +++ b/lib/AST/OMPTaskgroupDirective.cpp @@ -183,7 +183,7 @@ std::optional OMPTaskgroupDirective::from(const TokenCont } Expr OMPTaskgroupDirective::reduction_reference(void) const { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/OMPTeamsDistributeParallelForDirective.cpp b/lib/AST/OMPTeamsDistributeParallelForDirective.cpp index aa7b33c26..2167bcef2 100644 --- a/lib/AST/OMPTeamsDistributeParallelForDirective.cpp +++ b/lib/AST/OMPTeamsDistributeParallelForDirective.cpp @@ -185,12 +185,12 @@ std::optional OMPTeamsDistributeParallel } Expr OMPTeamsDistributeParallelForDirective::task_reduction_reference_expression(void) const { - RawEntityId eid = impl->reader.getVal56(); + RawEntityId eid = impl->reader.getVal57(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool OMPTeamsDistributeParallelForDirective::has_cancel(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OMPThreadPrivateDecl.cpp b/lib/AST/OMPThreadPrivateDecl.cpp index d72f07a4a..ec8d8bed9 100644 --- a/lib/AST/OMPThreadPrivateDecl.cpp +++ b/lib/AST/OMPThreadPrivateDecl.cpp @@ -212,11 +212,11 @@ std::optional OMPThreadPrivateDecl::from(const TokenContex } unsigned OMPThreadPrivateDecl::num_varlists(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional OMPThreadPrivateDecl::nth_varlist(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -230,12 +230,12 @@ std::optional OMPThreadPrivateDecl::nth_varlist(unsigned n) const { } gap::generator OMPThreadPrivateDecl::varlists(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d43))) { + if (auto d44 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d44))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCArrayLiteral.cpp b/lib/AST/ObjCArrayLiteral.cpp index 85d67bf74..68703f935 100644 --- a/lib/AST/ObjCArrayLiteral.cpp +++ b/lib/AST/ObjCArrayLiteral.cpp @@ -184,16 +184,16 @@ std::optional ObjCArrayLiteral::from(const TokenContext &t) { } ObjCMethodDecl ObjCArrayLiteral::array_with_objects_method(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } unsigned ObjCArrayLiteral::num_elements(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional ObjCArrayLiteral::nth_element(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -207,12 +207,12 @@ std::optional ObjCArrayLiteral::nth_element(unsigned n) const { } gap::generator ObjCArrayLiteral::elements(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCAtCatchStmt.cpp b/lib/AST/ObjCAtCatchStmt.cpp index 1baa9646f..b6df33082 100644 --- a/lib/AST/ObjCAtCatchStmt.cpp +++ b/lib/AST/ObjCAtCatchStmt.cpp @@ -182,25 +182,25 @@ std::optional ObjCAtCatchStmt::from(const TokenContext &t) { } Token ObjCAtCatchStmt::at_catch_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } Stmt ObjCAtCatchStmt::catch_body(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } VarDecl ObjCAtCatchStmt::catch_parameter_declaration(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return VarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCAtCatchStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal13()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); } bool ObjCAtCatchStmt::has_ellipsis(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCAtFinallyStmt.cpp b/lib/AST/ObjCAtFinallyStmt.cpp index f4fd50535..d74502a92 100644 --- a/lib/AST/ObjCAtFinallyStmt.cpp +++ b/lib/AST/ObjCAtFinallyStmt.cpp @@ -181,11 +181,11 @@ std::optional ObjCAtFinallyStmt::from(const TokenContext &t) } Token ObjCAtFinallyStmt::at_finally_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } Stmt ObjCAtFinallyStmt::finally_body(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/ObjCAtSynchronizedStmt.cpp b/lib/AST/ObjCAtSynchronizedStmt.cpp index c1eb6c4d5..d09bb9304 100644 --- a/lib/AST/ObjCAtSynchronizedStmt.cpp +++ b/lib/AST/ObjCAtSynchronizedStmt.cpp @@ -183,16 +183,16 @@ std::optional ObjCAtSynchronizedStmt::from(const TokenCo } Token ObjCAtSynchronizedStmt::at_synchronized_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } CompoundStmt ObjCAtSynchronizedStmt::synch_body(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ObjCAtSynchronizedStmt::synch_expression(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ObjCAtThrowStmt.cpp b/lib/AST/ObjCAtThrowStmt.cpp index 3e99100fd..69faecd1d 100644 --- a/lib/AST/ObjCAtThrowStmt.cpp +++ b/lib/AST/ObjCAtThrowStmt.cpp @@ -182,12 +182,12 @@ std::optional ObjCAtThrowStmt::from(const TokenContext &t) { } Expr ObjCAtThrowStmt::throw_expression(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token ObjCAtThrowStmt::throw_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCAtTryStmt.cpp b/lib/AST/ObjCAtTryStmt.cpp index 644fd41c4..4234c0c1b 100644 --- a/lib/AST/ObjCAtTryStmt.cpp +++ b/lib/AST/ObjCAtTryStmt.cpp @@ -183,25 +183,25 @@ std::optional ObjCAtTryStmt::from(const TokenContext &t) { } Token ObjCAtTryStmt::at_try_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } ObjCAtFinallyStmt ObjCAtTryStmt::finally_statement(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return ObjCAtFinallyStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Stmt ObjCAtTryStmt::try_body(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } unsigned ObjCAtTryStmt::num_catch_statements(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional ObjCAtTryStmt::nth_catch_statement(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -215,12 +215,12 @@ std::optional ObjCAtTryStmt::nth_catch_statement(unsigned n) co } gap::generator ObjCAtTryStmt::catch_statements(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = ObjCAtCatchStmt::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = ObjCAtCatchStmt::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCAutoreleasePoolStmt.cpp b/lib/AST/ObjCAutoreleasePoolStmt.cpp index ff855be05..d88e488b9 100644 --- a/lib/AST/ObjCAutoreleasePoolStmt.cpp +++ b/lib/AST/ObjCAutoreleasePoolStmt.cpp @@ -181,11 +181,11 @@ std::optional ObjCAutoreleasePoolStmt::from(const Token } Token ObjCAutoreleasePoolStmt::at_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } Stmt ObjCAutoreleasePoolStmt::sub_statement(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/ObjCAvailabilityCheckExpr.cpp b/lib/AST/ObjCAvailabilityCheckExpr.cpp index 017fbd105..5995fc57c 100644 --- a/lib/AST/ObjCAvailabilityCheckExpr.cpp +++ b/lib/AST/ObjCAvailabilityCheckExpr.cpp @@ -183,7 +183,7 @@ std::optional ObjCAvailabilityCheckExpr::from(const T } bool ObjCAvailabilityCheckExpr::has_version(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCBoolLiteralExpr.cpp b/lib/AST/ObjCBoolLiteralExpr.cpp index 8fb7a780c..67d3f4b78 100644 --- a/lib/AST/ObjCBoolLiteralExpr.cpp +++ b/lib/AST/ObjCBoolLiteralExpr.cpp @@ -183,11 +183,11 @@ std::optional ObjCBoolLiteralExpr::from(const TokenContext } Token ObjCBoolLiteralExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } bool ObjCBoolLiteralExpr::value(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCBoxedExpr.cpp b/lib/AST/ObjCBoxedExpr.cpp index e9972d403..d99e558bb 100644 --- a/lib/AST/ObjCBoxedExpr.cpp +++ b/lib/AST/ObjCBoxedExpr.cpp @@ -184,21 +184,21 @@ std::optional ObjCBoxedExpr::from(const TokenContext &t) { } Token ObjCBoxedExpr::at_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } ObjCMethodDecl ObjCBoxedExpr::boxing_method(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Expr ObjCBoxedExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool ObjCBoxedExpr::is_expressible_as_constant_initializer(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCBridgedCastExpr.cpp b/lib/AST/ObjCBridgedCastExpr.cpp index 0c6d58e89..27c0680ff 100644 --- a/lib/AST/ObjCBridgedCastExpr.cpp +++ b/lib/AST/ObjCBridgedCastExpr.cpp @@ -185,20 +185,20 @@ std::optional ObjCBridgedCastExpr::from(const TokenContext } Token ObjCBridgedCastExpr::bridge_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } ObjCBridgeCastKind ObjCBridgedCastExpr::bridge_kind(void) const { - return static_cast(impl->reader.getVal91()); + return static_cast(impl->reader.getVal92()); } std::string_view ObjCBridgedCastExpr::bridge_kind_name(void) const { - capnp::Text::Reader data = impl->reader.getVal66(); + capnp::Text::Reader data = impl->reader.getVal67(); return std::string_view(data.cStr(), data.size()); } Token ObjCBridgedCastExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCCategoryDecl.cpp b/lib/AST/ObjCCategoryDecl.cpp index 1c062a0a4..56fbd6a01 100644 --- a/lib/AST/ObjCCategoryDecl.cpp +++ b/lib/AST/ObjCCategoryDecl.cpp @@ -218,42 +218,42 @@ std::optional ObjCCategoryDecl::from(const TokenContext &t) { } bool ObjCCategoryDecl::is_class_extension(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } Token ObjCCategoryDecl::category_name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } ObjCInterfaceDecl ObjCCategoryDecl::class_interface(void) const { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCCategoryImplDecl ObjCCategoryDecl::implementation(void) const { - RawEntityId eid = impl->reader.getVal60(); + RawEntityId eid = impl->reader.getVal61(); return ObjCCategoryImplDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCCategoryDecl::instance_variable_l_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal70()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal71()); } Token ObjCCategoryDecl::instance_variable_r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal71()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal72()); } ObjCCategoryDecl ObjCCategoryDecl::next_class_category(void) const { - RawEntityId eid = impl->reader.getVal73(); + RawEntityId eid = impl->reader.getVal74(); return ObjCCategoryDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } unsigned ObjCCategoryDecl::num_instance_variables(void) const { - return impl->reader.getVal329().size(); + return impl->reader.getVal330().size(); } std::optional ObjCCategoryDecl::nth_instance_variable(unsigned n) const { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); if (n >= list.size()) { return std::nullopt; } @@ -267,12 +267,12 @@ std::optional ObjCCategoryDecl::nth_instance_variable(unsigned n) } gap::generator ObjCCategoryDecl::instance_variables(void) const & { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d329 = ep->DeclFor(ep, v)) { - if (auto e = ObjCIvarDecl::from_base(std::move(d329))) { + if (auto d330 = ep->DeclFor(ep, v)) { + if (auto e = ObjCIvarDecl::from_base(std::move(d330))) { co_yield std::move(*e); } } @@ -281,11 +281,11 @@ gap::generator ObjCCategoryDecl::instance_variables(void) const & } unsigned ObjCCategoryDecl::num_protocol_tokens(void) const { - return impl->reader.getVal340().size(); + return impl->reader.getVal341().size(); } std::optional ObjCCategoryDecl::nth_protocol_token(unsigned n) const { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); if (n >= list.size()) { return std::nullopt; } @@ -299,7 +299,7 @@ std::optional ObjCCategoryDecl::nth_protocol_token(unsigned n) const { } gap::generator ObjCCategoryDecl::protocol_tokens(void) const & { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); EntityProviderPtr ep = impl->ep; auto fragment = ep->FragmentFor(ep, impl->fragment_id); if (!fragment) { @@ -309,19 +309,19 @@ gap::generator ObjCCategoryDecl::protocol_tokens(void) const & { auto tok_reader = fragment->ParsedTokenReader(fragment); for (auto v : list) { EntityId id(v); - if (auto t340 = ep->TokenFor(ep, tok_reader, v)) { - co_yield t340; + if (auto t341 = ep->TokenFor(ep, tok_reader, v)) { + co_yield t341; } } co_return; } unsigned ObjCCategoryDecl::num_protocols(void) const { - return impl->reader.getVal347().size(); + return impl->reader.getVal348().size(); } std::optional ObjCCategoryDecl::nth_protocol(unsigned n) const { - auto list = impl->reader.getVal347(); + auto list = impl->reader.getVal348(); if (n >= list.size()) { return std::nullopt; } @@ -335,12 +335,12 @@ std::optional ObjCCategoryDecl::nth_protocol(unsigned n) const } gap::generator ObjCCategoryDecl::protocols(void) const & { - auto list = impl->reader.getVal347(); + auto list = impl->reader.getVal348(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d347 = ep->DeclFor(ep, v)) { - if (auto e = ObjCProtocolDecl::from_base(std::move(d347))) { + if (auto d348 = ep->DeclFor(ep, v)) { + if (auto e = ObjCProtocolDecl::from_base(std::move(d348))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCCategoryImplDecl.cpp b/lib/AST/ObjCCategoryImplDecl.cpp index 58153fe26..a96ed54b0 100644 --- a/lib/AST/ObjCCategoryImplDecl.cpp +++ b/lib/AST/ObjCCategoryImplDecl.cpp @@ -215,12 +215,12 @@ std::optional ObjCCategoryImplDecl::from(const TokenContex } ObjCCategoryDecl ObjCCategoryImplDecl::category_declaration(void) const { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); return ObjCCategoryDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCCategoryImplDecl::category_name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal61()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCCompatibleAliasDecl.cpp b/lib/AST/ObjCCompatibleAliasDecl.cpp index 4561e3db4..c8f9c3ce5 100644 --- a/lib/AST/ObjCCompatibleAliasDecl.cpp +++ b/lib/AST/ObjCCompatibleAliasDecl.cpp @@ -212,7 +212,7 @@ std::optional ObjCCompatibleAliasDecl::from(const Token } ObjCInterfaceDecl ObjCCompatibleAliasDecl::class_interface(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ObjCContainerDecl.cpp b/lib/AST/ObjCContainerDecl.cpp index fb7529b80..128ed22d7 100644 --- a/lib/AST/ObjCContainerDecl.cpp +++ b/lib/AST/ObjCContainerDecl.cpp @@ -228,11 +228,11 @@ std::optional ObjCContainerDecl::from(const TokenContext &t) } unsigned ObjCContainerDecl::num_class_methods(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional ObjCContainerDecl::nth_class_method(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -246,12 +246,12 @@ std::optional ObjCContainerDecl::nth_class_method(unsigned n) co } gap::generator ObjCContainerDecl::class_methods(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->DeclFor(ep, v)) { - if (auto e = ObjCMethodDecl::from_base(std::move(d43))) { + if (auto d44 = ep->DeclFor(ep, v)) { + if (auto e = ObjCMethodDecl::from_base(std::move(d44))) { co_yield std::move(*e); } } @@ -260,11 +260,11 @@ gap::generator ObjCContainerDecl::class_methods(void) const & { } unsigned ObjCContainerDecl::num_class_properties(void) const { - return impl->reader.getVal44().size(); + return impl->reader.getVal45().size(); } std::optional ObjCContainerDecl::nth_class_propertie(unsigned n) const { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); if (n >= list.size()) { return std::nullopt; } @@ -278,12 +278,12 @@ std::optional ObjCContainerDecl::nth_class_propertie(unsigned } gap::generator ObjCContainerDecl::class_properties(void) const & { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d44 = ep->DeclFor(ep, v)) { - if (auto e = ObjCPropertyDecl::from_base(std::move(d44))) { + if (auto d45 = ep->DeclFor(ep, v)) { + if (auto e = ObjCPropertyDecl::from_base(std::move(d45))) { co_yield std::move(*e); } } @@ -292,19 +292,19 @@ gap::generator ObjCContainerDecl::class_properties(void) const } TokenRange ObjCContainerDecl::at_end_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal48(), impl->reader.getVal49()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal49(), impl->reader.getVal50()); } Token ObjCContainerDecl::at_start_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal51()); } unsigned ObjCContainerDecl::num_instance_methods(void) const { - return impl->reader.getVal54().size(); + return impl->reader.getVal55().size(); } std::optional ObjCContainerDecl::nth_instance_method(unsigned n) const { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); if (n >= list.size()) { return std::nullopt; } @@ -318,12 +318,12 @@ std::optional ObjCContainerDecl::nth_instance_method(unsigned n) } gap::generator ObjCContainerDecl::instance_methods(void) const & { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d54 = ep->DeclFor(ep, v)) { - if (auto e = ObjCMethodDecl::from_base(std::move(d54))) { + if (auto d55 = ep->DeclFor(ep, v)) { + if (auto e = ObjCMethodDecl::from_base(std::move(d55))) { co_yield std::move(*e); } } @@ -332,11 +332,11 @@ gap::generator ObjCContainerDecl::instance_methods(void) const & } unsigned ObjCContainerDecl::num_instance_properties(void) const { - return impl->reader.getVal153().size(); + return impl->reader.getVal154().size(); } std::optional ObjCContainerDecl::nth_instance_propertie(unsigned n) const { - auto list = impl->reader.getVal153(); + auto list = impl->reader.getVal154(); if (n >= list.size()) { return std::nullopt; } @@ -350,12 +350,12 @@ std::optional ObjCContainerDecl::nth_instance_propertie(unsign } gap::generator ObjCContainerDecl::instance_properties(void) const & { - auto list = impl->reader.getVal153(); + auto list = impl->reader.getVal154(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d153 = ep->DeclFor(ep, v)) { - if (auto e = ObjCPropertyDecl::from_base(std::move(d153))) { + if (auto d154 = ep->DeclFor(ep, v)) { + if (auto e = ObjCPropertyDecl::from_base(std::move(d154))) { co_yield std::move(*e); } } @@ -364,11 +364,11 @@ gap::generator ObjCContainerDecl::instance_properties(void) co } unsigned ObjCContainerDecl::num_methods(void) const { - return impl->reader.getVal168().size(); + return impl->reader.getVal169().size(); } std::optional ObjCContainerDecl::nth_method(unsigned n) const { - auto list = impl->reader.getVal168(); + auto list = impl->reader.getVal169(); if (n >= list.size()) { return std::nullopt; } @@ -382,12 +382,12 @@ std::optional ObjCContainerDecl::nth_method(unsigned n) const { } gap::generator ObjCContainerDecl::methods(void) const & { - auto list = impl->reader.getVal168(); + auto list = impl->reader.getVal169(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d168 = ep->DeclFor(ep, v)) { - if (auto e = ObjCMethodDecl::from_base(std::move(d168))) { + if (auto d169 = ep->DeclFor(ep, v)) { + if (auto e = ObjCMethodDecl::from_base(std::move(d169))) { co_yield std::move(*e); } } @@ -396,11 +396,11 @@ gap::generator ObjCContainerDecl::methods(void) const & { } unsigned ObjCContainerDecl::num_properties(void) const { - return impl->reader.getVal174().size(); + return impl->reader.getVal175().size(); } std::optional ObjCContainerDecl::nth_propertie(unsigned n) const { - auto list = impl->reader.getVal174(); + auto list = impl->reader.getVal175(); if (n >= list.size()) { return std::nullopt; } @@ -414,12 +414,12 @@ std::optional ObjCContainerDecl::nth_propertie(unsigned n) con } gap::generator ObjCContainerDecl::properties(void) const & { - auto list = impl->reader.getVal174(); + auto list = impl->reader.getVal175(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d174 = ep->DeclFor(ep, v)) { - if (auto e = ObjCPropertyDecl::from_base(std::move(d174))) { + if (auto d175 = ep->DeclFor(ep, v)) { + if (auto e = ObjCPropertyDecl::from_base(std::move(d175))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCDictionaryLiteral.cpp b/lib/AST/ObjCDictionaryLiteral.cpp index 42a4c93af..ed3f0932a 100644 --- a/lib/AST/ObjCDictionaryLiteral.cpp +++ b/lib/AST/ObjCDictionaryLiteral.cpp @@ -184,7 +184,7 @@ std::optional ObjCDictionaryLiteral::from(const TokenCont } ObjCMethodDecl ObjCDictionaryLiteral::dictionary_with_objects_method(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ObjCEncodeExpr.cpp b/lib/AST/ObjCEncodeExpr.cpp index d59acd045..49bf81539 100644 --- a/lib/AST/ObjCEncodeExpr.cpp +++ b/lib/AST/ObjCEncodeExpr.cpp @@ -184,16 +184,16 @@ std::optional ObjCEncodeExpr::from(const TokenContext &t) { } Token ObjCEncodeExpr::at_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Type ObjCEncodeExpr::encoded_type(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Token ObjCEncodeExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCForCollectionStmt.cpp b/lib/AST/ObjCForCollectionStmt.cpp index 41544c308..7fcedc720 100644 --- a/lib/AST/ObjCForCollectionStmt.cpp +++ b/lib/AST/ObjCForCollectionStmt.cpp @@ -182,26 +182,26 @@ std::optional ObjCForCollectionStmt::from(const TokenCont } Stmt ObjCForCollectionStmt::body(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Expr ObjCForCollectionStmt::collection(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Stmt ObjCForCollectionStmt::element(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Token ObjCForCollectionStmt::for_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal13()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); } Token ObjCForCollectionStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCImplDecl.cpp b/lib/AST/ObjCImplDecl.cpp index 25feecb78..bc7e2ecf5 100644 --- a/lib/AST/ObjCImplDecl.cpp +++ b/lib/AST/ObjCImplDecl.cpp @@ -219,16 +219,16 @@ std::optional ObjCImplDecl::from(const TokenContext &t) { } ObjCInterfaceDecl ObjCImplDecl::class_interface(void) const { - RawEntityId eid = impl->reader.getVal58(); + RawEntityId eid = impl->reader.getVal59(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } unsigned ObjCImplDecl::num_property_implementations(void) const { - return impl->reader.getVal329().size(); + return impl->reader.getVal330().size(); } std::optional ObjCImplDecl::nth_property_implementation(unsigned n) const { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); if (n >= list.size()) { return std::nullopt; } @@ -242,12 +242,12 @@ std::optional ObjCImplDecl::nth_property_implementation(un } gap::generator ObjCImplDecl::property_implementations(void) const & { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d329 = ep->DeclFor(ep, v)) { - if (auto e = ObjCPropertyImplDecl::from_base(std::move(d329))) { + if (auto d330 = ep->DeclFor(ep, v)) { + if (auto e = ObjCPropertyImplDecl::from_base(std::move(d330))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCImplementationDecl.cpp b/lib/AST/ObjCImplementationDecl.cpp index df96c4043..30212c085 100644 --- a/lib/AST/ObjCImplementationDecl.cpp +++ b/lib/AST/ObjCImplementationDecl.cpp @@ -217,41 +217,41 @@ std::optional ObjCImplementationDecl::from(const TokenCo } Token ObjCImplementationDecl::instance_variable_l_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); } Token ObjCImplementationDecl::instance_variable_r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal61()); } std::string_view ObjCImplementationDecl::obj_c_runtime_name_as_string(void) const { - capnp::Text::Reader data = impl->reader.getVal56(); + capnp::Text::Reader data = impl->reader.getVal57(); return std::string_view(data.cStr(), data.size()); } ObjCInterfaceDecl ObjCImplementationDecl::super_class(void) const { - RawEntityId eid = impl->reader.getVal70(); + RawEntityId eid = impl->reader.getVal71(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCImplementationDecl::super_class_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal71()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal72()); } bool ObjCImplementationDecl::has_destructors(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool ObjCImplementationDecl::has_non_zero_constructors(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } unsigned ObjCImplementationDecl::num_initializers(void) const { - return impl->reader.getVal340().size(); + return impl->reader.getVal341().size(); } std::optional ObjCImplementationDecl::nth_initializer(unsigned n) const { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); if (n >= list.size()) { return std::nullopt; } @@ -265,23 +265,23 @@ std::optional ObjCImplementationDecl::nth_initializer(unsign } gap::generator ObjCImplementationDecl::initializers(void) const & { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d340 = ep->CXXCtorInitializerFor(ep, v)) { - co_yield CXXCtorInitializer(std::move(d340)); + if (auto d341 = ep->CXXCtorInitializerFor(ep, v)) { + co_yield CXXCtorInitializer(std::move(d341)); } } co_return; } unsigned ObjCImplementationDecl::num_instance_variables(void) const { - return impl->reader.getVal347().size(); + return impl->reader.getVal348().size(); } std::optional ObjCImplementationDecl::nth_instance_variable(unsigned n) const { - auto list = impl->reader.getVal347(); + auto list = impl->reader.getVal348(); if (n >= list.size()) { return std::nullopt; } @@ -295,12 +295,12 @@ std::optional ObjCImplementationDecl::nth_instance_variable(unsign } gap::generator ObjCImplementationDecl::instance_variables(void) const & { - auto list = impl->reader.getVal347(); + auto list = impl->reader.getVal348(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d347 = ep->DeclFor(ep, v)) { - if (auto e = ObjCIvarDecl::from_base(std::move(d347))) { + if (auto d348 = ep->DeclFor(ep, v)) { + if (auto e = ObjCIvarDecl::from_base(std::move(d348))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCIndirectCopyRestoreExpr.cpp b/lib/AST/ObjCIndirectCopyRestoreExpr.cpp index 1a0da0118..b69b00305 100644 --- a/lib/AST/ObjCIndirectCopyRestoreExpr.cpp +++ b/lib/AST/ObjCIndirectCopyRestoreExpr.cpp @@ -183,12 +183,12 @@ std::optional ObjCIndirectCopyRestoreExpr::from(con } Expr ObjCIndirectCopyRestoreExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool ObjCIndirectCopyRestoreExpr::should_copy(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCInterfaceDecl.cpp b/lib/AST/ObjCInterfaceDecl.cpp index abb3a2c60..e11f425f0 100644 --- a/lib/AST/ObjCInterfaceDecl.cpp +++ b/lib/AST/ObjCInterfaceDecl.cpp @@ -219,11 +219,11 @@ std::optional ObjCInterfaceDecl::from(const TokenContext &t) } unsigned ObjCInterfaceDecl::num_all_referenced_protocols(void) const { - return impl->reader.getVal329().size(); + return impl->reader.getVal330().size(); } std::optional ObjCInterfaceDecl::nth_all_referenced_protocol(unsigned n) const { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); if (n >= list.size()) { return std::nullopt; } @@ -237,12 +237,12 @@ std::optional ObjCInterfaceDecl::nth_all_referenced_protocol(u } gap::generator ObjCInterfaceDecl::all_referenced_protocols(void) const & { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d329 = ep->DeclFor(ep, v)) { - if (auto e = ObjCProtocolDecl::from_base(std::move(d329))) { + if (auto d330 = ep->DeclFor(ep, v)) { + if (auto e = ObjCProtocolDecl::from_base(std::move(d330))) { co_yield std::move(*e); } } @@ -251,26 +251,26 @@ gap::generator ObjCInterfaceDecl::all_referenced_protocols(voi } bool ObjCInterfaceDecl::declares_or_inherits_designated_initializers(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } Token ObjCInterfaceDecl::end_of_definition_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } ObjCImplementationDecl ObjCInterfaceDecl::implementation(void) const { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); return ObjCImplementationDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::string_view ObjCInterfaceDecl::obj_c_runtime_name_as_string(void) const { - capnp::Text::Reader data = impl->reader.getVal56(); + capnp::Text::Reader data = impl->reader.getVal57(); return std::string_view(data.cStr(), data.size()); } std::optional ObjCInterfaceDecl::super_class(void) const { if (true) { - RawEntityId eid = impl->reader.getVal60(); + RawEntityId eid = impl->reader.getVal61(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -282,12 +282,12 @@ std::optional ObjCInterfaceDecl::super_class(void) const { } Token ObjCInterfaceDecl::super_class_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal70()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal71()); } std::optional ObjCInterfaceDecl::super_class_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal71(); + RawEntityId eid = impl->reader.getVal72(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -299,41 +299,41 @@ std::optional ObjCInterfaceDecl::super_class_type(void) const { } Type ObjCInterfaceDecl::type_for_declaration(void) const { - RawEntityId eid = impl->reader.getVal73(); + RawEntityId eid = impl->reader.getVal74(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool ObjCInterfaceDecl::has_definition(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool ObjCInterfaceDecl::has_designated_initializers(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool ObjCInterfaceDecl::is_arc_weakref_unavailable(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool ObjCInterfaceDecl::is_implicit_interface_declaration(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } ObjCInterfaceDecl ObjCInterfaceDecl::is_obj_c_requires_property_definitions(void) const { - RawEntityId eid = impl->reader.getVal74(); + RawEntityId eid = impl->reader.getVal75(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } bool ObjCInterfaceDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } unsigned ObjCInterfaceDecl::num_instance_variables(void) const { - return impl->reader.getVal340().size(); + return impl->reader.getVal341().size(); } std::optional ObjCInterfaceDecl::nth_instance_variable(unsigned n) const { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); if (n >= list.size()) { return std::nullopt; } @@ -347,12 +347,12 @@ std::optional ObjCInterfaceDecl::nth_instance_variable(unsigned n) } gap::generator ObjCInterfaceDecl::instance_variables(void) const & { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d340 = ep->DeclFor(ep, v)) { - if (auto e = ObjCIvarDecl::from_base(std::move(d340))) { + if (auto d341 = ep->DeclFor(ep, v)) { + if (auto e = ObjCIvarDecl::from_base(std::move(d341))) { co_yield std::move(*e); } } @@ -361,11 +361,11 @@ gap::generator ObjCInterfaceDecl::instance_variables(void) const & } unsigned ObjCInterfaceDecl::num_known_categories(void) const { - return impl->reader.getVal347().size(); + return impl->reader.getVal348().size(); } std::optional ObjCInterfaceDecl::nth_known_categorie(unsigned n) const { - auto list = impl->reader.getVal347(); + auto list = impl->reader.getVal348(); if (n >= list.size()) { return std::nullopt; } @@ -379,12 +379,12 @@ std::optional ObjCInterfaceDecl::nth_known_categorie(unsigned } gap::generator ObjCInterfaceDecl::known_categories(void) const & { - auto list = impl->reader.getVal347(); + auto list = impl->reader.getVal348(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d347 = ep->DeclFor(ep, v)) { - if (auto e = ObjCCategoryDecl::from_base(std::move(d347))) { + if (auto d348 = ep->DeclFor(ep, v)) { + if (auto e = ObjCCategoryDecl::from_base(std::move(d348))) { co_yield std::move(*e); } } @@ -393,11 +393,11 @@ gap::generator ObjCInterfaceDecl::known_categories(void) const } unsigned ObjCInterfaceDecl::num_known_extensions(void) const { - return impl->reader.getVal348().size(); + return impl->reader.getVal349().size(); } std::optional ObjCInterfaceDecl::nth_known_extension(unsigned n) const { - auto list = impl->reader.getVal348(); + auto list = impl->reader.getVal349(); if (n >= list.size()) { return std::nullopt; } @@ -411,12 +411,12 @@ std::optional ObjCInterfaceDecl::nth_known_extension(unsigned } gap::generator ObjCInterfaceDecl::known_extensions(void) const & { - auto list = impl->reader.getVal348(); + auto list = impl->reader.getVal349(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d348 = ep->DeclFor(ep, v)) { - if (auto e = ObjCCategoryDecl::from_base(std::move(d348))) { + if (auto d349 = ep->DeclFor(ep, v)) { + if (auto e = ObjCCategoryDecl::from_base(std::move(d349))) { co_yield std::move(*e); } } @@ -425,11 +425,11 @@ gap::generator ObjCInterfaceDecl::known_extensions(void) const } unsigned ObjCInterfaceDecl::num_protocol_tokens(void) const { - return impl->reader.getVal349().size(); + return impl->reader.getVal350().size(); } std::optional ObjCInterfaceDecl::nth_protocol_token(unsigned n) const { - auto list = impl->reader.getVal349(); + auto list = impl->reader.getVal350(); if (n >= list.size()) { return std::nullopt; } @@ -443,7 +443,7 @@ std::optional ObjCInterfaceDecl::nth_protocol_token(unsigned n) const { } gap::generator ObjCInterfaceDecl::protocol_tokens(void) const & { - auto list = impl->reader.getVal349(); + auto list = impl->reader.getVal350(); EntityProviderPtr ep = impl->ep; auto fragment = ep->FragmentFor(ep, impl->fragment_id); if (!fragment) { @@ -453,19 +453,19 @@ gap::generator ObjCInterfaceDecl::protocol_tokens(void) const & { auto tok_reader = fragment->ParsedTokenReader(fragment); for (auto v : list) { EntityId id(v); - if (auto t349 = ep->TokenFor(ep, tok_reader, v)) { - co_yield t349; + if (auto t350 = ep->TokenFor(ep, tok_reader, v)) { + co_yield t350; } } co_return; } unsigned ObjCInterfaceDecl::num_protocols(void) const { - return impl->reader.getVal350().size(); + return impl->reader.getVal351().size(); } std::optional ObjCInterfaceDecl::nth_protocol(unsigned n) const { - auto list = impl->reader.getVal350(); + auto list = impl->reader.getVal351(); if (n >= list.size()) { return std::nullopt; } @@ -479,12 +479,12 @@ std::optional ObjCInterfaceDecl::nth_protocol(unsigned n) cons } gap::generator ObjCInterfaceDecl::protocols(void) const & { - auto list = impl->reader.getVal350(); + auto list = impl->reader.getVal351(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d350 = ep->DeclFor(ep, v)) { - if (auto e = ObjCProtocolDecl::from_base(std::move(d350))) { + if (auto d351 = ep->DeclFor(ep, v)) { + if (auto e = ObjCProtocolDecl::from_base(std::move(d351))) { co_yield std::move(*e); } } @@ -493,11 +493,11 @@ gap::generator ObjCInterfaceDecl::protocols(void) const & { } unsigned ObjCInterfaceDecl::num_visible_categories(void) const { - return impl->reader.getVal351().size(); + return impl->reader.getVal352().size(); } std::optional ObjCInterfaceDecl::nth_visible_categorie(unsigned n) const { - auto list = impl->reader.getVal351(); + auto list = impl->reader.getVal352(); if (n >= list.size()) { return std::nullopt; } @@ -511,12 +511,12 @@ std::optional ObjCInterfaceDecl::nth_visible_categorie(unsigne } gap::generator ObjCInterfaceDecl::visible_categories(void) const & { - auto list = impl->reader.getVal351(); + auto list = impl->reader.getVal352(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d351 = ep->DeclFor(ep, v)) { - if (auto e = ObjCCategoryDecl::from_base(std::move(d351))) { + if (auto d352 = ep->DeclFor(ep, v)) { + if (auto e = ObjCCategoryDecl::from_base(std::move(d352))) { co_yield std::move(*e); } } @@ -525,11 +525,11 @@ gap::generator ObjCInterfaceDecl::visible_categories(void) con } unsigned ObjCInterfaceDecl::num_visible_extensions(void) const { - return impl->reader.getVal352().size(); + return impl->reader.getVal353().size(); } std::optional ObjCInterfaceDecl::nth_visible_extension(unsigned n) const { - auto list = impl->reader.getVal352(); + auto list = impl->reader.getVal353(); if (n >= list.size()) { return std::nullopt; } @@ -543,12 +543,12 @@ std::optional ObjCInterfaceDecl::nth_visible_extension(unsigne } gap::generator ObjCInterfaceDecl::visible_extensions(void) const & { - auto list = impl->reader.getVal352(); + auto list = impl->reader.getVal353(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d352 = ep->DeclFor(ep, v)) { - if (auto e = ObjCCategoryDecl::from_base(std::move(d352))) { + if (auto d353 = ep->DeclFor(ep, v)) { + if (auto e = ObjCCategoryDecl::from_base(std::move(d353))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCIsaExpr.cpp b/lib/AST/ObjCIsaExpr.cpp index 93db99592..ad935f3aa 100644 --- a/lib/AST/ObjCIsaExpr.cpp +++ b/lib/AST/ObjCIsaExpr.cpp @@ -183,24 +183,24 @@ std::optional ObjCIsaExpr::from(const TokenContext &t) { } Expr ObjCIsaExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token ObjCIsaExpr::base_token_end(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Token ObjCIsaExpr::isa_member_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token ObjCIsaExpr::operation_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } bool ObjCIsaExpr::is_arrow(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCIvarDecl.cpp b/lib/AST/ObjCIvarDecl.cpp index 883a99a83..43f59fe09 100644 --- a/lib/AST/ObjCIvarDecl.cpp +++ b/lib/AST/ObjCIvarDecl.cpp @@ -215,25 +215,25 @@ std::optional ObjCIvarDecl::from(const TokenContext &t) { } ObjCIvarDeclAccessControl ObjCIvarDecl::access_control(void) const { - return static_cast(impl->reader.getVal76()); + return static_cast(impl->reader.getVal77()); } ObjCIvarDeclAccessControl ObjCIvarDecl::canonical_access_control(void) const { - return static_cast(impl->reader.getVal77()); + return static_cast(impl->reader.getVal78()); } ObjCInterfaceDecl ObjCIvarDecl::containing_interface(void) const { - RawEntityId eid = impl->reader.getVal113(); + RawEntityId eid = impl->reader.getVal114(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCIvarDecl ObjCIvarDecl::next_instance_variable(void) const { - RawEntityId eid = impl->reader.getVal114(); + RawEntityId eid = impl->reader.getVal115(); return ObjCIvarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } bool ObjCIvarDecl::synthesize(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCIvarRefExpr.cpp b/lib/AST/ObjCIvarRefExpr.cpp index 14d2e6272..05e475bdf 100644 --- a/lib/AST/ObjCIvarRefExpr.cpp +++ b/lib/AST/ObjCIvarRefExpr.cpp @@ -184,29 +184,29 @@ std::optional ObjCIvarRefExpr::from(const TokenContext &t) { } Expr ObjCIvarRefExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } ObjCIvarDecl ObjCIvarRefExpr::declaration(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return ObjCIvarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCIvarRefExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token ObjCIvarRefExpr::operation_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } bool ObjCIvarRefExpr::is_arrow(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool ObjCIvarRefExpr::is_free_instance_variable(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCMessageExpr.cpp b/lib/AST/ObjCMessageExpr.cpp index 3b4706412..e2ce85d55 100644 --- a/lib/AST/ObjCMessageExpr.cpp +++ b/lib/AST/ObjCMessageExpr.cpp @@ -187,11 +187,11 @@ std::optional ObjCMessageExpr::from(const TokenContext &t) { } unsigned ObjCMessageExpr::num_arguments(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional ObjCMessageExpr::nth_argument(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -205,12 +205,12 @@ std::optional ObjCMessageExpr::nth_argument(unsigned n) const { } gap::generator ObjCMessageExpr::arguments(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -219,90 +219,90 @@ gap::generator ObjCMessageExpr::arguments(void) const & { } Type ObjCMessageExpr::call_return_type(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Type ObjCMessageExpr::class_receiver(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Expr ObjCMessageExpr::instance_receiver(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token ObjCMessageExpr::left_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } ObjCMethodDecl ObjCMessageExpr::method_declaration(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCMethodFamily ObjCMessageExpr::method_family(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } ObjCInterfaceDecl ObjCMessageExpr::receiver_interface(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCMessageExprReceiverKind ObjCMessageExpr::receiver_kind(void) const { - return static_cast(impl->reader.getVal91()); + return static_cast(impl->reader.getVal92()); } TokenRange ObjCMessageExpr::receiver_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal44(), impl->reader.getVal45()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal45(), impl->reader.getVal46()); } Type ObjCMessageExpr::receiver_type(void) const { - RawEntityId eid = impl->reader.getVal46(); + RawEntityId eid = impl->reader.getVal47(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Token ObjCMessageExpr::right_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal47()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); } Token ObjCMessageExpr::selector_start_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } Token ObjCMessageExpr::super_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); } Type ObjCMessageExpr::super_type(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool ObjCMessageExpr::is_class_message(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool ObjCMessageExpr::is_delegate_initializer_call(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool ObjCMessageExpr::is_implicit(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool ObjCMessageExpr::is_instance_message(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } unsigned ObjCMessageExpr::num_selector_tokens(void) const { - return impl->reader.getVal27().size(); + return impl->reader.getVal28().size(); } std::optional ObjCMessageExpr::nth_selector_token(unsigned n) const { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); if (n >= list.size()) { return std::nullopt; } @@ -316,7 +316,7 @@ std::optional ObjCMessageExpr::nth_selector_token(unsigned n) const { } gap::generator ObjCMessageExpr::selector_tokens(void) const & { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); EntityProviderPtr ep = impl->ep; auto fragment = ep->FragmentFor(ep, impl->fragment_id); if (!fragment) { @@ -326,8 +326,8 @@ gap::generator ObjCMessageExpr::selector_tokens(void) const & { auto tok_reader = fragment->ParsedTokenReader(fragment); for (auto v : list) { EntityId id(v); - if (auto t27 = ep->TokenFor(ep, tok_reader, v)) { - co_yield t27; + if (auto t28 = ep->TokenFor(ep, tok_reader, v)) { + co_yield t28; } } co_return; diff --git a/lib/AST/ObjCMethodDecl.cpp b/lib/AST/ObjCMethodDecl.cpp index fa0984cb1..258602ef7 100644 --- a/lib/AST/ObjCMethodDecl.cpp +++ b/lib/AST/ObjCMethodDecl.cpp @@ -218,132 +218,132 @@ std::optional ObjCMethodDecl::from(const TokenContext &t) { } bool ObjCMethodDecl::defined_in_ns_object(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } ObjCPropertyDecl ObjCMethodDecl::find_property_declaration(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return ObjCPropertyDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCInterfaceDecl ObjCMethodDecl::class_interface(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ImplicitParamDecl ObjCMethodDecl::command_declaration(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return ImplicitParamDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCMethodDecl::declarator_end_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } ObjCImplementationControl ObjCMethodDecl::implementation_control(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } ObjCMethodFamily ObjCMethodDecl::method_family(void) const { - return static_cast(impl->reader.getVal76()); + return static_cast(impl->reader.getVal77()); } DeclObjCDeclQualifier ObjCMethodDecl::obj_c_decl_qualifier(void) const { - return static_cast(impl->reader.getVal77()); + return static_cast(impl->reader.getVal78()); } Type ObjCMethodDecl::return_type(void) const { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); return Type(impl->ep->TypeFor(impl->ep, eid)); } TokenRange ObjCMethodDecl::return_type_tokens(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal60(), impl->reader.getVal70()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal61(), impl->reader.getVal71()); } Token ObjCMethodDecl::selector_start_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal71()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal72()); } ImplicitParamDecl ObjCMethodDecl::self_declaration(void) const { - RawEntityId eid = impl->reader.getVal73(); + RawEntityId eid = impl->reader.getVal74(); return ImplicitParamDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } bool ObjCMethodDecl::has_parameter_destroyed_in_callee(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool ObjCMethodDecl::has_redeclaration(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool ObjCMethodDecl::has_related_result_type(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool ObjCMethodDecl::has_skipped_body(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool ObjCMethodDecl::is_class_method(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } bool ObjCMethodDecl::is_defined(void) const { - return impl->reader.getVal83(); + return impl->reader.getVal84(); } bool ObjCMethodDecl::is_designated_initializer_for_the_interface(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool ObjCMethodDecl::is_direct_method(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool ObjCMethodDecl::is_instance_method(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool ObjCMethodDecl::is_optional(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool ObjCMethodDecl::is_overriding(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool ObjCMethodDecl::is_property_accessor(void) const { - return impl->reader.getVal89(); + return impl->reader.getVal90(); } bool ObjCMethodDecl::is_redeclaration(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool ObjCMethodDecl::is_synthesized_accessor_stub(void) const { - return impl->reader.getVal91(); + return impl->reader.getVal92(); } bool ObjCMethodDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool ObjCMethodDecl::is_this_declaration_a_designated_initializer(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool ObjCMethodDecl::is_variadic(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } unsigned ObjCMethodDecl::num_parameters(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional ObjCMethodDecl::nth_parameter(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -357,12 +357,12 @@ std::optional ObjCMethodDecl::nth_parameter(unsigned n) const { } gap::generator ObjCMethodDecl::parameters(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->DeclFor(ep, v)) { - if (auto e = ParmVarDecl::from_base(std::move(d43))) { + if (auto d44 = ep->DeclFor(ep, v)) { + if (auto e = ParmVarDecl::from_base(std::move(d44))) { co_yield std::move(*e); } } @@ -371,11 +371,11 @@ gap::generator ObjCMethodDecl::parameters(void) const & { } unsigned ObjCMethodDecl::num_selector_tokens(void) const { - return impl->reader.getVal44().size(); + return impl->reader.getVal45().size(); } std::optional ObjCMethodDecl::nth_selector_token(unsigned n) const { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); if (n >= list.size()) { return std::nullopt; } @@ -389,7 +389,7 @@ std::optional ObjCMethodDecl::nth_selector_token(unsigned n) const { } gap::generator ObjCMethodDecl::selector_tokens(void) const & { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); EntityProviderPtr ep = impl->ep; auto fragment = ep->FragmentFor(ep, impl->fragment_id); if (!fragment) { @@ -399,8 +399,8 @@ gap::generator ObjCMethodDecl::selector_tokens(void) const & { auto tok_reader = fragment->ParsedTokenReader(fragment); for (auto v : list) { EntityId id(v); - if (auto t44 = ep->TokenFor(ep, tok_reader, v)) { - co_yield t44; + if (auto t45 = ep->TokenFor(ep, tok_reader, v)) { + co_yield t45; } } co_return; diff --git a/lib/AST/ObjCPropertyDecl.cpp b/lib/AST/ObjCPropertyDecl.cpp index 1dcf30e51..3134f3509 100644 --- a/lib/AST/ObjCPropertyDecl.cpp +++ b/lib/AST/ObjCPropertyDecl.cpp @@ -214,79 +214,79 @@ std::optional ObjCPropertyDecl::from(const TokenContext &t) { } Token ObjCPropertyDecl::at_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } ObjCMethodDecl ObjCPropertyDecl::getter_method_declaration(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCPropertyDecl::getter_name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal51()); } Token ObjCPropertyDecl::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } ObjCPropertyDeclPropertyControl ObjCPropertyDecl::property_implementation(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } ObjCIvarDecl ObjCPropertyDecl::property_instance_variable_declaration(void) const { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); return ObjCIvarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCPropertyQueryKind ObjCPropertyDecl::query_kind(void) const { - return static_cast(impl->reader.getVal76()); + return static_cast(impl->reader.getVal77()); } ObjCPropertyDeclSetterKind ObjCPropertyDecl::setter_kind(void) const { - return static_cast(impl->reader.getVal77()); + return static_cast(impl->reader.getVal78()); } ObjCMethodDecl ObjCPropertyDecl::setter_method_declaration(void) const { - RawEntityId eid = impl->reader.getVal60(); + RawEntityId eid = impl->reader.getVal61(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCPropertyDecl::setter_name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal70()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal71()); } Type ObjCPropertyDecl::type(void) const { - RawEntityId eid = impl->reader.getVal71(); + RawEntityId eid = impl->reader.getVal72(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool ObjCPropertyDecl::is_atomic(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool ObjCPropertyDecl::is_class_property(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool ObjCPropertyDecl::is_direct_property(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool ObjCPropertyDecl::is_instance_property(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool ObjCPropertyDecl::is_optional(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool ObjCPropertyDecl::is_read_only(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } bool ObjCPropertyDecl::is_retaining(void) const { - return impl->reader.getVal83(); + return impl->reader.getVal84(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCPropertyImplDecl.cpp b/lib/AST/ObjCPropertyImplDecl.cpp index 38d97d749..85cc9cd5b 100644 --- a/lib/AST/ObjCPropertyImplDecl.cpp +++ b/lib/AST/ObjCPropertyImplDecl.cpp @@ -214,45 +214,45 @@ std::optional ObjCPropertyImplDecl::from(const TokenContex } Expr ObjCPropertyImplDecl::getter_cxx_constructor(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } ObjCMethodDecl ObjCPropertyImplDecl::getter_method_declaration(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCPropertyDecl ObjCPropertyImplDecl::property_declaration(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return ObjCPropertyDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCPropertyImplDeclKind ObjCPropertyImplDecl::property_implementation(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } ObjCIvarDecl ObjCPropertyImplDecl::property_instance_variable_declaration(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return ObjCIvarDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCPropertyImplDecl::property_instance_variable_declaration_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } Expr ObjCPropertyImplDecl::setter_cxx_assignment(void) const { - RawEntityId eid = impl->reader.getVal59(); + RawEntityId eid = impl->reader.getVal60(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } ObjCMethodDecl ObjCPropertyImplDecl::setter_method_declaration(void) const { - RawEntityId eid = impl->reader.getVal60(); + RawEntityId eid = impl->reader.getVal61(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } bool ObjCPropertyImplDecl::is_instance_variable_name_specified(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCPropertyRefExpr.cpp b/lib/AST/ObjCPropertyRefExpr.cpp index 556279d38..55fa687e1 100644 --- a/lib/AST/ObjCPropertyRefExpr.cpp +++ b/lib/AST/ObjCPropertyRefExpr.cpp @@ -187,74 +187,74 @@ std::optional ObjCPropertyRefExpr::from(const TokenContext } Expr ObjCPropertyRefExpr::base(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } ObjCInterfaceDecl ObjCPropertyRefExpr::class_receiver(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return ObjCInterfaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCPropertyDecl ObjCPropertyRefExpr::explicit_property(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return ObjCPropertyDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCMethodDecl ObjCPropertyRefExpr::implicit_property_getter(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } ObjCMethodDecl ObjCPropertyRefExpr::implicit_property_setter(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCPropertyRefExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); } Token ObjCPropertyRefExpr::receiver_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } Type ObjCPropertyRefExpr::receiver_type(void) const { - RawEntityId eid = impl->reader.getVal45(); + RawEntityId eid = impl->reader.getVal46(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Type ObjCPropertyRefExpr::super_receiver_type(void) const { - RawEntityId eid = impl->reader.getVal46(); + RawEntityId eid = impl->reader.getVal47(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool ObjCPropertyRefExpr::is_class_receiver(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool ObjCPropertyRefExpr::is_explicit_property(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool ObjCPropertyRefExpr::is_implicit_property(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool ObjCPropertyRefExpr::is_messaging_getter(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool ObjCPropertyRefExpr::is_messaging_setter(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool ObjCPropertyRefExpr::is_object_receiver(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool ObjCPropertyRefExpr::is_super_receiver(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCProtocolDecl.cpp b/lib/AST/ObjCProtocolDecl.cpp index e717635de..245832976 100644 --- a/lib/AST/ObjCProtocolDecl.cpp +++ b/lib/AST/ObjCProtocolDecl.cpp @@ -214,28 +214,28 @@ std::optional ObjCProtocolDecl::from(const TokenContext &t) { } std::string_view ObjCProtocolDecl::obj_c_runtime_name_as_string(void) const { - capnp::Text::Reader data = impl->reader.getVal56(); + capnp::Text::Reader data = impl->reader.getVal57(); return std::string_view(data.cStr(), data.size()); } bool ObjCProtocolDecl::has_definition(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool ObjCProtocolDecl::is_non_runtime_protocol(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool ObjCProtocolDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } unsigned ObjCProtocolDecl::num_protocol_tokens(void) const { - return impl->reader.getVal329().size(); + return impl->reader.getVal330().size(); } std::optional ObjCProtocolDecl::nth_protocol_token(unsigned n) const { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); if (n >= list.size()) { return std::nullopt; } @@ -249,7 +249,7 @@ std::optional ObjCProtocolDecl::nth_protocol_token(unsigned n) const { } gap::generator ObjCProtocolDecl::protocol_tokens(void) const & { - auto list = impl->reader.getVal329(); + auto list = impl->reader.getVal330(); EntityProviderPtr ep = impl->ep; auto fragment = ep->FragmentFor(ep, impl->fragment_id); if (!fragment) { @@ -259,19 +259,19 @@ gap::generator ObjCProtocolDecl::protocol_tokens(void) const & { auto tok_reader = fragment->ParsedTokenReader(fragment); for (auto v : list) { EntityId id(v); - if (auto t329 = ep->TokenFor(ep, tok_reader, v)) { - co_yield t329; + if (auto t330 = ep->TokenFor(ep, tok_reader, v)) { + co_yield t330; } } co_return; } unsigned ObjCProtocolDecl::num_protocols(void) const { - return impl->reader.getVal340().size(); + return impl->reader.getVal341().size(); } std::optional ObjCProtocolDecl::nth_protocol(unsigned n) const { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); if (n >= list.size()) { return std::nullopt; } @@ -285,12 +285,12 @@ std::optional ObjCProtocolDecl::nth_protocol(unsigned n) const } gap::generator ObjCProtocolDecl::protocols(void) const & { - auto list = impl->reader.getVal340(); + auto list = impl->reader.getVal341(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d340 = ep->DeclFor(ep, v)) { - if (auto e = ObjCProtocolDecl::from_base(std::move(d340))) { + if (auto d341 = ep->DeclFor(ep, v)) { + if (auto e = ObjCProtocolDecl::from_base(std::move(d341))) { co_yield std::move(*e); } } diff --git a/lib/AST/ObjCProtocolExpr.cpp b/lib/AST/ObjCProtocolExpr.cpp index fdd10ea3a..441721ffa 100644 --- a/lib/AST/ObjCProtocolExpr.cpp +++ b/lib/AST/ObjCProtocolExpr.cpp @@ -184,20 +184,20 @@ std::optional ObjCProtocolExpr::from(const TokenContext &t) { } Token ObjCProtocolExpr::at_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } ObjCProtocolDecl ObjCProtocolExpr::protocol(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return ObjCProtocolDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token ObjCProtocolExpr::protocol_id_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token ObjCProtocolExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCSelectorExpr.cpp b/lib/AST/ObjCSelectorExpr.cpp index f04a383cd..f5a5873a9 100644 --- a/lib/AST/ObjCSelectorExpr.cpp +++ b/lib/AST/ObjCSelectorExpr.cpp @@ -183,11 +183,11 @@ std::optional ObjCSelectorExpr::from(const TokenContext &t) { } Token ObjCSelectorExpr::at_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token ObjCSelectorExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCStringLiteral.cpp b/lib/AST/ObjCStringLiteral.cpp index 9c82bf571..dd781f77f 100644 --- a/lib/AST/ObjCStringLiteral.cpp +++ b/lib/AST/ObjCStringLiteral.cpp @@ -184,11 +184,11 @@ std::optional ObjCStringLiteral::from(const TokenContext &t) } Token ObjCStringLiteral::at_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } StringLiteral ObjCStringLiteral::string(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return StringLiteral::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ObjCSubscriptRefExpr.cpp b/lib/AST/ObjCSubscriptRefExpr.cpp index d1d99e144..bff4a7c37 100644 --- a/lib/AST/ObjCSubscriptRefExpr.cpp +++ b/lib/AST/ObjCSubscriptRefExpr.cpp @@ -184,26 +184,26 @@ std::optional ObjCSubscriptRefExpr::from(const TokenContex } ObjCMethodDecl ObjCSubscriptRefExpr::at_index_method_declaration(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return ObjCMethodDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Expr ObjCSubscriptRefExpr::base_expression(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Expr ObjCSubscriptRefExpr::key_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token ObjCSubscriptRefExpr::r_bracket_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } bool ObjCSubscriptRefExpr::is_array_subscript_reference_expression(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ObjCTypeParamDecl.cpp b/lib/AST/ObjCTypeParamDecl.cpp index 20f3b3b99..ef300583e 100644 --- a/lib/AST/ObjCTypeParamDecl.cpp +++ b/lib/AST/ObjCTypeParamDecl.cpp @@ -213,23 +213,23 @@ std::optional ObjCTypeParamDecl::from(const TokenContext &t) } Token ObjCTypeParamDecl::colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } uint32_t ObjCTypeParamDecl::index(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } ObjCTypeParamVariance ObjCTypeParamDecl::variance(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } Token ObjCTypeParamDecl::variance_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); } bool ObjCTypeParamDecl::has_explicit_bound(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OffsetOfExpr.cpp b/lib/AST/OffsetOfExpr.cpp index 748d91b84..b7af2051a 100644 --- a/lib/AST/OffsetOfExpr.cpp +++ b/lib/AST/OffsetOfExpr.cpp @@ -183,11 +183,11 @@ std::optional OffsetOfExpr::from(const TokenContext &t) { } Token OffsetOfExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token OffsetOfExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } #pragma GCC diagnostic pop diff --git a/lib/AST/OpaqueValueExpr.cpp b/lib/AST/OpaqueValueExpr.cpp index 4c51ba6c3..887197ffb 100644 --- a/lib/AST/OpaqueValueExpr.cpp +++ b/lib/AST/OpaqueValueExpr.cpp @@ -183,12 +183,12 @@ std::optional OpaqueValueExpr::from(const TokenContext &t) { } Token OpaqueValueExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } std::optional OpaqueValueExpr::source_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -200,7 +200,7 @@ std::optional OpaqueValueExpr::source_expression(void) const { } bool OpaqueValueExpr::is_unique(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/OverloadExpr.cpp b/lib/AST/OverloadExpr.cpp index 9fe8e9517..d0e604d04 100644 --- a/lib/AST/OverloadExpr.cpp +++ b/lib/AST/OverloadExpr.cpp @@ -189,11 +189,11 @@ std::optional OverloadExpr::from(const TokenContext &t) { } unsigned OverloadExpr::num_declarations(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional OverloadExpr::nth_declaration(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -207,12 +207,12 @@ std::optional OverloadExpr::nth_declaration(unsigned n) const { } gap::generator OverloadExpr::declarations(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->DeclFor(ep, v)) { - if (auto e = NamedDecl::from_base(std::move(d15))) { + if (auto d16 = ep->DeclFor(ep, v)) { + if (auto e = NamedDecl::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -221,16 +221,16 @@ gap::generator OverloadExpr::declarations(void) const & { } Token OverloadExpr::l_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token OverloadExpr::name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } std::optional OverloadExpr::naming_class(void) const { if (true) { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -242,19 +242,19 @@ std::optional OverloadExpr::naming_class(void) const { } Token OverloadExpr::r_angle_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Token OverloadExpr::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } bool OverloadExpr::has_explicit_template_arguments(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool OverloadExpr::has_template_keyword(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/PackExpansionExpr.cpp b/lib/AST/PackExpansionExpr.cpp index 5004e13b9..1e2f70520 100644 --- a/lib/AST/PackExpansionExpr.cpp +++ b/lib/AST/PackExpansionExpr.cpp @@ -183,11 +183,11 @@ std::optional PackExpansionExpr::from(const TokenContext &t) } Token PackExpansionExpr::ellipsis_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Expr PackExpansionExpr::pattern(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ParenExpr.cpp b/lib/AST/ParenExpr.cpp index ad6211bed..914e3c9ef 100644 --- a/lib/AST/ParenExpr.cpp +++ b/lib/AST/ParenExpr.cpp @@ -183,15 +183,15 @@ std::optional ParenExpr::from(const TokenContext &t) { } Token ParenExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token ParenExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Expr ParenExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/ParenListExpr.cpp b/lib/AST/ParenListExpr.cpp index 13a53df41..5d89bc498 100644 --- a/lib/AST/ParenListExpr.cpp +++ b/lib/AST/ParenListExpr.cpp @@ -183,19 +183,19 @@ std::optional ParenListExpr::from(const TokenContext &t) { } Token ParenListExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token ParenListExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } unsigned ParenListExpr::num_expressions(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional ParenListExpr::nth_expression(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -209,12 +209,12 @@ std::optional ParenListExpr::nth_expression(unsigned n) const { } gap::generator ParenListExpr::expressions(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/ParmVarDecl.cpp b/lib/AST/ParmVarDecl.cpp index 6d4a7695f..bea5dd724 100644 --- a/lib/AST/ParmVarDecl.cpp +++ b/lib/AST/ParmVarDecl.cpp @@ -218,7 +218,7 @@ std::optional ParmVarDecl::from(const TokenContext &t) { std::optional ParmVarDecl::default_argument(void) const { if (true) { - RawEntityId eid = impl->reader.getVal113(); + RawEntityId eid = impl->reader.getVal114(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -230,33 +230,33 @@ std::optional ParmVarDecl::default_argument(void) const { } TokenRange ParmVarDecl::default_argument_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal114(), impl->reader.getVal115()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal115(), impl->reader.getVal116()); } Token ParmVarDecl::explicit_object_parameter_this_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal116()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal117()); } uint32_t ParmVarDecl::depth(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } uint32_t ParmVarDecl::index(void) const { - return impl->reader.getVal117(); + return impl->reader.getVal118(); } DeclObjCDeclQualifier ParmVarDecl::obj_c_decl_qualifier(void) const { - return static_cast(impl->reader.getVal118()); + return static_cast(impl->reader.getVal119()); } Type ParmVarDecl::original_type(void) const { - RawEntityId eid = impl->reader.getVal119(); + RawEntityId eid = impl->reader.getVal120(); return Type(impl->ep->TypeFor(impl->ep, eid)); } std::optional ParmVarDecl::uninstantiated_default_argument(void) const { if (true) { - RawEntityId eid = impl->reader.getVal120(); + RawEntityId eid = impl->reader.getVal121(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -268,35 +268,35 @@ std::optional ParmVarDecl::uninstantiated_default_argument(void) const { } bool ParmVarDecl::has_default_argument(void) const { - return impl->reader.getVal121(); + return impl->reader.getVal122(); } bool ParmVarDecl::has_inherited_default_argument(void) const { - return impl->reader.getVal122(); + return impl->reader.getVal123(); } bool ParmVarDecl::has_uninstantiated_default_argument(void) const { - return impl->reader.getVal123(); + return impl->reader.getVal124(); } bool ParmVarDecl::has_unparsed_default_argument(void) const { - return impl->reader.getVal124(); + return impl->reader.getVal125(); } bool ParmVarDecl::is_destroyed_in_callee(void) const { - return impl->reader.getVal125(); + return impl->reader.getVal126(); } bool ParmVarDecl::is_explicit_object_parameter(void) const { - return impl->reader.getVal126(); + return impl->reader.getVal127(); } bool ParmVarDecl::is_knr_promoted(void) const { - return impl->reader.getVal127(); + return impl->reader.getVal128(); } bool ParmVarDecl::is_obj_c_method_parameter(void) const { - return impl->reader.getVal128(); + return impl->reader.getVal129(); } #pragma GCC diagnostic pop diff --git a/lib/AST/PragmaCommentDecl.cpp b/lib/AST/PragmaCommentDecl.cpp index 628b825ce..0801e5fab 100644 --- a/lib/AST/PragmaCommentDecl.cpp +++ b/lib/AST/PragmaCommentDecl.cpp @@ -210,12 +210,12 @@ std::optional PragmaCommentDecl::from(const TokenContext &t) } std::string_view PragmaCommentDecl::argument(void) const { - capnp::Text::Reader data = impl->reader.getVal55(); + capnp::Text::Reader data = impl->reader.getVal56(); return std::string_view(data.cStr(), data.size()); } PragmaMSCommentKind PragmaCommentDecl::comment_kind(void) const { - return static_cast(impl->reader.getVal57()); + return static_cast(impl->reader.getVal58()); } #pragma GCC diagnostic pop diff --git a/lib/AST/PragmaDetectMismatchDecl.cpp b/lib/AST/PragmaDetectMismatchDecl.cpp index 2202cddff..0b8e8377b 100644 --- a/lib/AST/PragmaDetectMismatchDecl.cpp +++ b/lib/AST/PragmaDetectMismatchDecl.cpp @@ -210,12 +210,12 @@ std::optional PragmaDetectMismatchDecl::from(const Tok } std::string_view PragmaDetectMismatchDecl::name(void) const { - capnp::Text::Reader data = impl->reader.getVal55(); + capnp::Text::Reader data = impl->reader.getVal56(); return std::string_view(data.cStr(), data.size()); } std::string_view PragmaDetectMismatchDecl::value(void) const { - capnp::Text::Reader data = impl->reader.getVal56(); + capnp::Text::Reader data = impl->reader.getVal57(); return std::string_view(data.cStr(), data.size()); } diff --git a/lib/AST/PredefinedExpr.cpp b/lib/AST/PredefinedExpr.cpp index 11d826218..7752b333c 100644 --- a/lib/AST/PredefinedExpr.cpp +++ b/lib/AST/PredefinedExpr.cpp @@ -185,7 +185,7 @@ std::optional PredefinedExpr::from(const TokenContext &t) { std::optional PredefinedExpr::function_name(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -197,20 +197,20 @@ std::optional PredefinedExpr::function_name(void) const { } PredefinedIdentKind PredefinedExpr::identifier_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } std::string_view PredefinedExpr::identifier_kind_name(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } Token PredefinedExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } bool PredefinedExpr::is_transparent(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/PseudoObjectExpr.cpp b/lib/AST/PseudoObjectExpr.cpp index fc0894753..c4753a1cc 100644 --- a/lib/AST/PseudoObjectExpr.cpp +++ b/lib/AST/PseudoObjectExpr.cpp @@ -183,25 +183,25 @@ std::optional PseudoObjectExpr::from(const TokenContext &t) { } Expr PseudoObjectExpr::result_expression(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } uint32_t PseudoObjectExpr::result_expression_index(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } Expr PseudoObjectExpr::syntactic_form(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } unsigned PseudoObjectExpr::num_semantics(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional PseudoObjectExpr::nth_semantic(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -215,12 +215,12 @@ std::optional PseudoObjectExpr::nth_semantic(unsigned n) const { } gap::generator PseudoObjectExpr::semantics(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -229,11 +229,11 @@ gap::generator PseudoObjectExpr::semantics(void) const & { } unsigned PseudoObjectExpr::num_semantic_expressions(void) const { - return impl->reader.getVal27().size(); + return impl->reader.getVal28().size(); } std::optional PseudoObjectExpr::nth_semantic_expression(unsigned n) const { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); if (n >= list.size()) { return std::nullopt; } @@ -247,12 +247,12 @@ std::optional PseudoObjectExpr::nth_semantic_expression(unsigned n) const } gap::generator PseudoObjectExpr::semantic_expressions(void) const & { - auto list = impl->reader.getVal27(); + auto list = impl->reader.getVal28(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d27 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d27))) { + if (auto d28 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d28))) { co_yield std::move(*e); } } diff --git a/lib/AST/RecordDecl.cpp b/lib/AST/RecordDecl.cpp index 050893e43..d71f95a99 100644 --- a/lib/AST/RecordDecl.cpp +++ b/lib/AST/RecordDecl.cpp @@ -224,15 +224,15 @@ std::optional RecordDecl::from(const TokenContext &t) { } bool RecordDecl::can_pass_in_registers(void) const { - return impl->reader.getVal91(); + return impl->reader.getVal92(); } unsigned RecordDecl::num_fields(void) const { - return impl->reader.getVal54().size(); + return impl->reader.getVal55().size(); } std::optional RecordDecl::nth_field(unsigned n) const { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); if (n >= list.size()) { return std::nullopt; } @@ -246,12 +246,12 @@ std::optional RecordDecl::nth_field(unsigned n) const { } gap::generator RecordDecl::fields(void) const & { - auto list = impl->reader.getVal54(); + auto list = impl->reader.getVal55(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d54 = ep->DeclFor(ep, v)) { - if (auto e = FieldDecl::from_base(std::move(d54))) { + if (auto d55 = ep->DeclFor(ep, v)) { + if (auto e = FieldDecl::from_base(std::move(d55))) { co_yield std::move(*e); } } @@ -260,108 +260,108 @@ gap::generator RecordDecl::fields(void) const & { } RecordArgPassingKind RecordDecl::argument_passing_restrictions(void) const { - return static_cast(impl->reader.getVal76()); + return static_cast(impl->reader.getVal77()); } bool RecordDecl::has_flexible_array_member(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool RecordDecl::has_loaded_fields_from_external_storage(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool RecordDecl::has_non_trivial_to_primitive_copy_c_union(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } bool RecordDecl::has_non_trivial_to_primitive_default_initialize_c_union(void) const { - return impl->reader.getVal95(); + return impl->reader.getVal96(); } bool RecordDecl::has_non_trivial_to_primitive_destruct_c_union(void) const { - return impl->reader.getVal96(); + return impl->reader.getVal97(); } bool RecordDecl::has_object_member(void) const { - return impl->reader.getVal97(); + return impl->reader.getVal98(); } bool RecordDecl::has_volatile_member(void) const { - return impl->reader.getVal98(); + return impl->reader.getVal99(); } bool RecordDecl::is_anonymous_struct_or_union(void) const { - return impl->reader.getVal99(); + return impl->reader.getVal100(); } bool RecordDecl::is_captured_record(void) const { - return impl->reader.getVal100(); + return impl->reader.getVal101(); } bool RecordDecl::is_injected_class_name(void) const { - return impl->reader.getVal101(); + return impl->reader.getVal102(); } bool RecordDecl::is_lambda(void) const { - return impl->reader.getVal102(); + return impl->reader.getVal103(); } bool RecordDecl::is_ms_struct(void) const { - return impl->reader.getVal103(); + return impl->reader.getVal104(); } bool RecordDecl::is_non_trivial_to_primitive_copy(void) const { - return impl->reader.getVal104(); + return impl->reader.getVal105(); } bool RecordDecl::is_non_trivial_to_primitive_default_initialize(void) const { - return impl->reader.getVal105(); + return impl->reader.getVal106(); } bool RecordDecl::is_non_trivial_to_primitive_destroy(void) const { - return impl->reader.getVal106(); + return impl->reader.getVal107(); } bool RecordDecl::is_or_contains_union(void) const { - return impl->reader.getVal107(); + return impl->reader.getVal108(); } bool RecordDecl::is_parameter_destroyed_in_callee(void) const { - return impl->reader.getVal108(); + return impl->reader.getVal109(); } bool RecordDecl::is_randomized(void) const { - return impl->reader.getVal109(); + return impl->reader.getVal110(); } bool RecordDecl::may_insert_extra_padding(void) const { - return impl->reader.getVal110(); + return impl->reader.getVal111(); } std::optional RecordDecl::size(void) const { - if (!impl->reader.getVal111()) { + if (!impl->reader.getVal112()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal70()); + return static_cast(impl->reader.getVal71()); } return std::nullopt; } std::optional RecordDecl::alignment(void) const { - if (!impl->reader.getVal112()) { + if (!impl->reader.getVal113()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal71()); + return static_cast(impl->reader.getVal72()); } return std::nullopt; } std::optional RecordDecl::size_without_trailing_padding(void) const { - if (!impl->reader.getVal121()) { + if (!impl->reader.getVal122()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal73()); + return static_cast(impl->reader.getVal74()); } return std::nullopt; } diff --git a/lib/AST/RecoveryExpr.cpp b/lib/AST/RecoveryExpr.cpp index cc8aa4c5f..2fa05719b 100644 --- a/lib/AST/RecoveryExpr.cpp +++ b/lib/AST/RecoveryExpr.cpp @@ -183,11 +183,11 @@ std::optional RecoveryExpr::from(const TokenContext &t) { } unsigned RecoveryExpr::num_sub_expressions(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional RecoveryExpr::nth_sub_expression(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -201,12 +201,12 @@ std::optional RecoveryExpr::nth_sub_expression(unsigned n) const { } gap::generator RecoveryExpr::sub_expressions(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->StmtFor(ep, v)) { - if (auto e = Expr::from_base(std::move(d15))) { + if (auto d16 = ep->StmtFor(ep, v)) { + if (auto e = Expr::from_base(std::move(d16))) { co_yield std::move(*e); } } diff --git a/lib/AST/RedeclarableTemplateDecl.cpp b/lib/AST/RedeclarableTemplateDecl.cpp index 0976f8d2b..427345b63 100644 --- a/lib/AST/RedeclarableTemplateDecl.cpp +++ b/lib/AST/RedeclarableTemplateDecl.cpp @@ -222,7 +222,7 @@ std::optional RedeclarableTemplateDecl::from(const Tok } bool RedeclarableTemplateDecl::is_member_specialization(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } #pragma GCC diagnostic pop diff --git a/lib/AST/RequiresExpr.cpp b/lib/AST/RequiresExpr.cpp index a4341256c..f4600e46c 100644 --- a/lib/AST/RequiresExpr.cpp +++ b/lib/AST/RequiresExpr.cpp @@ -185,20 +185,20 @@ std::optional RequiresExpr::from(const TokenContext &t) { } RequiresExprBodyDecl RequiresExpr::body(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return RequiresExprBodyDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token RequiresExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } unsigned RequiresExpr::num_local_parameters(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional RequiresExpr::nth_local_parameter(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -212,12 +212,12 @@ std::optional RequiresExpr::nth_local_parameter(unsigned n) const { } gap::generator RequiresExpr::local_parameters(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->DeclFor(ep, v)) { - if (auto e = ParmVarDecl::from_base(std::move(d15))) { + if (auto d16 = ep->DeclFor(ep, v)) { + if (auto e = ParmVarDecl::from_base(std::move(d16))) { co_yield std::move(*e); } } @@ -226,15 +226,15 @@ gap::generator RequiresExpr::local_parameters(void) const & { } Token RequiresExpr::r_brace_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token RequiresExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Token RequiresExpr::requires_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal43()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ReturnStmt.cpp b/lib/AST/ReturnStmt.cpp index 79862c35c..6da1a0198 100644 --- a/lib/AST/ReturnStmt.cpp +++ b/lib/AST/ReturnStmt.cpp @@ -184,7 +184,7 @@ std::optional ReturnStmt::from(const TokenContext &t) { std::optional ReturnStmt::nrvo_candidate(void) const { if (true) { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -197,7 +197,7 @@ std::optional ReturnStmt::nrvo_candidate(void) const { std::optional ReturnStmt::return_value(void) const { if (true) { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -209,7 +209,7 @@ std::optional ReturnStmt::return_value(void) const { } Token ReturnStmt::return_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal12()); } #pragma GCC diagnostic pop diff --git a/lib/AST/SEHExceptStmt.cpp b/lib/AST/SEHExceptStmt.cpp index 025135dbf..b1a8aa52c 100644 --- a/lib/AST/SEHExceptStmt.cpp +++ b/lib/AST/SEHExceptStmt.cpp @@ -183,16 +183,16 @@ std::optional SEHExceptStmt::from(const TokenContext &t) { } CompoundStmt SEHExceptStmt::block(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token SEHExceptStmt::except_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } Expr SEHExceptStmt::filter_expression(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } diff --git a/lib/AST/SEHFinallyStmt.cpp b/lib/AST/SEHFinallyStmt.cpp index 2ff702235..18c58d0bc 100644 --- a/lib/AST/SEHFinallyStmt.cpp +++ b/lib/AST/SEHFinallyStmt.cpp @@ -182,12 +182,12 @@ std::optional SEHFinallyStmt::from(const TokenContext &t) { } CompoundStmt SEHFinallyStmt::block(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token SEHFinallyStmt::finally_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } #pragma GCC diagnostic pop diff --git a/lib/AST/SEHLeaveStmt.cpp b/lib/AST/SEHLeaveStmt.cpp index b9d035b4a..9232f1980 100644 --- a/lib/AST/SEHLeaveStmt.cpp +++ b/lib/AST/SEHLeaveStmt.cpp @@ -181,7 +181,7 @@ std::optional SEHLeaveStmt::from(const TokenContext &t) { } Token SEHLeaveStmt::leave_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } #pragma GCC diagnostic pop diff --git a/lib/AST/SEHTryStmt.cpp b/lib/AST/SEHTryStmt.cpp index 3e4fd8555..5e3dbd047 100644 --- a/lib/AST/SEHTryStmt.cpp +++ b/lib/AST/SEHTryStmt.cpp @@ -184,31 +184,31 @@ std::optional SEHTryStmt::from(const TokenContext &t) { } SEHExceptStmt SEHTryStmt::except_handler(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return SEHExceptStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } SEHFinallyStmt SEHTryStmt::finally_handler(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return SEHFinallyStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Stmt SEHTryStmt::handler(void) const { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } bool SEHTryStmt::is_cxx_try(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } CompoundStmt SEHTryStmt::try_block(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } Token SEHTryStmt::try_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } #pragma GCC diagnostic pop diff --git a/lib/AST/SYCLUniqueStableNameExpr.cpp b/lib/AST/SYCLUniqueStableNameExpr.cpp index e56cc974e..dd00d8c01 100644 --- a/lib/AST/SYCLUniqueStableNameExpr.cpp +++ b/lib/AST/SYCLUniqueStableNameExpr.cpp @@ -183,20 +183,20 @@ std::optional SYCLUniqueStableNameExpr::from(const Tok } std::string_view SYCLUniqueStableNameExpr::compute_name(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } Token SYCLUniqueStableNameExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token SYCLUniqueStableNameExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Token SYCLUniqueStableNameExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } #pragma GCC diagnostic pop diff --git a/lib/AST/ShuffleVectorExpr.cpp b/lib/AST/ShuffleVectorExpr.cpp index f0d5d8078..b00ea4f89 100644 --- a/lib/AST/ShuffleVectorExpr.cpp +++ b/lib/AST/ShuffleVectorExpr.cpp @@ -183,11 +183,11 @@ std::optional ShuffleVectorExpr::from(const TokenContext &t) } Token ShuffleVectorExpr::builtin_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token ShuffleVectorExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } #pragma GCC diagnostic pop diff --git a/lib/AST/SizeOfPackExpr.cpp b/lib/AST/SizeOfPackExpr.cpp index d7d9bb9bf..99cc8444b 100644 --- a/lib/AST/SizeOfPackExpr.cpp +++ b/lib/AST/SizeOfPackExpr.cpp @@ -185,50 +185,50 @@ std::optional SizeOfPackExpr::from(const TokenContext &t) { } Token SizeOfPackExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } NamedDecl SizeOfPackExpr::pack(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return NamedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional SizeOfPackExpr::pack_length(void) const { - if (!impl->reader.getVal84()) { + if (!impl->reader.getVal85()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal26()); + return static_cast(impl->reader.getVal27()); } return std::nullopt; } Token SizeOfPackExpr::pack_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } std::optional> SizeOfPackExpr::partial_arguments(void) const { - if (!impl->reader.getVal85()) { + if (!impl->reader.getVal86()) { return std::nullopt; } - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); std::vector vec; vec.reserve(list.size()); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->TemplateArgumentFor(ep, v)) { - vec.emplace_back(std::move(d15)); + if (auto d16 = ep->TemplateArgumentFor(ep, v)) { + vec.emplace_back(std::move(d16)); } } return vec; } Token SizeOfPackExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } bool SizeOfPackExpr::is_partially_substituted(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } #pragma GCC diagnostic pop diff --git a/lib/AST/SourceLocExpr.cpp b/lib/AST/SourceLocExpr.cpp index 58352d66f..4d058c1f5 100644 --- a/lib/AST/SourceLocExpr.cpp +++ b/lib/AST/SourceLocExpr.cpp @@ -183,20 +183,20 @@ std::optional SourceLocExpr::from(const TokenContext &t) { } std::string_view SourceLocExpr::builtin_string(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } SourceLocIdentKind SourceLocExpr::identifier_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } Token SourceLocExpr::token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } bool SourceLocExpr::is_int_type(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/StaticAssertDecl.cpp b/lib/AST/StaticAssertDecl.cpp index 2c04467f7..9ccf07879 100644 --- a/lib/AST/StaticAssertDecl.cpp +++ b/lib/AST/StaticAssertDecl.cpp @@ -211,13 +211,13 @@ std::optional StaticAssertDecl::from(const TokenContext &t) { } Expr StaticAssertDecl::assert_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional StaticAssertDecl::message(void) const { if (true) { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -229,11 +229,11 @@ std::optional StaticAssertDecl::message(void) const { } Token StaticAssertDecl::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); } bool StaticAssertDecl::is_failed(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } #pragma GCC diagnostic pop diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp index 13414026c..2d75520f6 100644 --- a/lib/AST/Stmt.cpp +++ b/lib/AST/Stmt.cpp @@ -41,6 +41,34 @@ std::optional Stmt::parent_statement(void) const { return std::nullopt; } +std::optional Stmt::ir(void) const { + auto raw = impl->reader.getVal2(); + if (raw == kInvalidEntityId) return std::nullopt; + auto vid = EntityId(raw).Unpack(); + if (auto *p = std::get_if(&vid)) { + if (auto ptr = impl->ep->IRFunctionFor(impl->ep, raw)) { + return IRFunction(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = impl->ep->IRBlockFor(impl->ep, raw)) { + return IRBlock(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = impl->ep->IRInstructionFor(impl->ep, raw)) { + return IRInstruction(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = impl->ep->IRObjectFor(impl->ep, raw)) { + return IRObject(std::move(ptr)); + } + } else if (auto *p = std::get_if(&vid)) { + if (auto ptr = impl->ep->IRStructureFor(impl->ep, raw)) { + return IRStructure(std::move(ptr)); + } + } + return std::nullopt; +} + std::shared_ptr Stmt::entity_provider_of(const Index &index_) { return index_.impl; } @@ -54,7 +82,7 @@ std::shared_ptr Stmt::entity_provider_of(const File &file_) { } std::optional Stmt::referenced_declaration_id(void) const { - if (auto id = impl->reader.getVal2(); + if (auto id = impl->reader.getVal3(); id != kInvalidEntityId) { VariantId vid = EntityId(id).Unpack(); if (std::holds_alternative(vid)) { @@ -66,7 +94,7 @@ std::optional Stmt::referenced_declaration_id(void) const { } std::optional Stmt::referenced_declaration(void) const { - if (auto id = impl->reader.getVal2(); + if (auto id = impl->reader.getVal3(); id != kInvalidEntityId) { if (auto eptr = impl->ep->DeclFor(impl->ep, id)) { return Decl(std::move(eptr)); @@ -222,32 +250,32 @@ std::optional Stmt::from(const TokenContext &t) { } Stmt Stmt::ignore_containers(void) const { - RawEntityId eid = impl->reader.getVal3(); + RawEntityId eid = impl->reader.getVal4(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } gap::generator Stmt::children(void) const & { - auto list = impl->reader.getVal4(); + auto list = impl->reader.getVal5(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d4 = ep->StmtFor(ep, v)) { - co_yield Stmt(std::move(d4)); + if (auto d5 = ep->StmtFor(ep, v)) { + co_yield Stmt(std::move(d5)); } } co_return; } TokenRange Stmt::tokens(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal5(), impl->reader.getVal6()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal6(), impl->reader.getVal7()); } StmtKind Stmt::kind(void) const { - return static_cast(impl->reader.getVal7()); + return static_cast(impl->reader.getVal8()); } Stmt Stmt::strip_label_like_statements(void) const { - RawEntityId eid = impl->reader.getVal8(); + RawEntityId eid = impl->reader.getVal9(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/StmtExpr.cpp b/lib/AST/StmtExpr.cpp index 738ea1e2f..998896cb7 100644 --- a/lib/AST/StmtExpr.cpp +++ b/lib/AST/StmtExpr.cpp @@ -184,20 +184,20 @@ std::optional StmtExpr::from(const TokenContext &t) { } Token StmtExpr::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token StmtExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } CompoundStmt StmtExpr::sub_statement(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return CompoundStmt::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } uint32_t StmtExpr::template_depth(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } #pragma GCC diagnostic pop diff --git a/lib/AST/StringLiteral.cpp b/lib/AST/StringLiteral.cpp index 6265032f7..b894e18d2 100644 --- a/lib/AST/StringLiteral.cpp +++ b/lib/AST/StringLiteral.cpp @@ -183,84 +183,84 @@ std::optional StringLiteral::from(const TokenContext &t) { } std::optional StringLiteral::contains_non_ascii(void) const { - if (!impl->reader.getVal85()) { + if (!impl->reader.getVal86()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal84()); + return static_cast(impl->reader.getVal85()); } return std::nullopt; } std::optional StringLiteral::contains_non_ascii_or_null(void) const { - if (!impl->reader.getVal87()) { + if (!impl->reader.getVal88()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal86()); + return static_cast(impl->reader.getVal87()); } return std::nullopt; } uint32_t StringLiteral::byte_length(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } std::string_view StringLiteral::bytes(void) const { - capnp::Text::Reader data = impl->reader.getVal61(); + capnp::Text::Reader data = impl->reader.getVal62(); return std::string_view(data.cStr(), data.size()); } uint32_t StringLiteral::character_byte_width(void) const { - return impl->reader.getVal100(); + return impl->reader.getVal101(); } StringLiteralKind StringLiteral::literal_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } uint32_t StringLiteral::length(void) const { - return impl->reader.getVal101(); + return impl->reader.getVal102(); } uint32_t StringLiteral::num_concatenated(void) const { - return impl->reader.getVal102(); + return impl->reader.getVal103(); } std::optional StringLiteral::string(void) const { - if (!impl->reader.getVal88()) { + if (!impl->reader.getVal89()) { return std::nullopt; } else { - capnp::Text::Reader data = impl->reader.getVal66(); + capnp::Text::Reader data = impl->reader.getVal67(); return std::string_view(data.cStr(), data.size()); } return std::nullopt; } bool StringLiteral::is_ordinary(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool StringLiteral::is_pascal(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool StringLiteral::is_utf16(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool StringLiteral::is_utf32(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } bool StringLiteral::is_utf8(void) const { - return impl->reader.getVal95(); + return impl->reader.getVal96(); } bool StringLiteral::is_unevaluated(void) const { - return impl->reader.getVal96(); + return impl->reader.getVal97(); } bool StringLiteral::is_wide(void) const { - return impl->reader.getVal97(); + return impl->reader.getVal98(); } #pragma GCC diagnostic pop diff --git a/lib/AST/SubstNonTypeTemplateParmExpr.cpp b/lib/AST/SubstNonTypeTemplateParmExpr.cpp index c44668a43..56f1dc616 100644 --- a/lib/AST/SubstNonTypeTemplateParmExpr.cpp +++ b/lib/AST/SubstNonTypeTemplateParmExpr.cpp @@ -185,44 +185,44 @@ std::optional SubstNonTypeTemplateParmExpr::from(c } Decl SubstNonTypeTemplateParmExpr::associated_declaration(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Decl(impl->ep->DeclFor(impl->ep, eid)); } uint32_t SubstNonTypeTemplateParmExpr::index(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } Token SubstNonTypeTemplateParmExpr::name_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } std::optional SubstNonTypeTemplateParmExpr::pack_index(void) const { - if (!impl->reader.getVal84()) { + if (!impl->reader.getVal85()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal100()); + return static_cast(impl->reader.getVal101()); } return std::nullopt; } NonTypeTemplateParmDecl SubstNonTypeTemplateParmExpr::parameter(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return NonTypeTemplateParmDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Type SubstNonTypeTemplateParmExpr::parameter_type(void) const { - RawEntityId eid = impl->reader.getVal41(); + RawEntityId eid = impl->reader.getVal42(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Expr SubstNonTypeTemplateParmExpr::replacement(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool SubstNonTypeTemplateParmExpr::is_reference_parameter(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } #pragma GCC diagnostic pop diff --git a/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp b/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp index 2b7dbec7c..95df905b1 100644 --- a/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp +++ b/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp @@ -184,21 +184,21 @@ std::optional SubstNonTypeTemplateParmPackExpr } Decl SubstNonTypeTemplateParmPackExpr::associated_declaration(void) const { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); return Decl(impl->ep->DeclFor(impl->ep, eid)); } uint32_t SubstNonTypeTemplateParmPackExpr::index(void) const { - return impl->reader.getVal26(); + return impl->reader.getVal27(); } NonTypeTemplateParmDecl SubstNonTypeTemplateParmPackExpr::parameter_pack(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return NonTypeTemplateParmDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token SubstNonTypeTemplateParmPackExpr::parameter_pack_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } #pragma GCC diagnostic pop diff --git a/lib/AST/SwitchCase.cpp b/lib/AST/SwitchCase.cpp index 660527522..c27d63319 100644 --- a/lib/AST/SwitchCase.cpp +++ b/lib/AST/SwitchCase.cpp @@ -185,16 +185,16 @@ std::optional SwitchCase::from(const TokenContext &t) { } Token SwitchCase::colon_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal9()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); } Token SwitchCase::keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal10()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal11()); } std::optional SwitchCase::next_switch_case(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -206,7 +206,7 @@ std::optional SwitchCase::next_switch_case(void) const { } Stmt SwitchCase::sub_statement(void) const { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } diff --git a/lib/AST/SwitchStmt.cpp b/lib/AST/SwitchStmt.cpp index 98485fe83..184855fa5 100644 --- a/lib/AST/SwitchStmt.cpp +++ b/lib/AST/SwitchStmt.cpp @@ -185,18 +185,18 @@ std::optional SwitchStmt::from(const TokenContext &t) { } Stmt SwitchStmt::body(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Expr SwitchStmt::condition(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional SwitchStmt::condition_variable(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -209,7 +209,7 @@ std::optional SwitchStmt::condition_variable(void) const { std::optional SwitchStmt::condition_variable_declaration_statement(void) const { if (true) { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -222,7 +222,7 @@ std::optional SwitchStmt::condition_variable_declaration_statement(voi std::optional SwitchStmt::initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal14(); + RawEntityId eid = impl->reader.getVal15(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -234,16 +234,16 @@ std::optional SwitchStmt::initializer(void) const { } Token SwitchStmt::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal17()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal18()); } Token SwitchStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal18()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal19()); } std::optional SwitchStmt::first_switch_case(void) const { if (true) { - RawEntityId eid = impl->reader.getVal19(); + RawEntityId eid = impl->reader.getVal20(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -255,19 +255,19 @@ std::optional SwitchStmt::first_switch_case(void) const { } Token SwitchStmt::switch_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal20()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal21()); } bool SwitchStmt::has_initializer_storage(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } bool SwitchStmt::has_variable_storage(void) const { - return impl->reader.getVal16(); + return impl->reader.getVal17(); } bool SwitchStmt::is_all_enum_cases_covered(void) const { - return impl->reader.getVal23(); + return impl->reader.getVal24(); } #pragma GCC diagnostic pop diff --git a/lib/AST/TagDecl.cpp b/lib/AST/TagDecl.cpp index 19f58a874..7ebc12c8a 100644 --- a/lib/AST/TagDecl.cpp +++ b/lib/AST/TagDecl.cpp @@ -229,24 +229,24 @@ std::optional TagDecl::from(const TokenContext &t) { } TokenRange TagDecl::brace_range(void) const { - return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal49(), impl->reader.getVal50()); + return impl->ep->TokenRangeFor(impl->ep, impl->reader.getVal50(), impl->reader.getVal51()); } Token TagDecl::first_inner_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } Token TagDecl::first_outer_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); } TagTypeKind TagDecl::tag_kind(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } std::optional TagDecl::typedef_name_for_anonymous_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal60(); + RawEntityId eid = impl->reader.getVal61(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -258,67 +258,67 @@ std::optional TagDecl::typedef_name_for_anonymous_declaration(v } bool TagDecl::has_name_for_linkage(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool TagDecl::is_being_defined(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool TagDecl::is_class(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool TagDecl::is_complete_definition(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool TagDecl::is_complete_definition_required(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool TagDecl::is_dependent_type(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } bool TagDecl::is_enum(void) const { - return impl->reader.getVal83(); + return impl->reader.getVal84(); } bool TagDecl::is_free_standing(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool TagDecl::is_interface(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool TagDecl::is_struct(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool TagDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool TagDecl::is_this_declaration_a_demoted_definition(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool TagDecl::is_union(void) const { - return impl->reader.getVal89(); + return impl->reader.getVal90(); } bool TagDecl::may_have_out_of_date_definition(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } unsigned TagDecl::num_template_parameter_lists(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional TagDecl::nth_template_parameter_list(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -332,12 +332,12 @@ std::optional TagDecl::nth_template_parameter_list(unsign } gap::generator TagDecl::template_parameter_lists(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->TemplateParameterListFor(ep, v)) { - co_yield TemplateParameterList(std::move(d43)); + if (auto d44 = ep->TemplateParameterListFor(ep, v)) { + co_yield TemplateParameterList(std::move(d44)); } } co_return; diff --git a/lib/AST/TemplateDecl.cpp b/lib/AST/TemplateDecl.cpp index a25378a5e..673f2bbb0 100644 --- a/lib/AST/TemplateDecl.cpp +++ b/lib/AST/TemplateDecl.cpp @@ -231,13 +231,13 @@ std::optional TemplateDecl::from(const TokenContext &t) { } TemplateParameterList TemplateDecl::template_parameters(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return TemplateParameterList(impl->ep->TemplateParameterListFor(impl->ep, eid)); } std::optional TemplateDecl::templated_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -249,11 +249,11 @@ std::optional TemplateDecl::templated_declaration(void) const { } bool TemplateDecl::has_associated_constraints(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool TemplateDecl::is_type_alias(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } #pragma GCC diagnostic pop diff --git a/lib/AST/TemplateTemplateParmDecl.cpp b/lib/AST/TemplateTemplateParmDecl.cpp index 16d0a145c..3fd79ac73 100644 --- a/lib/AST/TemplateTemplateParmDecl.cpp +++ b/lib/AST/TemplateTemplateParmDecl.cpp @@ -212,23 +212,23 @@ std::optional TemplateTemplateParmDecl::from(const Tok } bool TemplateTemplateParmDecl::default_argument_was_inherited(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } Token TemplateTemplateParmDecl::default_argument_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal51()); } bool TemplateTemplateParmDecl::has_default_argument(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool TemplateTemplateParmDecl::is_expanded_parameter_pack(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool TemplateTemplateParmDecl::is_pack_expansion(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } #pragma GCC diagnostic pop diff --git a/lib/AST/TemplateTypeParmDecl.cpp b/lib/AST/TemplateTypeParmDecl.cpp index 573e48b90..1af40d09c 100644 --- a/lib/AST/TemplateTypeParmDecl.cpp +++ b/lib/AST/TemplateTypeParmDecl.cpp @@ -213,12 +213,12 @@ std::optional TemplateTypeParmDecl::from(const TokenContex } bool TemplateTypeParmDecl::default_argument_was_inherited(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } std::optional TemplateTypeParmDecl::default_argument(void) const { if (true) { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -231,7 +231,7 @@ std::optional TemplateTypeParmDecl::default_argument(void) const { std::optional TemplateTypeParmDecl::default_argument_info(void) const { if (true) { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -243,35 +243,35 @@ std::optional TemplateTypeParmDecl::default_argument_info(void) const { } Token TemplateTypeParmDecl::default_argument_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } uint32_t TemplateTypeParmDecl::depth(void) const { - return impl->reader.getVal41(); + return impl->reader.getVal42(); } uint32_t TemplateTypeParmDecl::index(void) const { - return impl->reader.getVal117(); + return impl->reader.getVal118(); } bool TemplateTypeParmDecl::has_default_argument(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } bool TemplateTypeParmDecl::has_type_constraint(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool TemplateTypeParmDecl::is_expanded_parameter_pack(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool TemplateTypeParmDecl::is_pack_expansion(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } bool TemplateTypeParmDecl::was_declared_with_typename(void) const { - return impl->reader.getVal82(); + return impl->reader.getVal83(); } #pragma GCC diagnostic pop diff --git a/lib/AST/TopLevelStmtDecl.cpp b/lib/AST/TopLevelStmtDecl.cpp index 67131fc04..76be79197 100644 --- a/lib/AST/TopLevelStmtDecl.cpp +++ b/lib/AST/TopLevelStmtDecl.cpp @@ -210,12 +210,12 @@ std::optional TopLevelStmtDecl::from(const TokenContext &t) { } Stmt TopLevelStmtDecl::statement(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } bool TopLevelStmtDecl::is_semi_missing(void) const { - return impl->reader.getVal42(); + return impl->reader.getVal43(); } #pragma GCC diagnostic pop diff --git a/lib/AST/TypeAliasDecl.cpp b/lib/AST/TypeAliasDecl.cpp index 05075df1c..521b8b5ce 100644 --- a/lib/AST/TypeAliasDecl.cpp +++ b/lib/AST/TypeAliasDecl.cpp @@ -215,7 +215,7 @@ std::optional TypeAliasDecl::from(const TokenContext &t) { std::optional TypeAliasDecl::described_alias_template(void) const { if (true) { - RawEntityId eid = impl->reader.getVal58(); + RawEntityId eid = impl->reader.getVal59(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/TypeDecl.cpp b/lib/AST/TypeDecl.cpp index 3e86570af..8a0a61673 100644 --- a/lib/AST/TypeDecl.cpp +++ b/lib/AST/TypeDecl.cpp @@ -241,7 +241,7 @@ std::optional TypeDecl::from(const TokenContext &t) { std::optional TypeDecl::type_for_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/TypeTraitExpr.cpp b/lib/AST/TypeTraitExpr.cpp index 2ced70c1f..1b468d4ad 100644 --- a/lib/AST/TypeTraitExpr.cpp +++ b/lib/AST/TypeTraitExpr.cpp @@ -184,24 +184,24 @@ std::optional TypeTraitExpr::from(const TokenContext &t) { } TypeTrait TypeTraitExpr::trait(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } std::optional TypeTraitExpr::value(void) const { - if (!impl->reader.getVal85()) { + if (!impl->reader.getVal86()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal84()); + return static_cast(impl->reader.getVal85()); } return std::nullopt; } unsigned TypeTraitExpr::num_arguments(void) const { - return impl->reader.getVal15().size(); + return impl->reader.getVal16().size(); } std::optional TypeTraitExpr::nth_argument(unsigned n) const { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); if (n >= list.size()) { return std::nullopt; } @@ -215,12 +215,12 @@ std::optional TypeTraitExpr::nth_argument(unsigned n) const { } gap::generator TypeTraitExpr::arguments(void) const & { - auto list = impl->reader.getVal15(); + auto list = impl->reader.getVal16(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d15 = ep->TypeFor(ep, v)) { - co_yield Type(std::move(d15)); + if (auto d16 = ep->TypeFor(ep, v)) { + co_yield Type(std::move(d16)); } } co_return; diff --git a/lib/AST/TypedefNameDecl.cpp b/lib/AST/TypedefNameDecl.cpp index af1284cdb..aded6a7c8 100644 --- a/lib/AST/TypedefNameDecl.cpp +++ b/lib/AST/TypedefNameDecl.cpp @@ -222,7 +222,7 @@ std::optional TypedefNameDecl::from(const TokenContext &t) { std::optional TypedefNameDecl::anonymous_declaration_with_typedef_name(void) const { if (true) { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -234,16 +234,16 @@ std::optional TypedefNameDecl::anonymous_declaration_with_typedef_name( } Type TypedefNameDecl::underlying_type(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool TypedefNameDecl::is_moded(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool TypedefNameDecl::is_transparent_tag(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UnaryExprOrTypeTraitExpr.cpp b/lib/AST/UnaryExprOrTypeTraitExpr.cpp index 09aed0a86..448ce365f 100644 --- a/lib/AST/UnaryExprOrTypeTraitExpr.cpp +++ b/lib/AST/UnaryExprOrTypeTraitExpr.cpp @@ -185,7 +185,7 @@ std::optional UnaryExprOrTypeTraitExpr::from(const Tok std::optional UnaryExprOrTypeTraitExpr::argument_expression(void) const { if (true) { - RawEntityId eid = impl->reader.getVal38(); + RawEntityId eid = impl->reader.getVal39(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -198,7 +198,7 @@ std::optional UnaryExprOrTypeTraitExpr::argument_expression(void) const { std::optional UnaryExprOrTypeTraitExpr::argument_type(void) const { if (true) { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -210,24 +210,24 @@ std::optional UnaryExprOrTypeTraitExpr::argument_type(void) const { } UnaryExprOrTypeTrait UnaryExprOrTypeTraitExpr::keyword_kind(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } Token UnaryExprOrTypeTraitExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); } Token UnaryExprOrTypeTraitExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal41()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal42()); } Type UnaryExprOrTypeTraitExpr::type_of_argument(void) const { - RawEntityId eid = impl->reader.getVal42(); + RawEntityId eid = impl->reader.getVal43(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool UnaryExprOrTypeTraitExpr::is_argument_type(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UnaryOperator.cpp b/lib/AST/UnaryOperator.cpp index 3ae920ad0..68e10b4ac 100644 --- a/lib/AST/UnaryOperator.cpp +++ b/lib/AST/UnaryOperator.cpp @@ -183,48 +183,48 @@ std::optional UnaryOperator::from(const TokenContext &t) { } bool UnaryOperator::can_overflow(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } UnaryOperatorKind UnaryOperator::opcode(void) const { - return static_cast(impl->reader.getVal89()); + return static_cast(impl->reader.getVal90()); } Token UnaryOperator::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Expr UnaryOperator::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal39(); + RawEntityId eid = impl->reader.getVal40(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool UnaryOperator::has_stored_fp_features(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool UnaryOperator::is_arithmetic_operation(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool UnaryOperator::is_decrement_operation(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool UnaryOperator::is_increment_decrement_operation(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool UnaryOperator::is_increment_operation(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool UnaryOperator::is_postfix(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool UnaryOperator::is_prefix(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UnresolvedLookupExpr.cpp b/lib/AST/UnresolvedLookupExpr.cpp index 2f0883c8f..15f5a8424 100644 --- a/lib/AST/UnresolvedLookupExpr.cpp +++ b/lib/AST/UnresolvedLookupExpr.cpp @@ -184,11 +184,11 @@ std::optional UnresolvedLookupExpr::from(const TokenContex } bool UnresolvedLookupExpr::is_overloaded(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool UnresolvedLookupExpr::requires_adl(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UnresolvedMemberExpr.cpp b/lib/AST/UnresolvedMemberExpr.cpp index d90b9f4c9..4ba501e53 100644 --- a/lib/AST/UnresolvedMemberExpr.cpp +++ b/lib/AST/UnresolvedMemberExpr.cpp @@ -185,28 +185,28 @@ std::optional UnresolvedMemberExpr::from(const TokenContex } Type UnresolvedMemberExpr::base_type(void) const { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Token UnresolvedMemberExpr::member_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } Token UnresolvedMemberExpr::operator_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal46()); } bool UnresolvedMemberExpr::has_unresolved_using(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool UnresolvedMemberExpr::is_arrow(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool UnresolvedMemberExpr::is_implicit_access(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UnresolvedUsingTypenameDecl.cpp b/lib/AST/UnresolvedUsingTypenameDecl.cpp index b6b175fb6..9251611a4 100644 --- a/lib/AST/UnresolvedUsingTypenameDecl.cpp +++ b/lib/AST/UnresolvedUsingTypenameDecl.cpp @@ -212,19 +212,19 @@ std::optional UnresolvedUsingTypenameDecl::from(con } Token UnresolvedUsingTypenameDecl::ellipsis_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); } Token UnresolvedUsingTypenameDecl::typename_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal51()); } Token UnresolvedUsingTypenameDecl::using_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } bool UnresolvedUsingTypenameDecl::is_pack_expansion(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UnresolvedUsingValueDecl.cpp b/lib/AST/UnresolvedUsingValueDecl.cpp index 6aaa2c29d..046756b74 100644 --- a/lib/AST/UnresolvedUsingValueDecl.cpp +++ b/lib/AST/UnresolvedUsingValueDecl.cpp @@ -212,19 +212,19 @@ std::optional UnresolvedUsingValueDecl::from(const Tok } Token UnresolvedUsingValueDecl::ellipsis_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal51()); } Token UnresolvedUsingValueDecl::using_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } bool UnresolvedUsingValueDecl::is_access_declaration(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool UnresolvedUsingValueDecl::is_pack_expansion(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UserDefinedLiteral.cpp b/lib/AST/UserDefinedLiteral.cpp index 354dc51fc..19df16e35 100644 --- a/lib/AST/UserDefinedLiteral.cpp +++ b/lib/AST/UserDefinedLiteral.cpp @@ -185,7 +185,7 @@ std::optional UserDefinedLiteral::from(const TokenContext &t std::optional UserDefinedLiteral::cooked_literal(void) const { if (true) { - RawEntityId eid = impl->reader.getVal43(); + RawEntityId eid = impl->reader.getVal44(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -197,11 +197,11 @@ std::optional UserDefinedLiteral::cooked_literal(void) const { } UserDefinedLiteralLiteralOperatorKind UserDefinedLiteral::literal_operator_kind(void) const { - return static_cast(impl->reader.getVal91()); + return static_cast(impl->reader.getVal92()); } Token UserDefinedLiteral::ud_suffix_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal44()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal45()); } #pragma GCC diagnostic pop diff --git a/lib/AST/UsingDecl.cpp b/lib/AST/UsingDecl.cpp index b46309be4..beb0754ba 100644 --- a/lib/AST/UsingDecl.cpp +++ b/lib/AST/UsingDecl.cpp @@ -212,15 +212,15 @@ std::optional UsingDecl::from(const TokenContext &t) { } Token UsingDecl::using_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } bool UsingDecl::has_typename(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool UsingDecl::is_access_declaration(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } #pragma GCC diagnostic pop diff --git a/lib/AST/UsingDirectiveDecl.cpp b/lib/AST/UsingDirectiveDecl.cpp index b3c741b2d..a51a98540 100644 --- a/lib/AST/UsingDirectiveDecl.cpp +++ b/lib/AST/UsingDirectiveDecl.cpp @@ -212,25 +212,25 @@ std::optional UsingDirectiveDecl::from(const TokenContext &t } Token UsingDirectiveDecl::identifier_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal48()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); } Token UsingDirectiveDecl::namespace_key_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); } NamespaceDecl UsingDirectiveDecl::nominated_namespace(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return NamespaceDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } NamedDecl UsingDirectiveDecl::nominated_namespace_as_written(void) const { - RawEntityId eid = impl->reader.getVal58(); + RawEntityId eid = impl->reader.getVal59(); return NamedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token UsingDirectiveDecl::using_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal60()); } #pragma GCC diagnostic pop diff --git a/lib/AST/UsingEnumDecl.cpp b/lib/AST/UsingEnumDecl.cpp index dc5e6f333..c55f234b5 100644 --- a/lib/AST/UsingEnumDecl.cpp +++ b/lib/AST/UsingEnumDecl.cpp @@ -214,21 +214,21 @@ std::optional UsingEnumDecl::from(const TokenContext &t) { } EnumDecl UsingEnumDecl::enum_declaration(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return EnumDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } Token UsingEnumDecl::enum_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal49()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal50()); } Type UsingEnumDecl::enum_type(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return Type(impl->ep->TypeFor(impl->ep, eid)); } Token UsingEnumDecl::using_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal58()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal59()); } #pragma GCC diagnostic pop diff --git a/lib/AST/UsingPackDecl.cpp b/lib/AST/UsingPackDecl.cpp index 605355634..4228f7733 100644 --- a/lib/AST/UsingPackDecl.cpp +++ b/lib/AST/UsingPackDecl.cpp @@ -211,11 +211,11 @@ std::optional UsingPackDecl::from(const TokenContext &t) { } unsigned UsingPackDecl::num_expansions(void) const { - return impl->reader.getVal43().size(); + return impl->reader.getVal44().size(); } std::optional UsingPackDecl::nth_expansion(unsigned n) const { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); if (n >= list.size()) { return std::nullopt; } @@ -229,12 +229,12 @@ std::optional UsingPackDecl::nth_expansion(unsigned n) const { } gap::generator UsingPackDecl::expansions(void) const & { - auto list = impl->reader.getVal43(); + auto list = impl->reader.getVal44(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d43 = ep->DeclFor(ep, v)) { - if (auto e = NamedDecl::from_base(std::move(d43))) { + if (auto d44 = ep->DeclFor(ep, v)) { + if (auto e = NamedDecl::from_base(std::move(d44))) { co_yield std::move(*e); } } diff --git a/lib/AST/UsingShadowDecl.cpp b/lib/AST/UsingShadowDecl.cpp index 906dd855b..a83f6de22 100644 --- a/lib/AST/UsingShadowDecl.cpp +++ b/lib/AST/UsingShadowDecl.cpp @@ -215,13 +215,13 @@ std::optional UsingShadowDecl::from(const TokenContext &t) { } BaseUsingDecl UsingShadowDecl::introducer(void) const { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); return BaseUsingDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } std::optional UsingShadowDecl::next_using_shadow_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -233,7 +233,7 @@ std::optional UsingShadowDecl::next_using_shadow_declaration(vo } NamedDecl UsingShadowDecl::target_declaration(void) const { - RawEntityId eid = impl->reader.getVal50(); + RawEntityId eid = impl->reader.getVal51(); return NamedDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } diff --git a/lib/AST/VAArgExpr.cpp b/lib/AST/VAArgExpr.cpp index 5b7fc2159..e05d2c01d 100644 --- a/lib/AST/VAArgExpr.cpp +++ b/lib/AST/VAArgExpr.cpp @@ -183,20 +183,20 @@ std::optional VAArgExpr::from(const TokenContext &t) { } Token VAArgExpr::builtin_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal38()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); } Token VAArgExpr::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal39()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal40()); } Expr VAArgExpr::sub_expression(void) const { - RawEntityId eid = impl->reader.getVal40(); + RawEntityId eid = impl->reader.getVal41(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } bool VAArgExpr::is_microsoft_abi(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ValueDecl.cpp b/lib/AST/ValueDecl.cpp index c8c6384fe..1ad677741 100644 --- a/lib/AST/ValueDecl.cpp +++ b/lib/AST/ValueDecl.cpp @@ -293,7 +293,7 @@ std::optional ValueDecl::from(const TokenContext &t) { std::optional ValueDecl::potentially_decomposed_variable_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal48(); + RawEntityId eid = impl->reader.getVal49(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -305,16 +305,16 @@ std::optional ValueDecl::potentially_decomposed_variable_declaration(vo } Type ValueDecl::type(void) const { - RawEntityId eid = impl->reader.getVal49(); + RawEntityId eid = impl->reader.getVal50(); return Type(impl->ep->TypeFor(impl->ep, eid)); } bool ValueDecl::is_initializer_capture(void) const { - return impl->reader.getVal66(); + return impl->reader.getVal67(); } bool ValueDecl::is_weak(void) const { - return impl->reader.getVal67(); + return impl->reader.getVal68(); } #pragma GCC diagnostic pop diff --git a/lib/AST/ValueStmt.cpp b/lib/AST/ValueStmt.cpp index 590e2b1a4..06ad7e00a 100644 --- a/lib/AST/ValueStmt.cpp +++ b/lib/AST/ValueStmt.cpp @@ -559,7 +559,7 @@ std::optional ValueStmt::from(const TokenContext &t) { std::optional ValueStmt::expression_statement(void) const { if (true) { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); if (eid == kInvalidEntityId) { return std::nullopt; } diff --git a/lib/AST/VarDecl.cpp b/lib/AST/VarDecl.cpp index bc4af352d..98a61e258 100644 --- a/lib/AST/VarDecl.cpp +++ b/lib/AST/VarDecl.cpp @@ -234,7 +234,7 @@ std::optional VarDecl::from(const TokenContext &t) { std::optional VarDecl::acting_definition(void) const { if (true) { - RawEntityId eid = impl->reader.getVal71(); + RawEntityId eid = impl->reader.getVal72(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -247,7 +247,7 @@ std::optional VarDecl::acting_definition(void) const { std::optional VarDecl::described_variable_template(void) const { if (true) { - RawEntityId eid = impl->reader.getVal73(); + RawEntityId eid = impl->reader.getVal74(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -260,7 +260,7 @@ std::optional VarDecl::described_variable_template(void) const std::optional VarDecl::initializer(void) const { if (true) { - RawEntityId eid = impl->reader.getVal74(); + RawEntityId eid = impl->reader.getVal75(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -272,12 +272,12 @@ std::optional VarDecl::initializer(void) const { } VarDeclInitializationStyle VarDecl::initializer_style(void) const { - return static_cast(impl->reader.getVal72()); + return static_cast(impl->reader.getVal73()); } std::optional VarDecl::initializing_declaration(void) const { if (true) { - RawEntityId eid = impl->reader.getVal75(); + RawEntityId eid = impl->reader.getVal76(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -289,160 +289,160 @@ std::optional VarDecl::initializing_declaration(void) const { } LanguageLinkage VarDecl::language_linkage(void) const { - return static_cast(impl->reader.getVal76()); + return static_cast(impl->reader.getVal77()); } StorageClass VarDecl::storage_class(void) const { - return static_cast(impl->reader.getVal77()); + return static_cast(impl->reader.getVal78()); } StorageDuration VarDecl::storage_duration(void) const { - return static_cast(impl->reader.getVal78()); + return static_cast(impl->reader.getVal79()); } VarDeclTLSKind VarDecl::tls_kind(void) const { - return static_cast(impl->reader.getVal79()); + return static_cast(impl->reader.getVal80()); } ThreadStorageClassSpecifier VarDecl::tsc_spec(void) const { - return static_cast(impl->reader.getVal80()); + return static_cast(impl->reader.getVal81()); } bool VarDecl::has_constant_initialization(void) const { - return impl->reader.getVal68(); + return impl->reader.getVal69(); } bool VarDecl::has_dependent_alignment(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } bool VarDecl::has_external_storage(void) const { - return impl->reader.getVal81(); + return impl->reader.getVal82(); } std::optional VarDecl::has_flexible_array_initializer(void) const { - if (!impl->reader.getVal83()) { + if (!impl->reader.getVal84()) { return std::nullopt; } else { - return static_cast(impl->reader.getVal82()); + return static_cast(impl->reader.getVal83()); } return std::nullopt; } bool VarDecl::has_global_storage(void) const { - return impl->reader.getVal84(); + return impl->reader.getVal85(); } bool VarDecl::has_initializer(void) const { - return impl->reader.getVal85(); + return impl->reader.getVal86(); } bool VarDecl::has_local_storage(void) const { - return impl->reader.getVal86(); + return impl->reader.getVal87(); } bool VarDecl::is_arc_pseudo_strong(void) const { - return impl->reader.getVal87(); + return impl->reader.getVal88(); } bool VarDecl::is_cxx_for_range_declaration(void) const { - return impl->reader.getVal88(); + return impl->reader.getVal89(); } bool VarDecl::is_constexpr(void) const { - return impl->reader.getVal89(); + return impl->reader.getVal90(); } bool VarDecl::is_direct_initializer(void) const { - return impl->reader.getVal90(); + return impl->reader.getVal91(); } bool VarDecl::is_escaping_byref(void) const { - return impl->reader.getVal91(); + return impl->reader.getVal92(); } bool VarDecl::is_exception_variable(void) const { - return impl->reader.getVal92(); + return impl->reader.getVal93(); } bool VarDecl::is_extern_c(void) const { - return impl->reader.getVal93(); + return impl->reader.getVal94(); } bool VarDecl::is_file_variable_declaration(void) const { - return impl->reader.getVal94(); + return impl->reader.getVal95(); } bool VarDecl::is_function_or_method_variable_declaration(void) const { - return impl->reader.getVal95(); + return impl->reader.getVal96(); } bool VarDecl::is_in_extern_c_context(void) const { - return impl->reader.getVal96(); + return impl->reader.getVal97(); } bool VarDecl::is_in_extern_cxx_context(void) const { - return impl->reader.getVal97(); + return impl->reader.getVal98(); } bool VarDecl::is_inline(void) const { - return impl->reader.getVal98(); + return impl->reader.getVal99(); } bool VarDecl::is_inline_specified(void) const { - return impl->reader.getVal99(); + return impl->reader.getVal100(); } bool VarDecl::is_known_to_be_defined(void) const { - return impl->reader.getVal100(); + return impl->reader.getVal101(); } bool VarDecl::is_local_variable_declaration(void) const { - return impl->reader.getVal101(); + return impl->reader.getVal102(); } bool VarDecl::is_local_variable_declaration_or_parm(void) const { - return impl->reader.getVal102(); + return impl->reader.getVal103(); } bool VarDecl::is_nrvo_variable(void) const { - return impl->reader.getVal103(); + return impl->reader.getVal104(); } bool VarDecl::is_no_destroy(void) const { - return impl->reader.getVal104(); + return impl->reader.getVal105(); } bool VarDecl::is_non_escaping_byref(void) const { - return impl->reader.getVal105(); + return impl->reader.getVal106(); } bool VarDecl::is_obj_c_for_declaration(void) const { - return impl->reader.getVal106(); + return impl->reader.getVal107(); } bool VarDecl::is_previous_declaration_in_same_block_scope(void) const { - return impl->reader.getVal107(); + return impl->reader.getVal108(); } bool VarDecl::is_static_data_member(void) const { - return impl->reader.getVal108(); + return impl->reader.getVal109(); } bool VarDecl::is_static_local(void) const { - return impl->reader.getVal109(); + return impl->reader.getVal110(); } bool VarDecl::is_this_declaration_a_demoted_definition(void) const { - return impl->reader.getVal110(); + return impl->reader.getVal111(); } bool VarDecl::is_usable_in_constant_expressions(void) const { - return impl->reader.getVal111(); + return impl->reader.getVal112(); } bool VarDecl::might_be_usable_in_constant_expressions(void) const { - return impl->reader.getVal112(); + return impl->reader.getVal113(); } #pragma GCC diagnostic pop diff --git a/lib/AST/VarTemplateDecl.cpp b/lib/AST/VarTemplateDecl.cpp index d44d33bec..eb329d984 100644 --- a/lib/AST/VarTemplateDecl.cpp +++ b/lib/AST/VarTemplateDecl.cpp @@ -213,7 +213,7 @@ std::optional VarTemplateDecl::from(const TokenContext &t) { } bool VarTemplateDecl::is_this_declaration_a_definition(void) const { - return impl->reader.getVal69(); + return impl->reader.getVal70(); } #pragma GCC diagnostic pop diff --git a/lib/AST/VarTemplatePartialSpecializationDecl.cpp b/lib/AST/VarTemplatePartialSpecializationDecl.cpp index 5494d4b44..f1fc82adf 100644 --- a/lib/AST/VarTemplatePartialSpecializationDecl.cpp +++ b/lib/AST/VarTemplatePartialSpecializationDecl.cpp @@ -216,12 +216,12 @@ std::optional VarTemplatePartialSpecializa } TemplateParameterList VarTemplatePartialSpecializationDecl::template_parameters(void) const { - RawEntityId eid = impl->reader.getVal116(); + RawEntityId eid = impl->reader.getVal117(); return TemplateParameterList(impl->ep->TemplateParameterListFor(impl->ep, eid)); } bool VarTemplatePartialSpecializationDecl::has_associated_constraints(void) const { - return impl->reader.getVal124(); + return impl->reader.getVal125(); } #pragma GCC diagnostic pop diff --git a/lib/AST/VarTemplateSpecializationDecl.cpp b/lib/AST/VarTemplateSpecializationDecl.cpp index 9f1458d83..611c85acf 100644 --- a/lib/AST/VarTemplateSpecializationDecl.cpp +++ b/lib/AST/VarTemplateSpecializationDecl.cpp @@ -219,24 +219,24 @@ std::optional VarTemplateSpecializationDecl::from } Token VarTemplateSpecializationDecl::extern_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal113()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal114()); } TemplateSpecializationKind VarTemplateSpecializationDecl::specialization_kind(void) const { - return static_cast(impl->reader.getVal118()); + return static_cast(impl->reader.getVal119()); } VarTemplateDecl VarTemplateSpecializationDecl::specialized_template(void) const { - RawEntityId eid = impl->reader.getVal114(); + RawEntityId eid = impl->reader.getVal115(); return VarTemplateDecl::from_base(impl->ep->DeclFor(impl->ep, eid)).value(); } unsigned VarTemplateSpecializationDecl::num_template_arguments(void) const { - return impl->reader.getVal44().size(); + return impl->reader.getVal45().size(); } std::optional VarTemplateSpecializationDecl::nth_template_argument(unsigned n) const { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); if (n >= list.size()) { return std::nullopt; } @@ -250,31 +250,31 @@ std::optional VarTemplateSpecializationDecl::nth_template_argu } gap::generator VarTemplateSpecializationDecl::template_arguments(void) const & { - auto list = impl->reader.getVal44(); + auto list = impl->reader.getVal45(); EntityProviderPtr ep = impl->ep; for (auto v : list) { EntityId id(v); - if (auto d44 = ep->TemplateArgumentFor(ep, v)) { - co_yield TemplateArgument(std::move(d44)); + if (auto d45 = ep->TemplateArgumentFor(ep, v)) { + co_yield TemplateArgument(std::move(d45)); } } co_return; } Token VarTemplateSpecializationDecl::template_keyword_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal115()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal116()); } bool VarTemplateSpecializationDecl::is_class_scope_explicit_specialization(void) const { - return impl->reader.getVal121(); + return impl->reader.getVal122(); } bool VarTemplateSpecializationDecl::is_explicit_instantiation_or_specialization(void) const { - return impl->reader.getVal122(); + return impl->reader.getVal123(); } bool VarTemplateSpecializationDecl::is_explicit_specialization(void) const { - return impl->reader.getVal123(); + return impl->reader.getVal124(); } #pragma GCC diagnostic pop diff --git a/lib/AST/WhileStmt.cpp b/lib/AST/WhileStmt.cpp index a80afe136..380b402d2 100644 --- a/lib/AST/WhileStmt.cpp +++ b/lib/AST/WhileStmt.cpp @@ -184,18 +184,18 @@ std::optional WhileStmt::from(const TokenContext &t) { } Stmt WhileStmt::body(void) const { - RawEntityId eid = impl->reader.getVal9(); + RawEntityId eid = impl->reader.getVal10(); return Stmt(impl->ep->StmtFor(impl->ep, eid)); } Expr WhileStmt::condition(void) const { - RawEntityId eid = impl->reader.getVal10(); + RawEntityId eid = impl->reader.getVal11(); return Expr::from_base(impl->ep->StmtFor(impl->ep, eid)).value(); } std::optional WhileStmt::condition_variable(void) const { if (true) { - RawEntityId eid = impl->reader.getVal11(); + RawEntityId eid = impl->reader.getVal12(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -208,7 +208,7 @@ std::optional WhileStmt::condition_variable(void) const { std::optional WhileStmt::condition_variable_declaration_statement(void) const { if (true) { - RawEntityId eid = impl->reader.getVal13(); + RawEntityId eid = impl->reader.getVal14(); if (eid == kInvalidEntityId) { return std::nullopt; } @@ -220,19 +220,19 @@ std::optional WhileStmt::condition_variable_declaration_statement(void } Token WhileStmt::l_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal14()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal15()); } Token WhileStmt::r_paren_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal17()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal18()); } Token WhileStmt::while_token(void) const { - return impl->ep->TokenFor(impl->ep, impl->reader.getVal18()); + return impl->ep->TokenFor(impl->ep, impl->reader.getVal19()); } bool WhileStmt::has_variable_storage(void) const { - return impl->reader.getVal12(); + return impl->reader.getVal13(); } #pragma GCC diagnostic pop diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 391ed4948..493e3b289 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -13,6 +13,7 @@ set(binary_include_dir "${PROJECT_BINARY_DIR}/include/${lower_project_name}") # Auto-generate C++ headers and sources from our Cap'n Proto schemas. capnp_generate_cpp(MX_RPC_SOURCES MX_RPC_HEADERS RPC.capnp) capnp_generate_cpp(MX_AST_SOURCES MX_AST_HEADERS AST.capnp) # Bootstrapped file. +capnp_generate_cpp(MX_IR_SOURCES MX_IR_HEADERS IR.capnp) file(GLOB frontend_headers CONFIGURE_DEPENDS "${MX_BOOTSTRAP_INCLUDE_DIR}/Frontend/*.h") file(GLOB frontend_sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_LIST_DIR}/Frontend/*.cpp") @@ -29,6 +30,7 @@ configure_file(Version.cpp.in "${PROJECT_BINARY_DIR}/lib/Version.cpp" @ONLY) add_library("mx-serialize" INTERFACE ${MX_AST_SOURCES} ${MX_RPC_SOURCES} + ${MX_IR_SOURCES} ) set_target_properties("mx-serialize" @@ -51,7 +53,7 @@ target_link_libraries("mx-serialize" # Generate the commands to copy the headers into the binary include directory. set(copied_headers "") set(copy_headers_commands "") -foreach(capnp_header_path ${MX_RPC_HEADERS} ${MX_AST_HEADERS}) +foreach(capnp_header_path ${MX_RPC_HEADERS} ${MX_AST_HEADERS} ${MX_IR_HEADERS}) get_filename_component(header_name "${capnp_header_path}" NAME) set(output_header_path "${binary_include_dir}/${header_name}") list(APPEND copied_headers $) @@ -76,6 +78,7 @@ add_custom_command( DEPENDS ${MX_RPC_HEADERS} ${MX_AST_HEADERS} + ${MX_IR_HEADERS} COMMENT "Exporting Cap'n Proto-generated headers" @@ -134,6 +137,15 @@ add_library("mx-api" OBJECT "Fragment.h" "Generator.h" "Index.cpp" + "IR/Enums.cpp" + "IR/Impl.cpp" + "IR/Function.cpp" + "IR/Block.cpp" + "IR/Instruction.cpp" + "IR/InstructionKinds.cpp" + "IR/Structure.cpp" + "IR/StructureKinds.cpp" + "IR/Object.cpp" "InvalidEntityProvider.cpp" "InvalidEntityProvider.h" "Macro.h" @@ -315,6 +327,13 @@ if(MX_ENABLE_INSTALL AND NOT MX_ENABLE_BOOTSTRAP) DESTINATION "${MX_INSTALL_INCLUDE_DIR}/${lower_project_name}" ) + file(GLOB ir_headers CONFIGURE_DEPENDS "${source_include_dir}/IR/*.h") + install( + FILES + ${ir_headers} + DESTINATION + "${MX_INSTALL_INCLUDE_DIR}/${lower_project_name}/IR" + ) install( TARGETS "multiplier" diff --git a/lib/CachingEntityProvider.cpp b/lib/CachingEntityProvider.cpp index 434e7906d..25f3b81c1 100644 --- a/lib/CachingEntityProvider.cpp +++ b/lib/CachingEntityProvider.cpp @@ -4,6 +4,11 @@ // the LICENSE file found in the root directory of this source tree. #include "CachingEntityProvider.h" +#include +#include +#include +#include +#include "IR/Impl.h" #include #include @@ -47,6 +52,12 @@ void CachingEntityProvider::ClearCacheLocked(unsigned new_version_number) { next->VersionNumberChanged(new_version_number); } +IndexVersion CachingEntityProvider::GetIndexVersion(void) { + auto iv = next->GetIndexVersion(); + iv.version = VersionNumber(); + return iv; +} + void CachingEntityProvider::VersionNumberChanged(unsigned new_version_number) { std::lock_guard locker(lock); if (new_version_number > version_number) { @@ -276,12 +287,13 @@ EntityProviderPtr EntityProvider::CreateInMemoryCache( } MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER) #undef MX_DECLARE_ENTITY_GETTER #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \ @@ -291,12 +303,13 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, } MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_LISTERS, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_LISTERS, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS } // namespace mx diff --git a/lib/CachingEntityProvider.h b/lib/CachingEntityProvider.h index a1265d5aa..baf6bf32d 100644 --- a/lib/CachingEntityProvider.h +++ b/lib/CachingEntityProvider.h @@ -45,6 +45,7 @@ class CachingEntityProvider final : public EntityProvider { DECLARE_ENTITY_CACHE, DECLARE_ENTITY_CACHE, DECLARE_ENTITY_CACHE, + DECLARE_ENTITY_CACHE, DECLARE_ENTITY_CACHE) #undef DECLARE_ENTITY_CACHE @@ -72,6 +73,7 @@ class CachingEntityProvider final : public EntityProvider { unsigned VersionNumber(void) final; unsigned VersionNumber(const Ptr &) final; + IndexVersion GetIndexVersion(void) final; void VersionNumberChanged(unsigned) final; FilePathMap ListFiles(const Ptr &) final; @@ -121,12 +123,13 @@ class CachingEntityProvider final : public EntityProvider { const Ptr &ep) & final; MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER) #undef MX_DECLARE_ENTITY_GETTER #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \ @@ -134,12 +137,13 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, const Ptr &, type_name ## Kind) & final; MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_LISTERS, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_LISTERS, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS }; diff --git a/lib/Database.cpp b/lib/Database.cpp index 0ac558c91..99822a488 100644 --- a/lib/Database.cpp +++ b/lib/Database.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -165,13 +166,13 @@ class BulkInserterState { EncodeCategoryKind(mx::EntityCategory::enum_, -1), \ CreateEntityIndexInsertQuery(mx::EntityCategory::enum_)); \ - MX_FOR_EACH_ENTITY_CATEGORY( - MX_IGNORE_ENTITY_CATEGORY, + MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, CREATE_FRAG_OFFSET_INDEX, CREATE_PSEUDO_INDEX, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef CREATE_FRAG_OFFSET_INDEX @@ -616,10 +617,26 @@ void DatabaseWriterImpl::ExitDictionaries(void) { } } -// Initialize the metadata table. It only stores one row of data. +// Initialize the metadata table and generate a unique index ID. void DatabaseWriterImpl::InitMetadata(void) { add_version.BindValues(1u); add_version.Execute(); + + // Generate and store a unique index ID if not already present. + auto check = db.Prepare("SELECT COUNT(*) FROM index_id"); + check.ExecuteStep(); + int64_t count = 0; + check.Row().Columns(count); + check.Reset(); + + if (count == 0) { + std::random_device rd; + std::mt19937_64 gen(rd()); + uint64_t id = gen(); + auto insert = db.Prepare("INSERT INTO index_id (id) VALUES (?1)"); + insert.BindValues(id); + insert.Execute(); + } } void DatabaseWriterImpl::BulkInserter(void) { @@ -759,13 +776,13 @@ std::filesystem::path CreateDatabase(const std::filesystem::path &db_path_) { db.Execute(query); \ } while (false); - MX_FOR_EACH_ENTITY_CATEGORY( - MX_IGNORE_ENTITY_CATEGORY, + MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, CREATE_FRAG_OFFSET_INDEX, CREATE_PSEUDO_INDEX, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef CREATE_FRAG_OFFSET_INDEX @@ -779,16 +796,17 @@ std::filesystem::path CreateDatabase(const std::filesystem::path &db_path_) { } // namespace DatabaseWriterImpl::~DatabaseWriterImpl(void) { - + // Join the bulk insertion thread FIRST so its database connection is closed + // before we run any cleanup SQL on the main connection. Otherwise SQLite + // can return "database is locked" due to concurrent writers. ExitDictionaries(); insertion_queue.enqueue(ExitSignal{}); bulk_insertion_thread.join(); -// for (const char *stmt : DatabaseWriter::kExitStatments) { -// db.Execute(stmt); -// } - + // These may fail with "database is locked" if the async writer's + // SQLite connection hasn't fully released its WAL lock. + // Each step is isolated so failures don't cascade. ExitRecords(); ExitMetadata(); db.Execute("PRAGMA wal_checkpoint(FULL)"); @@ -1010,9 +1028,12 @@ void DatabaseWriterImpl::InitRecords(void) { void DatabaseWriterImpl::ExitRecords(void) { #ifndef __CDT_PARSER__ #define MX_EXEC_TEARDOWNS(record) \ - for (const char *stmt : record::kExitStatements) { \ - if (stmt) { \ - db.Execute(stmt); \ + { \ + sqlite::ExclusiveTransaction transaction(db); \ + for (const char *stmt : record::kExitStatements) { \ + if (stmt) { \ + db.Execute(stmt); \ + } \ } \ } diff --git a/lib/EntityProvider.cpp b/lib/EntityProvider.cpp index 476ba4cd2..0bface543 100644 --- a/lib/EntityProvider.cpp +++ b/lib/EntityProvider.cpp @@ -383,12 +383,13 @@ inline static RawEntityId DefinitionId(const Args&...) { } MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_FRAGMENT_OFFSET_LISTERS, - MX_DECLARE_FRAGMENT_PSEUDO_LISTERS, - MX_IGNORE_ENTITY_CATEGORY) + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_FRAGMENT_OFFSET_LISTERS, + MX_DECLARE_FRAGMENT_PSEUDO_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_FRAGMENT_OFFSET_LISTERS #undef MX_DECLARE_FRAGMENT_PSEUDO_LISTERS diff --git a/lib/EntityProvider.h b/lib/EntityProvider.h index 045a24894..a84fea2f7 100644 --- a/lib/EntityProvider.h +++ b/lib/EntityProvider.h @@ -9,10 +9,15 @@ #include #include #include +#include +#include +#include +#include #include #include #include "Entity.h" +#include "IR/Impl.h" namespace mx { @@ -68,6 +73,9 @@ class EntityProvider { // caches. virtual void VersionNumberChanged(unsigned new_version_number) = 0; + // Get the index version (unique ID + version number). + virtual IndexVersion GetIndexVersion(void) = 0; + // Clear the cache. virtual void ClearCache(void) = 0; @@ -127,6 +135,7 @@ class EntityProvider { MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER) #undef MX_DECLARE_ENTITY_GETTER @@ -140,6 +149,7 @@ class EntityProvider { MX_IGNORE_ENTITY_CATEGORY, MX_DECLARE_ENTITY_LISTERS, MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS @@ -153,6 +163,7 @@ class EntityProvider { MX_IGNORE_ENTITY_CATEGORY, MX_DECLARE_ENTITY_LISTERS, MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS @@ -166,6 +177,7 @@ class EntityProvider { MX_IGNORE_ENTITY_CATEGORY, MX_DECLARE_ENTITY_LISTERS, MX_DECLARE_ENTITY_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS diff --git a/lib/File.cpp b/lib/File.cpp index 18cfc5963..7bf524d29 100644 --- a/lib/File.cpp +++ b/lib/File.cpp @@ -244,6 +244,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_DEFINE_CONTAINING, MX_DEFINE_CONTAINING, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DEFINE_CONTAINING @@ -255,6 +256,7 @@ std::optional File::containing(const VariantEntity &entity) noexcept { MX_FOR_EACH_ENTITY_CATEGORY(GET_FILE, GET_FILE, MX_IGNORE_ENTITY_CATEGORY, GET_FILE, GET_FILE, GET_FILE, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) return std::nullopt; #undef GET_FILE diff --git a/lib/Fragment.cpp b/lib/Fragment.cpp index a28dc3e25..15754f55d 100644 --- a/lib/Fragment.cpp +++ b/lib/Fragment.cpp @@ -133,6 +133,7 @@ std::optional Fragment::containing( GET_FRAGMENT, GET_FRAGMENT, GET_FRAGMENT, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) return std::nullopt; #undef GET_FRAGMENT diff --git a/lib/IR.capnp b/lib/IR.capnp new file mode 100644 index 000000000..b652f3970 --- /dev/null +++ b/lib/IR.capnp @@ -0,0 +1,55 @@ +@0xa5321e2fb1267b91; + +using Cxx = import "/capnp/c++.capnp"; +$Cxx.namespace("mx::rpc::ir"); + +struct Object @0xa7625c6bfddc036b { + sourceDeclId @0 :UInt64; + typeEntityId @1 :UInt64; + sizeBytes @2 :UInt32; + alignBytes @3 :UInt32; + kind @4 :UInt8; +} + +struct Instruction @0xc6bb311936d9962b { + entityOffset @0 :UInt32; # Start index into fragment's irEntityPool + constOffset @1 :UInt32; # Start index into fragment's irIntPool + users @2 :List(UInt64); # IRInstructionId entity IDs of instructions using this value + numOperands @3 :UInt8; # Number of data-flow operand entity IDs + opcode @4 :UInt8; # OpCode enum + constWidth @5 :UInt8; # Bit width for constants + flags @6 :UInt8; # Bit flags +} + +struct Block @0xb1141386bcc94b26 { + entityOffset @0 :UInt32; + numInstructions @1 :UInt16; + numSuccessors @2 :UInt16; + numPredecessors @3 :UInt16; + numDominators @4 :UInt16; + numPostDominators @5 :UInt16; + kind @6 :UInt8; + parentStructureId @7 :UInt64; # IRStructureId of enclosing structure +} + +struct Structure @0xd4a8b7c2e9f31056 { + sourceEntityId @0 :UInt64; # AST Stmt/Decl entity ID + parentId @1 :UInt64; # IRStructureId of parent (or IRFunctionId) + kind @2 :UInt8; # StructureKind + entityOffset @3 :UInt32; # into irEntityPool for children + numChildren @4 :UInt16; # child structure/block entity IDs + numObjects @5 :UInt16; # ALLOCAs declared in this scope (scopes only) + caseLow @6 :Int64; # SWITCH_CASE: case value lower bound + caseHigh @7 :Int64; # SWITCH_CASE: case value upper bound + isDefault @8 :Bool; # SWITCH_CASE: true for default case +} + +struct Function @0xe6be31a259218610 { + sourceDeclEntityId @0 :UInt64; # FunctionDecl for NORMAL, VarDecl for GLOBAL_INITIALIZER + entryBlockId @1 :UInt64; + numBlocks @2 :UInt16; + numObjects @3 :UInt16; + entityOffset @4 :UInt32; + kind @5 :UInt8; # FunctionKind enum (0 = NORMAL) + bodyScopeId @6 :UInt64; # IRStructureId of FUNCTION_SCOPE (root of structure tree) +} diff --git a/lib/IR.capnp.c++ b/lib/IR.capnp.c++ new file mode 100644 index 000000000..d2705fb26 --- /dev/null +++ b/lib/IR.capnp.c++ @@ -0,0 +1,794 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: IR.capnp + +#include "IR.capnp.h" + +namespace capnp { +namespace schemas { +static const ::capnp::_::AlignedData<95> b_a7625c6bfddc036b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 107, 3, 220, 253, 107, 92, 98, 167, + 9, 0, 0, 0, 1, 0, 4, 0, + 145, 123, 38, 177, 47, 30, 50, 165, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 130, 0, 0, 0, + 25, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 82, 46, 99, 97, 112, 110, 112, + 58, 79, 98, 106, 101, 99, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 0, 0, 0, 3, 0, 1, 0, + 144, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 0, 0, 0, 3, 0, 1, 0, + 152, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 3, 0, 1, 0, + 160, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 24, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 1, 0, + 164, 0, 0, 0, 2, 0, 1, 0, + 115, 111, 117, 114, 99, 101, 68, 101, + 99, 108, 73, 100, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 121, 112, 101, 69, 110, 116, 105, + 116, 121, 73, 100, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 105, 122, 101, 66, 121, 116, 101, + 115, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 108, 105, 103, 110, 66, 121, 116, + 101, 115, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 107, 105, 110, 100, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a7625c6bfddc036b = b_a7625c6bfddc036b.words; +#if !CAPNP_LITE +static const uint16_t m_a7625c6bfddc036b[] = {3, 4, 2, 0, 1}; +static const uint16_t i_a7625c6bfddc036b[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_a7625c6bfddc036b = { + 0xa7625c6bfddc036b, b_a7625c6bfddc036b.words, 95, nullptr, m_a7625c6bfddc036b, + 0, 5, i_a7625c6bfddc036b, nullptr, nullptr, { &s_a7625c6bfddc036b, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<130> b_c6bb311936d9962b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 43, 150, 217, 54, 25, 49, 187, 198, + 9, 0, 0, 0, 1, 0, 2, 0, + 145, 123, 38, 177, 47, 30, 50, 165, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 170, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 143, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 82, 46, 99, 97, 112, 110, 112, + 58, 73, 110, 115, 116, 114, 117, 99, + 116, 105, 111, 110, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 28, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 180, 0, 0, 0, 3, 0, 1, 0, + 192, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 188, 0, 0, 0, 3, 0, 1, 0, + 200, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 197, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 3, 0, 1, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 217, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 0, 0, 0, 3, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 3, 0, 1, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 229, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 0, 0, 0, 3, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 3, 0, 1, 0, + 244, 0, 0, 0, 2, 0, 1, 0, + 101, 110, 116, 105, 116, 121, 79, 102, + 102, 115, 101, 116, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 110, 115, 116, 79, 102, 102, + 115, 101, 116, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 115, 101, 114, 115, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 79, 112, 101, 114, 97, + 110, 100, 115, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 112, 99, 111, 100, 101, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 110, 115, 116, 87, 105, 100, + 116, 104, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 97, 103, 115, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c6bb311936d9962b = b_c6bb311936d9962b.words; +#if !CAPNP_LITE +static const uint16_t m_c6bb311936d9962b[] = {1, 5, 0, 6, 3, 4, 2}; +static const uint16_t i_c6bb311936d9962b[] = {0, 1, 2, 3, 4, 5, 6}; +const ::capnp::_::RawSchema s_c6bb311936d9962b = { + 0xc6bb311936d9962b, b_c6bb311936d9962b.words, 130, nullptr, m_c6bb311936d9962b, + 0, 7, i_c6bb311936d9962b, nullptr, nullptr, { &s_c6bb311936d9962b, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<145> b_b1141386bcc94b26 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 38, 75, 201, 188, 134, 19, 20, 177, + 9, 0, 0, 0, 1, 0, 3, 0, + 145, 123, 38, 177, 47, 30, 50, 165, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 122, 0, 0, 0, + 25, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 199, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 82, 46, 99, 97, 112, 110, 112, + 58, 66, 108, 111, 99, 107, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 32, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 0, 0, 0, 3, 0, 1, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 217, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 0, 0, 0, 3, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 0, 0, 0, 3, 0, 1, 0, + 236, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 3, 0, 1, 0, + 244, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 241, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 240, 0, 0, 0, 3, 0, 1, 0, + 252, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 249, 0, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 252, 0, 0, 0, 3, 0, 1, 0, + 8, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 1, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 3, 0, 1, 0, + 12, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 1, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 0, 0, 3, 0, 1, 0, + 24, 1, 0, 0, 2, 0, 1, 0, + 101, 110, 116, 105, 116, 121, 79, 102, + 102, 115, 101, 116, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 73, 110, 115, 116, 114, + 117, 99, 116, 105, 111, 110, 115, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 83, 117, 99, 99, 101, + 115, 115, 111, 114, 115, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 80, 114, 101, 100, 101, + 99, 101, 115, 115, 111, 114, 115, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 68, 111, 109, 105, 110, + 97, 116, 111, 114, 115, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 80, 111, 115, 116, 68, + 111, 109, 105, 110, 97, 116, 111, 114, + 115, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 107, 105, 110, 100, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 114, 101, 110, 116, 83, 116, + 114, 117, 99, 116, 117, 114, 101, 73, + 100, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b1141386bcc94b26 = b_b1141386bcc94b26.words; +#if !CAPNP_LITE +static const uint16_t m_b1141386bcc94b26[] = {0, 6, 4, 1, 5, 3, 2, 7}; +static const uint16_t i_b1141386bcc94b26[] = {0, 1, 2, 3, 4, 5, 6, 7}; +const ::capnp::_::RawSchema s_b1141386bcc94b26 = { + 0xb1141386bcc94b26, b_b1141386bcc94b26.words, 145, nullptr, m_b1141386bcc94b26, + 0, 8, i_b1141386bcc94b26, nullptr, nullptr, { &s_b1141386bcc94b26, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<159> b_d4a8b7c2e9f31056 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 86, 16, 243, 233, 194, 183, 168, 212, + 9, 0, 0, 0, 1, 0, 6, 0, + 145, 123, 38, 177, 47, 30, 50, 165, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 154, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 255, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 82, 46, 99, 97, 112, 110, 112, + 58, 83, 116, 114, 117, 99, 116, 117, + 114, 101, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 36, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 0, 0, 0, 3, 0, 1, 0, + 248, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 245, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 244, 0, 0, 0, 3, 0, 1, 0, + 0, 1, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 253, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 0, 0, 0, 3, 0, 1, 0, + 4, 1, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 3, 0, 1, 0, + 12, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 1, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 1, 0, 0, 3, 0, 1, 0, + 20, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 1, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 1, 0, 0, 3, 0, 1, 0, + 28, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 20, 1, 0, 0, 3, 0, 1, 0, + 32, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 1, 0, 0, 3, 0, 1, 0, + 40, 1, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 136, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 1, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 1, 0, 0, 3, 0, 1, 0, + 48, 1, 0, 0, 2, 0, 1, 0, + 115, 111, 117, 114, 99, 101, 69, 110, + 116, 105, 116, 121, 73, 100, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 114, 101, 110, 116, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 107, 105, 110, 100, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 116, 105, 116, 121, 79, 102, + 102, 115, 101, 116, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 67, 104, 105, 108, 100, + 114, 101, 110, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 79, 98, 106, 101, 99, + 116, 115, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 115, 101, 76, 111, 119, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 115, 101, 72, 105, 103, 104, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 115, 68, 101, 102, 97, 117, 108, + 116, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d4a8b7c2e9f31056 = b_d4a8b7c2e9f31056.words; +#if !CAPNP_LITE +static const uint16_t m_d4a8b7c2e9f31056[] = {7, 6, 3, 8, 2, 4, 5, 1, 0}; +static const uint16_t i_d4a8b7c2e9f31056[] = {0, 1, 2, 3, 4, 5, 6, 7, 8}; +const ::capnp::_::RawSchema s_d4a8b7c2e9f31056 = { + 0xd4a8b7c2e9f31056, b_d4a8b7c2e9f31056.words, 159, nullptr, m_d4a8b7c2e9f31056, + 0, 9, i_d4a8b7c2e9f31056, nullptr, nullptr, { &s_d4a8b7c2e9f31056, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<129> b_e6be31a259218610 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 16, 134, 33, 89, 162, 49, 190, 230, + 9, 0, 0, 0, 1, 0, 5, 0, + 145, 123, 38, 177, 47, 30, 50, 165, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 146, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 143, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 82, 46, 99, 97, 112, 110, 112, + 58, 70, 117, 110, 99, 116, 105, 111, + 110, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 28, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 0, 0, 0, 154, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 0, 0, 0, 3, 0, 1, 0, + 196, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 193, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 0, 0, 0, 3, 0, 1, 0, + 204, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 0, 0, 0, 3, 0, 1, 0, + 212, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 0, 0, 0, 3, 0, 1, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 217, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 0, 0, 0, 3, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 24, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 3, 0, 1, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 229, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 0, 0, 0, 3, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 115, 111, 117, 114, 99, 101, 68, 101, + 99, 108, 69, 110, 116, 105, 116, 121, + 73, 100, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 116, 114, 121, 66, 108, 111, + 99, 107, 73, 100, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 66, 108, 111, 99, 107, + 115, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 79, 98, 106, 101, 99, + 116, 115, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 116, 105, 116, 121, 79, 102, + 102, 115, 101, 116, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 107, 105, 110, 100, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 100, 121, 83, 99, 111, 112, + 101, 73, 100, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e6be31a259218610 = b_e6be31a259218610.words; +#if !CAPNP_LITE +static const uint16_t m_e6be31a259218610[] = {6, 4, 1, 5, 2, 3, 0}; +static const uint16_t i_e6be31a259218610[] = {0, 1, 2, 3, 4, 5, 6}; +const ::capnp::_::RawSchema s_e6be31a259218610 = { + 0xe6be31a259218610, b_e6be31a259218610.words, 129, nullptr, m_e6be31a259218610, + 0, 7, i_e6be31a259218610, nullptr, nullptr, { &s_e6be31a259218610, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +} // namespace schemas +} // namespace capnp + +// ======================================================================================= + +namespace mx { +namespace rpc { +namespace ir { + +// Object +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Object::_capnpPrivate::dataWordSize; +constexpr uint16_t Object::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Object::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Object::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// Instruction +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Instruction::_capnpPrivate::dataWordSize; +constexpr uint16_t Instruction::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Instruction::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Instruction::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// Block +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Block::_capnpPrivate::dataWordSize; +constexpr uint16_t Block::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Block::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Block::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// Structure +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Structure::_capnpPrivate::dataWordSize; +constexpr uint16_t Structure::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Structure::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Structure::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// Function +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Function::_capnpPrivate::dataWordSize; +constexpr uint16_t Function::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Function::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Function::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + + +} // namespace +} // namespace +} // namespace + diff --git a/lib/IR.capnp.h b/lib/IR.capnp.h new file mode 100644 index 000000000..53853c18f --- /dev/null +++ b/lib/IR.capnp.h @@ -0,0 +1,1187 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: IR.capnp + +#pragma once + +#include +#include + +#ifndef CAPNP_VERSION +#error "CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?" +#elif CAPNP_VERSION != 1001000 +#error "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." +#endif + + +CAPNP_BEGIN_HEADER + +namespace capnp { +namespace schemas { + +CAPNP_DECLARE_SCHEMA(a7625c6bfddc036b); +CAPNP_DECLARE_SCHEMA(c6bb311936d9962b); +CAPNP_DECLARE_SCHEMA(b1141386bcc94b26); +CAPNP_DECLARE_SCHEMA(d4a8b7c2e9f31056); +CAPNP_DECLARE_SCHEMA(e6be31a259218610); + +} // namespace schemas +} // namespace capnp + +namespace mx { +namespace rpc { +namespace ir { + +struct Object { + Object() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a7625c6bfddc036b, 4, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct Instruction { + Instruction() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c6bb311936d9962b, 2, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct Block { + Block() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b1141386bcc94b26, 3, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct Structure { + Structure() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d4a8b7c2e9f31056, 6, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct Function { + Function() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e6be31a259218610, 5, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +// ======================================================================================= + +class Object::Reader { +public: + typedef Object Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getSourceDeclId() const; + + inline ::uint64_t getTypeEntityId() const; + + inline ::uint32_t getSizeBytes() const; + + inline ::uint32_t getAlignBytes() const; + + inline ::uint8_t getKind() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Object::Builder { +public: + typedef Object Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getSourceDeclId(); + inline void setSourceDeclId( ::uint64_t value); + + inline ::uint64_t getTypeEntityId(); + inline void setTypeEntityId( ::uint64_t value); + + inline ::uint32_t getSizeBytes(); + inline void setSizeBytes( ::uint32_t value); + + inline ::uint32_t getAlignBytes(); + inline void setAlignBytes( ::uint32_t value); + + inline ::uint8_t getKind(); + inline void setKind( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Object::Pipeline { +public: + typedef Object Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class Instruction::Reader { +public: + typedef Instruction Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getEntityOffset() const; + + inline ::uint32_t getConstOffset() const; + + inline bool hasUsers() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUsers() const; + + inline ::uint8_t getNumOperands() const; + + inline ::uint8_t getOpcode() const; + + inline ::uint8_t getConstWidth() const; + + inline ::uint8_t getFlags() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Instruction::Builder { +public: + typedef Instruction Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getEntityOffset(); + inline void setEntityOffset( ::uint32_t value); + + inline ::uint32_t getConstOffset(); + inline void setConstOffset( ::uint32_t value); + + inline bool hasUsers(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getUsers(); + inline void setUsers( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUsers(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initUsers(unsigned int size); + inline void adoptUsers(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownUsers(); + + inline ::uint8_t getNumOperands(); + inline void setNumOperands( ::uint8_t value); + + inline ::uint8_t getOpcode(); + inline void setOpcode( ::uint8_t value); + + inline ::uint8_t getConstWidth(); + inline void setConstWidth( ::uint8_t value); + + inline ::uint8_t getFlags(); + inline void setFlags( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Instruction::Pipeline { +public: + typedef Instruction Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class Block::Reader { +public: + typedef Block Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getEntityOffset() const; + + inline ::uint16_t getNumInstructions() const; + + inline ::uint16_t getNumSuccessors() const; + + inline ::uint16_t getNumPredecessors() const; + + inline ::uint16_t getNumDominators() const; + + inline ::uint16_t getNumPostDominators() const; + + inline ::uint8_t getKind() const; + + inline ::uint64_t getParentStructureId() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Block::Builder { +public: + typedef Block Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getEntityOffset(); + inline void setEntityOffset( ::uint32_t value); + + inline ::uint16_t getNumInstructions(); + inline void setNumInstructions( ::uint16_t value); + + inline ::uint16_t getNumSuccessors(); + inline void setNumSuccessors( ::uint16_t value); + + inline ::uint16_t getNumPredecessors(); + inline void setNumPredecessors( ::uint16_t value); + + inline ::uint16_t getNumDominators(); + inline void setNumDominators( ::uint16_t value); + + inline ::uint16_t getNumPostDominators(); + inline void setNumPostDominators( ::uint16_t value); + + inline ::uint8_t getKind(); + inline void setKind( ::uint8_t value); + + inline ::uint64_t getParentStructureId(); + inline void setParentStructureId( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Block::Pipeline { +public: + typedef Block Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class Structure::Reader { +public: + typedef Structure Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getSourceEntityId() const; + + inline ::uint64_t getParentId() const; + + inline ::uint8_t getKind() const; + + inline ::uint32_t getEntityOffset() const; + + inline ::uint16_t getNumChildren() const; + + inline ::uint16_t getNumObjects() const; + + inline ::int64_t getCaseLow() const; + + inline ::int64_t getCaseHigh() const; + + inline bool getIsDefault() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Structure::Builder { +public: + typedef Structure Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getSourceEntityId(); + inline void setSourceEntityId( ::uint64_t value); + + inline ::uint64_t getParentId(); + inline void setParentId( ::uint64_t value); + + inline ::uint8_t getKind(); + inline void setKind( ::uint8_t value); + + inline ::uint32_t getEntityOffset(); + inline void setEntityOffset( ::uint32_t value); + + inline ::uint16_t getNumChildren(); + inline void setNumChildren( ::uint16_t value); + + inline ::uint16_t getNumObjects(); + inline void setNumObjects( ::uint16_t value); + + inline ::int64_t getCaseLow(); + inline void setCaseLow( ::int64_t value); + + inline ::int64_t getCaseHigh(); + inline void setCaseHigh( ::int64_t value); + + inline bool getIsDefault(); + inline void setIsDefault(bool value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Structure::Pipeline { +public: + typedef Structure Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class Function::Reader { +public: + typedef Function Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getSourceDeclEntityId() const; + + inline ::uint64_t getEntryBlockId() const; + + inline ::uint16_t getNumBlocks() const; + + inline ::uint16_t getNumObjects() const; + + inline ::uint32_t getEntityOffset() const; + + inline ::uint8_t getKind() const; + + inline ::uint64_t getBodyScopeId() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Function::Builder { +public: + typedef Function Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getSourceDeclEntityId(); + inline void setSourceDeclEntityId( ::uint64_t value); + + inline ::uint64_t getEntryBlockId(); + inline void setEntryBlockId( ::uint64_t value); + + inline ::uint16_t getNumBlocks(); + inline void setNumBlocks( ::uint16_t value); + + inline ::uint16_t getNumObjects(); + inline void setNumObjects( ::uint16_t value); + + inline ::uint32_t getEntityOffset(); + inline void setEntityOffset( ::uint32_t value); + + inline ::uint8_t getKind(); + inline void setKind( ::uint8_t value); + + inline ::uint64_t getBodyScopeId(); + inline void setBodyScopeId( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Function::Pipeline { +public: + typedef Function Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +// ======================================================================================= + +inline ::uint64_t Object::Reader::getSourceDeclId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Object::Builder::getSourceDeclId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Object::Builder::setSourceDeclId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Object::Reader::getTypeEntityId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Object::Builder::getTypeEntityId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void Object::Builder::setTypeEntityId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t Object::Reader::getSizeBytes() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t Object::Builder::getSizeBytes() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void Object::Builder::setSizeBytes( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t Object::Reader::getAlignBytes() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t Object::Builder::getAlignBytes() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void Object::Builder::setAlignBytes( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t Object::Reader::getKind() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<24>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Object::Builder::getKind() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<24>() * ::capnp::ELEMENTS); +} +inline void Object::Builder::setKind( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<24>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t Instruction::Reader::getEntityOffset() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t Instruction::Builder::getEntityOffset() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Instruction::Builder::setEntityOffset( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t Instruction::Reader::getConstOffset() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t Instruction::Builder::getConstOffset() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void Instruction::Builder::setConstOffset( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline bool Instruction::Reader::hasUsers() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool Instruction::Builder::hasUsers() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Instruction::Reader::getUsers() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Instruction::Builder::getUsers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Instruction::Builder::setUsers( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void Instruction::Builder::setUsers(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Instruction::Builder::initUsers(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void Instruction::Builder::adoptUsers( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Instruction::Builder::disownUsers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint8_t Instruction::Reader::getNumOperands() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Instruction::Builder::getNumOperands() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} +inline void Instruction::Builder::setNumOperands( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t Instruction::Reader::getOpcode() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Instruction::Builder::getOpcode() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} +inline void Instruction::Builder::setOpcode( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t Instruction::Reader::getConstWidth() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<10>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Instruction::Builder::getConstWidth() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<10>() * ::capnp::ELEMENTS); +} +inline void Instruction::Builder::setConstWidth( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<10>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t Instruction::Reader::getFlags() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<11>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Instruction::Builder::getFlags() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<11>() * ::capnp::ELEMENTS); +} +inline void Instruction::Builder::setFlags( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<11>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t Block::Reader::getEntityOffset() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t Block::Builder::getEntityOffset() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setEntityOffset( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Block::Reader::getNumInstructions() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Block::Builder::getNumInstructions() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setNumInstructions( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Block::Reader::getNumSuccessors() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Block::Builder::getNumSuccessors() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setNumSuccessors( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Block::Reader::getNumPredecessors() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Block::Builder::getNumPredecessors() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setNumPredecessors( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Block::Reader::getNumDominators() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Block::Builder::getNumDominators() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setNumDominators( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Block::Reader::getNumPostDominators() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<6>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Block::Builder::getNumPostDominators() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<6>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setNumPostDominators( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t Block::Reader::getKind() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<14>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Block::Builder::getKind() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<14>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setKind( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<14>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Block::Reader::getParentStructureId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Block::Builder::getParentStructureId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void Block::Builder::setParentStructureId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Structure::Reader::getSourceEntityId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Structure::Builder::getSourceEntityId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setSourceEntityId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Structure::Reader::getParentId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Structure::Builder::getParentId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setParentId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t Structure::Reader::getKind() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Structure::Builder::getKind() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setKind( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t Structure::Reader::getEntityOffset() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t Structure::Builder::getEntityOffset() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setEntityOffset( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Structure::Reader::getNumChildren() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Structure::Builder::getNumChildren() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setNumChildren( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Structure::Reader::getNumObjects() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Structure::Builder::getNumObjects() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setNumObjects( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS, value); +} + +inline ::int64_t Structure::Reader::getCaseLow() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline ::int64_t Structure::Builder::getCaseLow() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setCaseLow( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +inline ::int64_t Structure::Reader::getCaseHigh() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::int64_t Structure::Builder::getCaseHigh() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setCaseHigh( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline bool Structure::Reader::getIsDefault() const { + return _reader.getDataField( + ::capnp::bounded<136>() * ::capnp::ELEMENTS); +} + +inline bool Structure::Builder::getIsDefault() { + return _builder.getDataField( + ::capnp::bounded<136>() * ::capnp::ELEMENTS); +} +inline void Structure::Builder::setIsDefault(bool value) { + _builder.setDataField( + ::capnp::bounded<136>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Function::Reader::getSourceDeclEntityId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Function::Builder::getSourceDeclEntityId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Function::Builder::setSourceDeclEntityId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Function::Reader::getEntryBlockId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Function::Builder::getEntryBlockId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void Function::Builder::setEntryBlockId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Function::Reader::getNumBlocks() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Function::Builder::getNumBlocks() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} +inline void Function::Builder::setNumBlocks( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t Function::Reader::getNumObjects() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t Function::Builder::getNumObjects() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} +inline void Function::Builder::setNumObjects( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t Function::Reader::getEntityOffset() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t Function::Builder::getEntityOffset() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void Function::Builder::setEntityOffset( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t Function::Reader::getKind() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<24>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t Function::Builder::getKind() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<24>() * ::capnp::ELEMENTS); +} +inline void Function::Builder::setKind( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<24>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Function::Reader::getBodyScopeId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Function::Builder::getBodyScopeId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void Function::Builder::setBodyScopeId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +} // namespace +} // namespace +} // namespace + +CAPNP_END_HEADER + diff --git a/lib/IR/Block.cpp b/lib/IR/Block.cpp new file mode 100644 index 000000000..2ed956216 --- /dev/null +++ b/lib/IR/Block.cpp @@ -0,0 +1,191 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include +#include +#include +#include + +#include "Impl.h" +#include "../Fragment.h" + +namespace mx { + +// Entity pool layout per block (starting at entityOffset): +// [inst0..instN, succ0..succN, pred0..predN, +// idom, dom0..domN, ipdom, pdom0..pdomN] + +static capnp::List::Reader +GetEntityPool(const IRBlockImpl &impl) { + return impl.frag->reader.getIrEntityPool(); +} + +EntityId IRBlock::id(void) const { + if (!impl) return {}; + IRBlockId bid; + bid.fragment_id = impl->fragment_id; + bid.offset = impl->offset; + bid.block_kind = kind(); + return EntityId(bid); +} + +ir::BlockKind IRBlock::kind(void) const { + if (!impl) return ir::BlockKind::GENERIC; + return static_cast(impl->reader().getKind()); +} + +std::optional IRBlock::parent_structure(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getParentStructureId(); + if (eid == kInvalidEntityId) return std::nullopt; + auto vid = EntityId(eid).Unpack(); + if (auto *sid = std::get_if(&vid)) { + return IRStructure(std::make_shared( + impl->frag, sid->offset, impl->fragment_id)); + } + return std::nullopt; +} + +std::optional IRBlock::parent_function(void) const { + auto s = parent_structure(); + while (s) { + if (auto f = s->parent_function()) return f; + s = s->parent_structure(); + } + return std::nullopt; +} + +gap::generator IRBlock::all_instructions(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset(); + uint16_t n = r.getNumInstructions(); + for (uint16_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *iid = std::get_if(&vid)) { + co_yield IRInstruction(std::make_shared( + impl->frag, iid->offset, impl->fragment_id)); + } + } +} + +gap::generator IRBlock::instructions(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + auto all_insts = impl->frag->reader.getIrInstructions(); + auto full_pool = impl->frag->reader.getIrEntityPool(); + uint32_t base = r.getEntityOffset(); + uint16_t n = r.getNumInstructions(); + for (uint16_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *iid = std::get_if(&vid)) { + // Root instructions have an IRBlockId at their pool position 0. + auto parent_eid = full_pool[all_insts[iid->offset].getEntityOffset()]; + if (std::holds_alternative(EntityId(parent_eid).Unpack())) { + co_yield IRInstruction(std::make_shared( + impl->frag, iid->offset, impl->fragment_id)); + } + } + } +} + +// Helper to read a block from a pool entity ID. +static std::optional BlockFromPoolEid( + const FragmentImplPtr &frag, RawEntityId fragment_id, uint64_t eid) { + auto vid = EntityId(eid).Unpack(); + if (auto *bid = std::get_if(&vid)) { + return IRBlock(std::make_shared(frag, bid->offset, fragment_id)); + } + return std::nullopt; +} + +gap::generator IRBlock::successors(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset() + r.getNumInstructions(); + for (uint16_t i = 0; i < r.getNumSuccessors(); ++i) { + if (auto b = BlockFromPoolEid(impl->frag, impl->fragment_id, pool[base + i])) { + co_yield *b; + } + } +} + +gap::generator IRBlock::predecessors(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset() + r.getNumInstructions() + r.getNumSuccessors(); + for (uint16_t i = 0; i < r.getNumPredecessors(); ++i) { + if (auto b = BlockFromPoolEid(impl->frag, impl->fragment_id, pool[base + i])) { + co_yield *b; + } + } +} + +std::optional IRBlock::immediate_dominator(void) const { + if (!impl) return std::nullopt; + auto r = impl->reader(); + if (r.getNumDominators() == 0) return std::nullopt; + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset() + r.getNumInstructions() + + r.getNumSuccessors() + r.getNumPredecessors(); + return BlockFromPoolEid(impl->frag, impl->fragment_id, pool[base]); +} + +std::optional IRBlock::immediate_post_dominator(void) const { + if (!impl) return std::nullopt; + auto r = impl->reader(); + if (r.getNumPostDominators() == 0) return std::nullopt; + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset() + r.getNumInstructions() + + r.getNumSuccessors() + r.getNumPredecessors() + r.getNumDominators(); + return BlockFromPoolEid(impl->frag, impl->fragment_id, pool[base]); +} + +gap::generator IRBlock::dominators(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset() + r.getNumInstructions() + + r.getNumSuccessors() + r.getNumPredecessors(); + for (uint16_t i = 0; i < r.getNumDominators(); ++i) { + if (auto b = BlockFromPoolEid(impl->frag, impl->fragment_id, pool[base + i])) { + co_yield *b; + } + } +} + +gap::generator IRBlock::post_dominators(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset() + r.getNumInstructions() + + r.getNumSuccessors() + r.getNumPredecessors() + r.getNumDominators(); + for (uint16_t i = 0; i < r.getNumPostDominators(); ++i) { + if (auto b = BlockFromPoolEid(impl->frag, impl->fragment_id, pool[base + i])) { + co_yield *b; + } + } +} + +bool IRBlock::dominates(const IRBlock &other) const { + if (!impl || !other.impl) return false; + auto my_id = id().Pack(); + auto r = other.impl->reader(); + auto pool = GetEntityPool(*other.impl); + uint32_t base = r.getEntityOffset() + r.getNumInstructions() + + r.getNumSuccessors() + r.getNumPredecessors(); + for (uint16_t i = 0; i < r.getNumDominators(); ++i) { + if (pool[base + i] == my_id) return true; + } + return false; +} + +} // namespace mx diff --git a/lib/IR/Enums.cpp b/lib/IR/Enums.cpp new file mode 100644 index 000000000..086b3f96e --- /dev/null +++ b/lib/IR/Enums.cpp @@ -0,0 +1,622 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include +#include +#include +#include +#include +#include + +namespace mx::ir { + +const char *EnumeratorName(OpCode op) noexcept { + switch (op) { + case OpCode::CONST: return "CONST"; + case OpCode::ALLOCA: return "ALLOCA"; + case OpCode::MEMORY: return "MEMORY"; + case OpCode::LOGICAL_AND: return "LOGICAL_AND"; + case OpCode::LOGICAL_OR: return "LOGICAL_OR"; + case OpCode::PTR_DIFF_32: return "PTR_DIFF_32"; + case OpCode::PTR_DIFF_64: return "PTR_DIFF_64"; + case OpCode::LOGICAL_NOT: return "LOGICAL_NOT"; + case OpCode::CAST: return "CAST"; + case OpCode::CALL: return "CALL"; + case OpCode::READ_MODIFY_WRITE: return "READ_MODIFY_WRITE"; + case OpCode::SELECT: return "SELECT"; + case OpCode::COND_BRANCH: return "COND_BRANCH"; + case OpCode::SWITCH: return "SWITCH"; + case OpCode::RET: return "RET"; + case OpCode::UNREACHABLE: return "UNREACHABLE"; + case OpCode::BREAK: return "BREAK"; + case OpCode::CONTINUE: return "CONTINUE"; + case OpCode::GOTO: return "GOTO"; + case OpCode::IMPLICIT_GOTO: return "IMPLICIT_GOTO"; + case OpCode::FALLTHROUGH: return "FALLTHROUGH"; + case OpCode::IMPLICIT_FALLTHROUGH: return "IMPLICIT_FALLTHROUGH"; + case OpCode::IMPLICIT_UNREACHABLE: return "IMPLICIT_UNREACHABLE"; + case OpCode::VA_START: return "VA_START"; + case OpCode::VA_COPY: return "VA_COPY"; + case OpCode::VA_END: return "VA_END"; + case OpCode::ENTER_SCOPE: return "ENTER_SCOPE"; + case OpCode::EXIT_SCOPE: return "EXIT_SCOPE"; + case OpCode::BITWISE_8: return "BITWISE_8"; + case OpCode::BITWISE_16: return "BITWISE_16"; + case OpCode::BITWISE_32: return "BITWISE_32"; + case OpCode::BITWISE_64: return "BITWISE_64"; + case OpCode::ABS_8: return "ABS_8"; + case OpCode::ABS_16: return "ABS_16"; + case OpCode::ABS_32: return "ABS_32"; + case OpCode::ABS_64: return "ABS_64"; + case OpCode::FLOAT: return "FLOAT"; + case OpCode::UNDEFINED: return "UNDEFINED"; + case OpCode::ATOMIC_ADD_8: return "ATOMIC_ADD_8"; + case OpCode::ATOMIC_ADD_16: return "ATOMIC_ADD_16"; + case OpCode::ATOMIC_ADD_32: return "ATOMIC_ADD_32"; + case OpCode::ATOMIC_ADD_64: return "ATOMIC_ADD_64"; + case OpCode::ATOMIC_SUB_8: return "ATOMIC_SUB_8"; + case OpCode::ATOMIC_SUB_16: return "ATOMIC_SUB_16"; + case OpCode::ATOMIC_SUB_32: return "ATOMIC_SUB_32"; + case OpCode::ATOMIC_SUB_64: return "ATOMIC_SUB_64"; + case OpCode::ATOMIC_AND_8: return "ATOMIC_AND_8"; + case OpCode::ATOMIC_AND_16: return "ATOMIC_AND_16"; + case OpCode::ATOMIC_AND_32: return "ATOMIC_AND_32"; + case OpCode::ATOMIC_AND_64: return "ATOMIC_AND_64"; + case OpCode::ATOMIC_OR_8: return "ATOMIC_OR_8"; + case OpCode::ATOMIC_OR_16: return "ATOMIC_OR_16"; + case OpCode::ATOMIC_OR_32: return "ATOMIC_OR_32"; + case OpCode::ATOMIC_OR_64: return "ATOMIC_OR_64"; + case OpCode::ATOMIC_XOR_8: return "ATOMIC_XOR_8"; + case OpCode::ATOMIC_XOR_16: return "ATOMIC_XOR_16"; + case OpCode::ATOMIC_XOR_32: return "ATOMIC_XOR_32"; + case OpCode::ATOMIC_XOR_64: return "ATOMIC_XOR_64"; + case OpCode::ATOMIC_NAND_8: return "ATOMIC_NAND_8"; + case OpCode::ATOMIC_NAND_16: return "ATOMIC_NAND_16"; + case OpCode::ATOMIC_NAND_32: return "ATOMIC_NAND_32"; + case OpCode::ATOMIC_NAND_64: return "ATOMIC_NAND_64"; + case OpCode::ATOMIC_EXCHANGE_8: return "ATOMIC_EXCHANGE_8"; + case OpCode::ATOMIC_EXCHANGE_16: return "ATOMIC_EXCHANGE_16"; + case OpCode::ATOMIC_EXCHANGE_32: return "ATOMIC_EXCHANGE_32"; + case OpCode::ATOMIC_EXCHANGE_64: return "ATOMIC_EXCHANGE_64"; + case OpCode::ADD_OVERFLOW_8: return "ADD_OVERFLOW_8"; + case OpCode::ADD_OVERFLOW_16: return "ADD_OVERFLOW_16"; + case OpCode::ADD_OVERFLOW_32: return "ADD_OVERFLOW_32"; + case OpCode::ADD_OVERFLOW_64: return "ADD_OVERFLOW_64"; + case OpCode::SUB_OVERFLOW_8: return "SUB_OVERFLOW_8"; + case OpCode::SUB_OVERFLOW_16: return "SUB_OVERFLOW_16"; + case OpCode::SUB_OVERFLOW_32: return "SUB_OVERFLOW_32"; + case OpCode::SUB_OVERFLOW_64: return "SUB_OVERFLOW_64"; + case OpCode::MUL_OVERFLOW_8: return "MUL_OVERFLOW_8"; + case OpCode::MUL_OVERFLOW_16: return "MUL_OVERFLOW_16"; + case OpCode::MUL_OVERFLOW_32: return "MUL_OVERFLOW_32"; + case OpCode::MUL_OVERFLOW_64: return "MUL_OVERFLOW_64"; + case OpCode::LAST_VALUE: return "LAST_VALUE"; + case OpCode::UNKNOWN: return "UNKNOWN"; + case OpCode::FCMP_EQ_32: return "FCMP_EQ_32"; + case OpCode::FCMP_EQ_64: return "FCMP_EQ_64"; + case OpCode::FCMP_NE_32: return "FCMP_NE_32"; + case OpCode::FCMP_NE_64: return "FCMP_NE_64"; + case OpCode::FCMP_LT_32: return "FCMP_LT_32"; + case OpCode::FCMP_LT_64: return "FCMP_LT_64"; + case OpCode::FCMP_LE_32: return "FCMP_LE_32"; + case OpCode::FCMP_LE_64: return "FCMP_LE_64"; + case OpCode::FCMP_GT_32: return "FCMP_GT_32"; + case OpCode::FCMP_GT_64: return "FCMP_GT_64"; + case OpCode::FCMP_GE_32: return "FCMP_GE_32"; + case OpCode::FCMP_GE_64: return "FCMP_GE_64"; + case OpCode::FADD_32: return "FADD_32"; + case OpCode::FADD_64: return "FADD_64"; + case OpCode::FSUB_32: return "FSUB_32"; + case OpCode::FSUB_64: return "FSUB_64"; + case OpCode::FMUL_32: return "FMUL_32"; + case OpCode::FMUL_64: return "FMUL_64"; + case OpCode::FDIV_32: return "FDIV_32"; + case OpCode::FDIV_64: return "FDIV_64"; + case OpCode::FREM_32: return "FREM_32"; + case OpCode::FREM_64: return "FREM_64"; + case OpCode::FNEG_32: return "FNEG_32"; + case OpCode::FNEG_64: return "FNEG_64"; + case OpCode::ADD_8: return "ADD_8"; + case OpCode::ADD_16: return "ADD_16"; + case OpCode::ADD_32: return "ADD_32"; + case OpCode::ADD_64: return "ADD_64"; + case OpCode::SUB_8: return "SUB_8"; + case OpCode::SUB_16: return "SUB_16"; + case OpCode::SUB_32: return "SUB_32"; + case OpCode::SUB_64: return "SUB_64"; + case OpCode::MUL_8: return "MUL_8"; + case OpCode::MUL_16: return "MUL_16"; + case OpCode::MUL_32: return "MUL_32"; + case OpCode::MUL_64: return "MUL_64"; + case OpCode::DIV_8: return "DIV_8"; + case OpCode::DIV_16: return "DIV_16"; + case OpCode::DIV_32: return "DIV_32"; + case OpCode::DIV_64: return "DIV_64"; + case OpCode::REM_8: return "REM_8"; + case OpCode::REM_16: return "REM_16"; + case OpCode::REM_32: return "REM_32"; + case OpCode::REM_64: return "REM_64"; + case OpCode::UDIV_8: return "UDIV_8"; + case OpCode::UDIV_16: return "UDIV_16"; + case OpCode::UDIV_32: return "UDIV_32"; + case OpCode::UDIV_64: return "UDIV_64"; + case OpCode::UREM_8: return "UREM_8"; + case OpCode::UREM_16: return "UREM_16"; + case OpCode::UREM_32: return "UREM_32"; + case OpCode::UREM_64: return "UREM_64"; + case OpCode::USHR_8: return "USHR_8"; + case OpCode::USHR_16: return "USHR_16"; + case OpCode::USHR_32: return "USHR_32"; + case OpCode::USHR_64: return "USHR_64"; + case OpCode::BIT_AND_8: return "BIT_AND_8"; + case OpCode::BIT_AND_16: return "BIT_AND_16"; + case OpCode::BIT_AND_32: return "BIT_AND_32"; + case OpCode::BIT_AND_64: return "BIT_AND_64"; + case OpCode::BIT_OR_8: return "BIT_OR_8"; + case OpCode::BIT_OR_16: return "BIT_OR_16"; + case OpCode::BIT_OR_32: return "BIT_OR_32"; + case OpCode::BIT_OR_64: return "BIT_OR_64"; + case OpCode::BIT_XOR_8: return "BIT_XOR_8"; + case OpCode::BIT_XOR_16: return "BIT_XOR_16"; + case OpCode::BIT_XOR_32: return "BIT_XOR_32"; + case OpCode::BIT_XOR_64: return "BIT_XOR_64"; + case OpCode::SHL_8: return "SHL_8"; + case OpCode::SHL_16: return "SHL_16"; + case OpCode::SHL_32: return "SHL_32"; + case OpCode::SHL_64: return "SHL_64"; + case OpCode::SHR_8: return "SHR_8"; + case OpCode::SHR_16: return "SHR_16"; + case OpCode::SHR_32: return "SHR_32"; + case OpCode::SHR_64: return "SHR_64"; + case OpCode::CMP_EQ_8: return "CMP_EQ_8"; + case OpCode::CMP_EQ_16: return "CMP_EQ_16"; + case OpCode::CMP_EQ_32: return "CMP_EQ_32"; + case OpCode::CMP_EQ_64: return "CMP_EQ_64"; + case OpCode::CMP_NE_8: return "CMP_NE_8"; + case OpCode::CMP_NE_16: return "CMP_NE_16"; + case OpCode::CMP_NE_32: return "CMP_NE_32"; + case OpCode::CMP_NE_64: return "CMP_NE_64"; + case OpCode::CMP_LT_8: return "CMP_LT_8"; + case OpCode::CMP_LT_16: return "CMP_LT_16"; + case OpCode::CMP_LT_32: return "CMP_LT_32"; + case OpCode::CMP_LT_64: return "CMP_LT_64"; + case OpCode::CMP_LE_8: return "CMP_LE_8"; + case OpCode::CMP_LE_16: return "CMP_LE_16"; + case OpCode::CMP_LE_32: return "CMP_LE_32"; + case OpCode::CMP_LE_64: return "CMP_LE_64"; + case OpCode::CMP_GT_8: return "CMP_GT_8"; + case OpCode::CMP_GT_16: return "CMP_GT_16"; + case OpCode::CMP_GT_32: return "CMP_GT_32"; + case OpCode::CMP_GT_64: return "CMP_GT_64"; + case OpCode::CMP_GE_8: return "CMP_GE_8"; + case OpCode::CMP_GE_16: return "CMP_GE_16"; + case OpCode::CMP_GE_32: return "CMP_GE_32"; + case OpCode::CMP_GE_64: return "CMP_GE_64"; + case OpCode::UCMP_LT_8: return "UCMP_LT_8"; + case OpCode::UCMP_LT_16: return "UCMP_LT_16"; + case OpCode::UCMP_LT_32: return "UCMP_LT_32"; + case OpCode::UCMP_LT_64: return "UCMP_LT_64"; + case OpCode::UCMP_LE_8: return "UCMP_LE_8"; + case OpCode::UCMP_LE_16: return "UCMP_LE_16"; + case OpCode::UCMP_LE_32: return "UCMP_LE_32"; + case OpCode::UCMP_LE_64: return "UCMP_LE_64"; + case OpCode::UCMP_GT_8: return "UCMP_GT_8"; + case OpCode::UCMP_GT_16: return "UCMP_GT_16"; + case OpCode::UCMP_GT_32: return "UCMP_GT_32"; + case OpCode::UCMP_GT_64: return "UCMP_GT_64"; + case OpCode::UCMP_GE_8: return "UCMP_GE_8"; + case OpCode::UCMP_GE_16: return "UCMP_GE_16"; + case OpCode::UCMP_GE_32: return "UCMP_GE_32"; + case OpCode::UCMP_GE_64: return "UCMP_GE_64"; + case OpCode::NEG_8: return "NEG_8"; + case OpCode::NEG_16: return "NEG_16"; + case OpCode::NEG_32: return "NEG_32"; + case OpCode::NEG_64: return "NEG_64"; + case OpCode::BIT_NOT_8: return "BIT_NOT_8"; + case OpCode::BIT_NOT_16: return "BIT_NOT_16"; + case OpCode::BIT_NOT_32: return "BIT_NOT_32"; + case OpCode::BIT_NOT_64: return "BIT_NOT_64"; + case OpCode::PTR_ADD_32: return "PTR_ADD_32"; + case OpCode::PTR_ADD_64: return "PTR_ADD_64"; + case OpCode::GEP_FIELD_32: return "GEP_FIELD_32"; + case OpCode::GEP_FIELD_64: return "GEP_FIELD_64"; + case OpCode::GLOBAL_PTR_32: return "GLOBAL_PTR_32"; + case OpCode::GLOBAL_PTR_64: return "GLOBAL_PTR_64"; + case OpCode::THREAD_LOCAL_PTR_32: return "THREAD_LOCAL_PTR_32"; + case OpCode::THREAD_LOCAL_PTR_64: return "THREAD_LOCAL_PTR_64"; + case OpCode::FUNC_PTR_32: return "FUNC_PTR_32"; + case OpCode::FUNC_PTR_64: return "FUNC_PTR_64"; + case OpCode::STRING_PTR_32: return "STRING_PTR_32"; + case OpCode::STRING_PTR_64: return "STRING_PTR_64"; + case OpCode::PARAM_PTR_32: return "PARAM_PTR_32"; + case OpCode::PARAM_PTR_64: return "PARAM_PTR_64"; + case OpCode::FRAME_PTR_32: return "FRAME_PTR_32"; + case OpCode::FRAME_PTR_64: return "FRAME_PTR_64"; + case OpCode::RETURN_PTR_32: return "RETURN_PTR_32"; + case OpCode::RETURN_PTR_64: return "RETURN_PTR_64"; + case OpCode::RETURN_ADDRESS_32: return "RETURN_ADDRESS_32"; + case OpCode::RETURN_ADDRESS_64: return "RETURN_ADDRESS_64"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(ConstOp op) noexcept { + switch (op) { + case ConstOp::INT8: return "INT8"; + case ConstOp::INT16: return "INT16"; + case ConstOp::INT32: return "INT32"; + case ConstOp::INT64: return "INT64"; + case ConstOp::UINT8: return "UINT8"; + case ConstOp::UINT16: return "UINT16"; + case ConstOp::UINT32: return "UINT32"; + case ConstOp::UINT64: return "UINT64"; + case ConstOp::FLOAT32: return "FLOAT32"; + case ConstOp::FLOAT64: return "FLOAT64"; + case ConstOp::FLOAT16: return "FLOAT16"; + case ConstOp::NULL_PTR: return "NULL_PTR"; + case ConstOp::INF32: return "INF32"; + case ConstOp::INF64: return "INF64"; + case ConstOp::NAN32: return "NAN32"; + case ConstOp::NAN64: return "NAN64"; + case ConstOp::WCHAR16: return "WCHAR16"; + case ConstOp::WCHAR32: return "WCHAR32"; + case ConstOp::BOOL: return "BOOL"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(AllocaKind op) noexcept { + switch (op) { + case AllocaKind::LOCAL: return "LOCAL"; + case AllocaKind::ARG: return "ARG"; + case AllocaKind::RETURN: return "RETURN"; + case AllocaKind::DYNAMIC: return "DYNAMIC"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(CastOp op) noexcept { + switch (op) { + case CastOp::SEXT_I8_I16: return "SEXT_I8_I16"; + case CastOp::SEXT_I8_I32: return "SEXT_I8_I32"; + case CastOp::SEXT_I8_I64: return "SEXT_I8_I64"; + case CastOp::SEXT_I16_I32: return "SEXT_I16_I32"; + case CastOp::SEXT_I16_I64: return "SEXT_I16_I64"; + case CastOp::SEXT_I32_I64: return "SEXT_I32_I64"; + case CastOp::ZEXT_I8_I16: return "ZEXT_I8_I16"; + case CastOp::ZEXT_I8_I32: return "ZEXT_I8_I32"; + case CastOp::ZEXT_I8_I64: return "ZEXT_I8_I64"; + case CastOp::ZEXT_I16_I32: return "ZEXT_I16_I32"; + case CastOp::ZEXT_I16_I64: return "ZEXT_I16_I64"; + case CastOp::ZEXT_I32_I64: return "ZEXT_I32_I64"; + case CastOp::TRUNC_I16_I8: return "TRUNC_I16_I8"; + case CastOp::TRUNC_I32_I8: return "TRUNC_I32_I8"; + case CastOp::TRUNC_I64_I8: return "TRUNC_I64_I8"; + case CastOp::TRUNC_I32_I16: return "TRUNC_I32_I16"; + case CastOp::TRUNC_I64_I16: return "TRUNC_I64_I16"; + case CastOp::TRUNC_I64_I32: return "TRUNC_I64_I32"; + case CastOp::F32_TO_F64: return "F32_TO_F64"; + case CastOp::F64_TO_F32: return "F64_TO_F32"; + case CastOp::SI8_TO_F32: return "SI8_TO_F32"; + case CastOp::SI8_TO_F64: return "SI8_TO_F64"; + case CastOp::SI16_TO_F32: return "SI16_TO_F32"; + case CastOp::SI16_TO_F64: return "SI16_TO_F64"; + case CastOp::SI32_TO_F32: return "SI32_TO_F32"; + case CastOp::SI32_TO_F64: return "SI32_TO_F64"; + case CastOp::SI64_TO_F32: return "SI64_TO_F32"; + case CastOp::SI64_TO_F64: return "SI64_TO_F64"; + case CastOp::UI8_TO_F32: return "UI8_TO_F32"; + case CastOp::UI8_TO_F64: return "UI8_TO_F64"; + case CastOp::UI16_TO_F32: return "UI16_TO_F32"; + case CastOp::UI16_TO_F64: return "UI16_TO_F64"; + case CastOp::UI32_TO_F32: return "UI32_TO_F32"; + case CastOp::UI32_TO_F64: return "UI32_TO_F64"; + case CastOp::UI64_TO_F32: return "UI64_TO_F32"; + case CastOp::UI64_TO_F64: return "UI64_TO_F64"; + case CastOp::F32_TO_SI8: return "F32_TO_SI8"; + case CastOp::F32_TO_SI16: return "F32_TO_SI16"; + case CastOp::F32_TO_SI32: return "F32_TO_SI32"; + case CastOp::F32_TO_SI64: return "F32_TO_SI64"; + case CastOp::F64_TO_SI8: return "F64_TO_SI8"; + case CastOp::F64_TO_SI16: return "F64_TO_SI16"; + case CastOp::F64_TO_SI32: return "F64_TO_SI32"; + case CastOp::F64_TO_SI64: return "F64_TO_SI64"; + case CastOp::F32_TO_UI8: return "F32_TO_UI8"; + case CastOp::F32_TO_UI16: return "F32_TO_UI16"; + case CastOp::F32_TO_UI32: return "F32_TO_UI32"; + case CastOp::F32_TO_UI64: return "F32_TO_UI64"; + case CastOp::F64_TO_UI8: return "F64_TO_UI8"; + case CastOp::F64_TO_UI16: return "F64_TO_UI16"; + case CastOp::F64_TO_UI32: return "F64_TO_UI32"; + case CastOp::F64_TO_UI64: return "F64_TO_UI64"; + case CastOp::PTR_TO_I32: return "PTR_TO_I32"; + case CastOp::PTR_TO_I64: return "PTR_TO_I64"; + case CastOp::I32_TO_PTR: return "I32_TO_PTR"; + case CastOp::I64_TO_PTR: return "I64_TO_PTR"; + case CastOp::BITCAST: return "BITCAST"; + case CastOp::IDENTITY: return "IDENTITY"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(MemOp op) noexcept { + switch (op) { + case MemOp::LOAD_LE_8: return "LOAD_LE_8"; + case MemOp::LOAD_LE_16: return "LOAD_LE_16"; + case MemOp::LOAD_LE_32: return "LOAD_LE_32"; + case MemOp::LOAD_LE_64: return "LOAD_LE_64"; + case MemOp::LOAD_BE_8: return "LOAD_BE_8"; + case MemOp::LOAD_BE_16: return "LOAD_BE_16"; + case MemOp::LOAD_BE_32: return "LOAD_BE_32"; + case MemOp::LOAD_BE_64: return "LOAD_BE_64"; + case MemOp::STORE_LE_8: return "STORE_LE_8"; + case MemOp::STORE_LE_16: return "STORE_LE_16"; + case MemOp::STORE_LE_32: return "STORE_LE_32"; + case MemOp::STORE_LE_64: return "STORE_LE_64"; + case MemOp::STORE_BE_8: return "STORE_BE_8"; + case MemOp::STORE_BE_16: return "STORE_BE_16"; + case MemOp::STORE_BE_32: return "STORE_BE_32"; + case MemOp::STORE_BE_64: return "STORE_BE_64"; + case MemOp::ATOMIC_LOAD_LE_8: return "ATOMIC_LOAD_LE_8"; + case MemOp::ATOMIC_LOAD_LE_16: return "ATOMIC_LOAD_LE_16"; + case MemOp::ATOMIC_LOAD_LE_32: return "ATOMIC_LOAD_LE_32"; + case MemOp::ATOMIC_LOAD_LE_64: return "ATOMIC_LOAD_LE_64"; + case MemOp::ATOMIC_LOAD_BE_8: return "ATOMIC_LOAD_BE_8"; + case MemOp::ATOMIC_LOAD_BE_16: return "ATOMIC_LOAD_BE_16"; + case MemOp::ATOMIC_LOAD_BE_32: return "ATOMIC_LOAD_BE_32"; + case MemOp::ATOMIC_LOAD_BE_64: return "ATOMIC_LOAD_BE_64"; + case MemOp::ATOMIC_STORE_LE_8: return "ATOMIC_STORE_LE_8"; + case MemOp::ATOMIC_STORE_LE_16: return "ATOMIC_STORE_LE_16"; + case MemOp::ATOMIC_STORE_LE_32: return "ATOMIC_STORE_LE_32"; + case MemOp::ATOMIC_STORE_LE_64: return "ATOMIC_STORE_LE_64"; + case MemOp::ATOMIC_STORE_BE_8: return "ATOMIC_STORE_BE_8"; + case MemOp::ATOMIC_STORE_BE_16: return "ATOMIC_STORE_BE_16"; + case MemOp::ATOMIC_STORE_BE_32: return "ATOMIC_STORE_BE_32"; + case MemOp::ATOMIC_STORE_BE_64: return "ATOMIC_STORE_BE_64"; + case MemOp::MEMSET: return "MEMSET"; + case MemOp::MEMCPY: return "MEMCPY"; + case MemOp::MEMMOVE: return "MEMMOVE"; + case MemOp::MEMCMP: return "MEMCMP"; + case MemOp::MEMCHR: return "MEMCHR"; + case MemOp::BZERO: return "BZERO"; + case MemOp::STRLEN: return "STRLEN"; + case MemOp::STRNLEN: return "STRNLEN"; + case MemOp::STRCMP: return "STRCMP"; + case MemOp::STRNCMP: return "STRNCMP"; + case MemOp::STRCHR: return "STRCHR"; + case MemOp::STRRCHR: return "STRRCHR"; + case MemOp::STRSTR: return "STRSTR"; + case MemOp::STRCPY: return "STRCPY"; + case MemOp::STRNCPY: return "STRNCPY"; + case MemOp::STRCAT: return "STRCAT"; + case MemOp::STRNCAT: return "STRNCAT"; + case MemOp::STPCPY: return "STPCPY"; + case MemOp::STPNCPY: return "STPNCPY"; + case MemOp::STRTOI32: return "STRTOI32"; + case MemOp::STRTOI64: return "STRTOI64"; + case MemOp::STRTOU32: return "STRTOU32"; + case MemOp::STRTOU64: return "STRTOU64"; + case MemOp::STRTOF32: return "STRTOF32"; + case MemOp::STRTOF64: return "STRTOF64"; + case MemOp::BIT_READ_LE: return "BIT_READ_LE"; + case MemOp::BIT_WRITE_LE: return "BIT_WRITE_LE"; + case MemOp::BIT_READ_BE: return "BIT_READ_BE"; + case MemOp::BIT_WRITE_BE: return "BIT_WRITE_BE"; + case MemOp::CMPXCHG_LE_8: return "CMPXCHG_LE_8"; + case MemOp::CMPXCHG_LE_16: return "CMPXCHG_LE_16"; + case MemOp::CMPXCHG_LE_32: return "CMPXCHG_LE_32"; + case MemOp::CMPXCHG_LE_64: return "CMPXCHG_LE_64"; + case MemOp::CMPXCHG_BE_8: return "CMPXCHG_BE_8"; + case MemOp::CMPXCHG_BE_16: return "CMPXCHG_BE_16"; + case MemOp::CMPXCHG_BE_32: return "CMPXCHG_BE_32"; + case MemOp::CMPXCHG_BE_64: return "CMPXCHG_BE_64"; + case MemOp::CONSUME_VA_PARAM: return "CONSUME_VA_PARAM"; + case MemOp::LOAD_F32_LE: return "LOAD_F32_LE"; + case MemOp::LOAD_F64_LE: return "LOAD_F64_LE"; + case MemOp::LOAD_F32_BE: return "LOAD_F32_BE"; + case MemOp::LOAD_F64_BE: return "LOAD_F64_BE"; + case MemOp::STORE_F32_LE: return "STORE_F32_LE"; + case MemOp::STORE_F64_LE: return "STORE_F64_LE"; + case MemOp::STORE_F32_BE: return "STORE_F32_BE"; + case MemOp::STORE_F64_BE: return "STORE_F64_BE"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(BitwiseOp op) noexcept { + switch (op) { + case BitwiseOp::BSWAP_16: return "BSWAP_16"; + case BitwiseOp::BSWAP_32: return "BSWAP_32"; + case BitwiseOp::BSWAP_64: return "BSWAP_64"; + case BitwiseOp::POPCOUNT: return "POPCOUNT"; + case BitwiseOp::CLZ: return "CLZ"; + case BitwiseOp::CTZ: return "CTZ"; + case BitwiseOp::FFS: return "FFS"; + case BitwiseOp::PARITY: return "PARITY"; + case BitwiseOp::ROTL: return "ROTL"; + case BitwiseOp::ROTR: return "ROTR"; + // (ABS moved to sized opcode) + } + return "UNKNOWN"; +} + +const char *EnumeratorName(FloatOp op) noexcept { + switch (op) { + case FloatOp::ISNAN_32: return "ISNAN_32"; + case FloatOp::ISNAN_64: return "ISNAN_64"; + case FloatOp::ISINF_32: return "ISINF_32"; + case FloatOp::ISINF_64: return "ISINF_64"; + case FloatOp::ISFINITE_32: return "ISFINITE_32"; + case FloatOp::ISFINITE_64: return "ISFINITE_64"; + case FloatOp::FABS_32: return "FABS_32"; + case FloatOp::FABS_64: return "FABS_64"; + case FloatOp::COPYSIGN_32: return "COPYSIGN_32"; + case FloatOp::COPYSIGN_64: return "COPYSIGN_64"; + case FloatOp::FMIN_32: return "FMIN_32"; + case FloatOp::FMIN_64: return "FMIN_64"; + case FloatOp::FMAX_32: return "FMAX_32"; + case FloatOp::FMAX_64: return "FMAX_64"; + case FloatOp::CEIL_32: return "CEIL_32"; + case FloatOp::CEIL_64: return "CEIL_64"; + case FloatOp::FLOOR_32: return "FLOOR_32"; + case FloatOp::FLOOR_64: return "FLOOR_64"; + case FloatOp::ROUND_32: return "ROUND_32"; + case FloatOp::ROUND_64: return "ROUND_64"; + case FloatOp::TRUNC_32: return "TRUNC_32"; + case FloatOp::TRUNC_64: return "TRUNC_64"; + case FloatOp::SQRT_32: return "SQRT_32"; + case FloatOp::SQRT_64: return "SQRT_64"; + case FloatOp::INF_32: return "INF_32"; + case FloatOp::INF_64: return "INF_64"; + case FloatOp::NAN_32: return "NAN_32"; + case FloatOp::NAN_64: return "NAN_64"; + case FloatOp::HUGE_32: return "HUGE_32"; + case FloatOp::HUGE_64: return "HUGE_64"; + case FloatOp::SIN_32: return "SIN_32"; + case FloatOp::SIN_64: return "SIN_64"; + case FloatOp::COS_32: return "COS_32"; + case FloatOp::COS_64: return "COS_64"; + case FloatOp::TAN_32: return "TAN_32"; + case FloatOp::TAN_64: return "TAN_64"; + case FloatOp::ASIN_32: return "ASIN_32"; + case FloatOp::ASIN_64: return "ASIN_64"; + case FloatOp::ACOS_32: return "ACOS_32"; + case FloatOp::ACOS_64: return "ACOS_64"; + case FloatOp::ATAN_32: return "ATAN_32"; + case FloatOp::ATAN_64: return "ATAN_64"; + case FloatOp::ATAN2_32: return "ATAN2_32"; + case FloatOp::ATAN2_64: return "ATAN2_64"; + case FloatOp::EXP_32: return "EXP_32"; + case FloatOp::EXP_64: return "EXP_64"; + case FloatOp::EXP2_32: return "EXP2_32"; + case FloatOp::EXP2_64: return "EXP2_64"; + case FloatOp::LOG_32: return "LOG_32"; + case FloatOp::LOG_64: return "LOG_64"; + case FloatOp::LOG2_32: return "LOG2_32"; + case FloatOp::LOG2_64: return "LOG2_64"; + case FloatOp::LOG10_32: return "LOG10_32"; + case FloatOp::LOG10_64: return "LOG10_64"; + case FloatOp::POW_32: return "POW_32"; + case FloatOp::POW_64: return "POW_64"; + case FloatOp::FMOD_32: return "FMOD_32"; + case FloatOp::FMOD_64: return "FMOD_64"; + case FloatOp::REMAINDER_32: return "REMAINDER_32"; + case FloatOp::REMAINDER_64: return "REMAINDER_64"; + case FloatOp::FMA_32: return "FMA_32"; + case FloatOp::FMA_64: return "FMA_64"; + case FloatOp::SINH_32: return "SINH_32"; + case FloatOp::SINH_64: return "SINH_64"; + case FloatOp::COSH_32: return "COSH_32"; + case FloatOp::COSH_64: return "COSH_64"; + case FloatOp::TANH_32: return "TANH_32"; + case FloatOp::TANH_64: return "TANH_64"; + case FloatOp::HYPOT_32: return "HYPOT_32"; + case FloatOp::HYPOT_64: return "HYPOT_64"; + case FloatOp::ERF_32: return "ERF_32"; + case FloatOp::ERF_64: return "ERF_64"; + case FloatOp::ERFC_32: return "ERFC_32"; + case FloatOp::ERFC_64: return "ERFC_64"; + case FloatOp::TGAMMA_32: return "TGAMMA_32"; + case FloatOp::TGAMMA_64: return "TGAMMA_64"; + case FloatOp::LGAMMA_32: return "LGAMMA_32"; + case FloatOp::LGAMMA_64: return "LGAMMA_64"; + case FloatOp::FDIM_32: return "FDIM_32"; + case FloatOp::FDIM_64: return "FDIM_64"; + case FloatOp::SIGNBIT_32: return "SIGNBIT_32"; + case FloatOp::SIGNBIT_64: return "SIGNBIT_64"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(FunctionKind kind) noexcept { + switch (kind) { + case FunctionKind::NORMAL: return "NORMAL"; + case FunctionKind::GLOBAL_INITIALIZER: return "GLOBAL_INITIALIZER"; + case FunctionKind::THREAD_LOCAL_INITIALIZER: return "THREAD_LOCAL_INITIALIZER"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(ObjectKind kind) noexcept { + switch (kind) { + case ObjectKind::LOCAL: return "LOCAL"; + case ObjectKind::LOCAL_VALUE: return "LOCAL_VALUE"; + case ObjectKind::PARAMETER: return "PARAMETER"; + case ObjectKind::PARAMETER_VALUE: return "PARAMETER_VALUE"; + case ObjectKind::GLOBAL: return "GLOBAL"; + case ObjectKind::THREAD_LOCAL: return "THREAD_LOCAL"; + case ObjectKind::STRING_LITERAL: return "STRING_LITERAL"; + case ObjectKind::COMPOUND_LITERAL: return "COMPOUND_LITERAL"; + case ObjectKind::RETURN_SLOT: return "RETURN_SLOT"; + case ObjectKind::ALLOCA: return "ALLOCA"; + case ObjectKind::HEAP: return "HEAP"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(StructureKind kind) noexcept { + switch (kind) { + case StructureKind::FUNCTION_SCOPE: return "FUNCTION_SCOPE"; + case StructureKind::SCOPE: return "SCOPE"; + case StructureKind::IF: return "IF"; + case StructureKind::IF_THEN: return "IF_THEN"; + case StructureKind::IF_ELSE: return "IF_ELSE"; + case StructureKind::FOR: return "FOR"; + case StructureKind::FOR_INIT: return "FOR_INIT"; + case StructureKind::FOR_CONDITION: return "FOR_CONDITION"; + case StructureKind::FOR_BODY: return "FOR_BODY"; + case StructureKind::FOR_INCREMENT: return "FOR_INCREMENT"; + case StructureKind::WHILE: return "WHILE"; + case StructureKind::WHILE_CONDITION: return "WHILE_CONDITION"; + case StructureKind::WHILE_BODY: return "WHILE_BODY"; + case StructureKind::DO_WHILE: return "DO_WHILE"; + case StructureKind::DO_WHILE_BODY: return "DO_WHILE_BODY"; + case StructureKind::DO_WHILE_CONDITION: return "DO_WHILE_CONDITION"; + case StructureKind::SWITCH: return "SWITCH"; + case StructureKind::SWITCH_CASE: return "SWITCH_CASE"; + case StructureKind::EXPRESSION_SCOPE: return "EXPRESSION_SCOPE"; + } + return "UNKNOWN"; +} + +const char *EnumeratorName(BlockKind kind) noexcept { + switch (kind) { + case BlockKind::ENTRY: return "ENTRY"; + case BlockKind::IF_THEN: return "IF_THEN"; + case BlockKind::IF_ELSE: return "IF_ELSE"; + case BlockKind::IF_MERGE: return "IF_MERGE"; + case BlockKind::LOOP_CONDITION: return "LOOP_CONDITION"; + case BlockKind::LOOP_BODY: return "LOOP_BODY"; + case BlockKind::LOOP_EXIT: return "LOOP_EXIT"; + case BlockKind::LOOP_INCREMENT: return "LOOP_INCREMENT"; + case BlockKind::SWITCH_CASE: return "SWITCH_CASE"; + case BlockKind::SWITCH_DEFAULT: return "SWITCH_DEFAULT"; + case BlockKind::SWITCH_EXIT: return "SWITCH_EXIT"; + case BlockKind::LABEL: return "LABEL"; + case BlockKind::UNREACHABLE: return "UNREACHABLE"; + case BlockKind::GENERIC: return "GENERIC"; + case BlockKind::FRAME: return "FRAME"; + case BlockKind::COMPENSATION: return "COMPENSATION"; + case BlockKind::LOOP_PREHEADER: return "LOOP_PREHEADER"; + } + return "UNKNOWN"; +} + +} // namespace mx::ir + +namespace mx { + +const char *EnumeratorName(IREntityKind kind) noexcept { + switch (kind) { + case IREntityKind::IR_FUNCTION: return "IR_FUNCTION"; + case IREntityKind::IR_BLOCK: return "IR_BLOCK"; + case IREntityKind::IR_INSTRUCTION: return "IR_INSTRUCTION"; + case IREntityKind::IR_OBJECT: return "IR_OBJECT"; + case IREntityKind::IR_STRUCTURE: return "IR_STRUCTURE"; + } + return "UNKNOWN"; +} + +} // namespace mx diff --git a/lib/IR/Function.cpp b/lib/IR/Function.cpp new file mode 100644 index 000000000..83ed4f7af --- /dev/null +++ b/lib/IR/Function.cpp @@ -0,0 +1,185 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Impl.h" +#include "../Fragment.h" +#include "../EntityProvider.h" + +namespace mx { + +EntityId IRFunction::id(void) const { + if (!impl) return {}; + IRFunctionId fid; + fid.fragment_id = impl->fragment_id; + fid.offset = impl->offset; + return EntityId(fid); +} + +IRBlock IRFunction::entry_block(void) const { + if (!impl) return {}; + auto eid = impl->reader().getEntryBlockId(); + auto vid = EntityId(eid).Unpack(); + if (auto *bid = std::get_if(&vid)) { + return IRBlock(std::make_shared( + impl->frag, bid->offset, impl->fragment_id)); + } + return {}; +} + +gap::generator IRFunction::blocks(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = impl->frag->reader.getIrEntityPool(); + uint32_t base = r.getEntityOffset(); + uint16_t n = r.getNumBlocks(); + for (uint16_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *bid = std::get_if(&vid)) { + co_yield IRBlock(std::make_shared( + impl->frag, bid->offset, impl->fragment_id)); + } + } +} + +gap::generator IRFunction::objects(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = impl->frag->reader.getIrEntityPool(); + uint32_t base = r.getEntityOffset() + r.getNumBlocks(); + uint16_t n = r.getNumObjects(); + for (uint16_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *oid = std::get_if(&vid)) { + co_yield IRObject(std::make_shared( + impl->frag, oid->offset, impl->fragment_id)); + } + } +} + +ir::FunctionKind IRFunction::kind(void) const { + if (!impl) return ir::FunctionKind::NORMAL; + return static_cast(impl->reader().getKind()); +} + +std::optional IRFunction::declaration(void) const { + if (!impl) return std::nullopt; + if (kind() != ir::FunctionKind::NORMAL) return std::nullopt; + auto eid = impl->reader().getSourceDeclEntityId(); + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl->frag->ep->DeclFor(impl->frag->ep, eid)) { + return FunctionDecl::from(Decl(std::move(ptr))); + } + return std::nullopt; +} + +std::optional IRFunction::source_declaration(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getSourceDeclEntityId(); + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl->frag->ep->DeclFor(impl->frag->ep, eid)) { + return Decl(std::move(ptr)); + } + return std::nullopt; +} + +std::optional IRFunction::body_scope(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getBodyScopeId(); + if (eid == kInvalidEntityId) return std::nullopt; + auto vid = EntityId(eid).Unpack(); + if (auto *sid = std::get_if(&vid)) { + return IRStructure(std::make_shared( + impl->frag, sid->offset, impl->fragment_id)); + } + return std::nullopt; +} + +std::optional IRFunction::from(const FunctionDecl &decl) { + // Try this specific declaration first. + auto try_decl = [](const FunctionDecl &d) -> std::optional { + auto frag = Fragment::containing(d); + if (!frag.impl) return std::nullopt; + + auto decl_eid = d.id().Pack(); + auto ir_funcs = frag.impl->reader.getIrFunctions(); + auto frag_id = frag.impl->fragment_id; + + for (unsigned i = 0; i < ir_funcs.size(); ++i) { + if (ir_funcs[i].getSourceDeclEntityId() == decl_eid) { + return IRFunction(std::make_shared( + frag.impl, i, frag_id)); + } + } + return std::nullopt; + }; + + if (auto ir = try_decl(decl)) return ir; + + // If this declaration has no IR, try the definition. + // IR is generated from the definition, so a forward declaration + // won't have IR mapped directly. + if (!decl.is_definition()) { + for (auto redecl : decl.redeclarations()) { + if (auto fd = FunctionDecl::from(redecl)) { + if (fd->is_definition()) { + if (auto ir = try_decl(*fd)) return ir; + } + } + } + } + + return std::nullopt; +} + +std::optional IRFunction::containing(const Decl &decl) { + // If this IS a FunctionDecl, use from() directly. + if (auto fd = FunctionDecl::from(decl)) { + return from(*fd); + } + + // Walk up the parent chain: Decl → parent Decl or parent Stmt. + // A local variable's parent is the DeclStmt, whose parent is the + // CompoundStmt, whose parent is the FunctionDecl's body, etc. + if (auto parent_decl = decl.parent_declaration()) { + return containing(*parent_decl); + } + if (auto parent_stmt = decl.parent_statement()) { + return containing(*parent_stmt); + } + return std::nullopt; +} + +std::optional IRFunction::containing(const Stmt &stmt) { + // Walk up: Stmt → parent Stmt or parent Decl. + if (auto parent_decl = stmt.parent_declaration()) { + return containing(*parent_decl); + } + if (auto parent_stmt = stmt.parent_statement()) { + return containing(*parent_stmt); + } + return std::nullopt; +} + +std::optional IRFunction::containing(const IRBlock &block) { + return block.parent_function(); +} + +std::optional IRFunction::containing(const IRInstruction &inst) { + return containing(inst.parent_block()); +} + +} // namespace mx diff --git a/lib/IR/Impl.cpp b/lib/IR/Impl.cpp new file mode 100644 index 000000000..2db06cd88 --- /dev/null +++ b/lib/IR/Impl.cpp @@ -0,0 +1,31 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include "Impl.h" +#include "../Fragment.h" + +namespace mx { + +rpc::ir::Function::Reader IRFunctionImpl::reader() const { + return frag->reader.getIrFunctions()[offset]; +} + +rpc::ir::Block::Reader IRBlockImpl::reader() const { + return frag->reader.getIrBlocks()[offset]; +} + +rpc::ir::Instruction::Reader IRInstructionImpl::reader() const { + return frag->reader.getIrInstructions()[offset]; +} + +rpc::ir::Object::Reader IRObjectImpl::reader() const { + return frag->reader.getIrObjects()[offset]; +} + +rpc::ir::Structure::Reader IRStructureImpl::reader() const { + return frag->reader.getIrStructures()[offset]; +} + +} // namespace mx diff --git a/lib/IR/Impl.h b/lib/IR/Impl.h new file mode 100644 index 000000000..68ef13b2c --- /dev/null +++ b/lib/IR/Impl.h @@ -0,0 +1,98 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#pragma once + +#include +#include +#include +#include + +namespace mx { + +class FragmentImpl; +class EntityProvider; +using FragmentImplPtr = std::shared_ptr; + +// All IR entity impls hold a reference to the containing fragment +// (keeps capnp data alive) plus the offset into the fragment's flat list. +// The pools (entityPool, intPool) are accessed via frag->reader. + +class IRFunctionImpl { + public: + const FragmentImplPtr frag; + const unsigned offset; + const RawEntityId fragment_id; + + IRFunctionImpl(FragmentImplPtr frag_, unsigned offset_, + RawEntityId fragment_id_) + : frag(std::move(frag_)), offset(offset_), + fragment_id(fragment_id_) {} + + rpc::ir::Function::Reader reader() const; + virtual ~IRFunctionImpl() = default; +}; + +class IRBlockImpl { + public: + const FragmentImplPtr frag; + const unsigned offset; + const RawEntityId fragment_id; + + IRBlockImpl(FragmentImplPtr frag_, unsigned offset_, + RawEntityId fragment_id_) + : frag(std::move(frag_)), offset(offset_), + fragment_id(fragment_id_) {} + + rpc::ir::Block::Reader reader() const; + virtual ~IRBlockImpl() = default; +}; + +class IRInstructionImpl { + public: + const FragmentImplPtr frag; + const unsigned offset; + const RawEntityId fragment_id; + + IRInstructionImpl(FragmentImplPtr frag_, unsigned offset_, + RawEntityId fragment_id_) + : frag(std::move(frag_)), offset(offset_), + fragment_id(fragment_id_) {} + + rpc::ir::Instruction::Reader reader() const; + virtual ~IRInstructionImpl() = default; +}; + +class IRObjectImpl { + public: + const FragmentImplPtr frag; + const unsigned offset; + const RawEntityId fragment_id; + + IRObjectImpl(FragmentImplPtr frag_, unsigned offset_, + RawEntityId fragment_id_) + : frag(std::move(frag_)), offset(offset_), + fragment_id(fragment_id_) {} + + rpc::ir::Object::Reader reader() const; + virtual ~IRObjectImpl() = default; +}; + +class IRStructureImpl { + public: + const FragmentImplPtr frag; + const unsigned offset; + const RawEntityId fragment_id; + + IRStructureImpl(FragmentImplPtr frag_, unsigned offset_, + RawEntityId fragment_id_) + : frag(std::move(frag_)), offset(offset_), + fragment_id(fragment_id_) {} + + rpc::ir::Structure::Reader reader() const; + virtual ~IRStructureImpl() = default; +}; + +} // namespace mx diff --git a/lib/IR/Instruction.cpp b/lib/IR/Instruction.cpp new file mode 100644 index 000000000..6d6cff58c --- /dev/null +++ b/lib/IR/Instruction.cpp @@ -0,0 +1,290 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Impl.h" +#include "../Fragment.h" +#include "../EntityProvider.h" + +namespace mx { + +// Pool layout per instruction: +// Position 0: parentBlockOrInstruction (IRBlockId for roots, IRInstructionId for sub-exprs) +// Position 1: sourceEntityId +// Position 2 (value-producing only): resultType +// After that: operands, then opcode-specific extras + +static capnp::List::Reader +GetEntityPool(const IRInstructionImpl &impl) { + return impl.frag->reader.getIrEntityPool(); +} + +static capnp::List::Reader +GetIntPool(const IRInstructionImpl &impl) { + return impl.frag->reader.getIrIntPool(); +} + +// Does this opcode produce a typed value (has result type at position 2)? +static bool HasResultType(ir::OpCode op) { + return !ir::IsTerminator(op) && + op != ir::OpCode::VA_START && + op != ir::OpCode::VA_END && + op != ir::OpCode::VA_COPY && + op != ir::OpCode::UNKNOWN; +} + +// Starting pool offset of operands for this instruction. +static uint32_t OperandBase(const IRInstructionImpl &impl) { + auto r = impl.reader(); + auto op = static_cast(r.getOpcode()); + bool has_type = HasResultType(op); + if (has_type && op == ir::OpCode::MEMORY) { + auto int_pool = GetIntPool(impl); + auto mop = static_cast(int_pool[r.getConstOffset()]); + if (ir::IsDirectLoadStore(mop) && ir::IsAnyStore(mop)) has_type = false; + } + return r.getEntityOffset() + 2 + (has_type ? 1 : 0); +} + +EntityId IRInstruction::id(void) const { + if (!impl) return {}; + IRInstructionId iid; + iid.fragment_id = impl->fragment_id; + iid.offset = impl->offset; + iid.opcode = opcode(); + return EntityId(iid); +} + +ir::OpCode IRInstruction::opcode(void) const { + if (!impl) return ir::OpCode::UNKNOWN; + return static_cast(impl->reader().getOpcode()); +} + +gap::generator IRInstruction::operands(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = OperandBase(*impl); + uint8_t n = r.getNumOperands(); + for (uint8_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *iid = std::get_if(&vid)) { + co_yield IRInstruction(std::make_shared( + impl->frag, iid->offset, impl->fragment_id)); + } + } +} + +unsigned IRInstruction::num_operands(void) const { + if (!impl) return 0; + return impl->reader().getNumOperands(); +} + +IRInstruction IRInstruction::nth_operand(unsigned n) const { + if (!impl) return {}; + auto r = impl->reader(); + if (n >= r.getNumOperands()) return {}; + auto pool = GetEntityPool(*impl); + auto eid = pool[OperandBase(*impl) + n]; + auto vid = EntityId(eid).Unpack(); + if (auto *iid = std::get_if(&vid)) { + return IRInstruction(std::make_shared( + impl->frag, iid->offset, impl->fragment_id)); + } + return {}; +} + +std::optional IRInstruction::parent_instruction(void) const { + if (!impl) return std::nullopt; + auto pool = GetEntityPool(*impl); + auto parent_eid = pool[impl->reader().getEntityOffset()]; // position 0 + auto vid = EntityId(parent_eid).Unpack(); + // If position 0 is an instruction ID, that's the parent instruction. + if (auto *iid = std::get_if(&vid)) { + return IRInstruction(std::make_shared( + impl->frag, iid->offset, impl->fragment_id)); + } + // It's a block ID -- this is a root, no parent instruction. + return std::nullopt; +} + +bool IRInstruction::is_root(void) const { + if (!impl) return false; + auto pool = GetEntityPool(*impl); + auto parent_eid = pool[impl->reader().getEntityOffset()]; + auto vid = EntityId(parent_eid).Unpack(); + return std::holds_alternative(vid); +} + +std::optional IRInstruction::source_statement(void) const { + if (!impl) return std::nullopt; + auto pool = GetEntityPool(*impl); + auto eid = pool[impl->reader().getEntityOffset() + 1]; // position 1 + if (eid == kInvalidEntityId) return std::nullopt; + // source_entity_id can be a DeclId, StmtId, or other entity kind. + // Only try StmtFor if it's actually a Stmt entity. + auto vid = EntityId(eid).Unpack(); + if (!std::holds_alternative(vid)) return std::nullopt; + if (auto ptr = impl->frag->ep->StmtFor(impl->frag->ep, eid)) { + return Stmt(std::move(ptr)); + } + return std::nullopt; +} + +RawEntityId IRInstruction::source_entity_id(void) const { + if (!impl) return kInvalidEntityId; + auto pool = GetEntityPool(*impl); + return pool[impl->reader().getEntityOffset() + 1]; +} + +IRBlock IRInstruction::parent_block(void) const { + if (!impl) return {}; + auto pool = GetEntityPool(*impl); + auto parent_eid = pool[impl->reader().getEntityOffset()]; // position 0 + auto vid = EntityId(parent_eid).Unpack(); + // If position 0 is a block ID, return it directly. + if (auto *bid = std::get_if(&vid)) { + return IRBlock(std::make_shared( + impl->frag, bid->offset, impl->fragment_id)); + } + // Walk up the parent chain to find the block. + if (auto *iid = std::get_if(&vid)) { + auto parent = IRInstruction(std::make_shared( + impl->frag, iid->offset, impl->fragment_id)); + return parent.parent_block(); + } + return {}; +} + +gap::generator IRInstruction::users(void) const & { + if (!impl) co_return; + for (auto eid : impl->reader().getUsers()) { + auto vid = EntityId(eid).Unpack(); + if (auto *iid = std::get_if(&vid)) { + co_yield IRInstruction(std::make_shared( + impl->frag, iid->offset, impl->fragment_id)); + } + } +} + +unsigned IRInstruction::num_users(void) const { + if (!impl) return 0; + return impl->reader().getUsers().size(); +} + +bool IRInstruction::is_terminator(void) const { + return ir::IsTerminator(opcode()); +} + +bool IRInstruction::is_conditionally_executed(void) const { + if (!impl) return false; + return (impl->reader().getFlags() & 0x4) != 0; +} + +// Derive a name from the source entity for this instruction. +// ALLOCAs → VarDecl name. GLOBAL_PTR/THREAD_LOCAL_PTR → VarDecl name. +// FUNC_PTR → FunctionDecl name. CALL → target name. Others → empty. +std::string_view IRInstruction::name(void) const { + if (!impl) return {}; + auto eid = source_entity_id(); + if (eid == kInvalidEntityId) return {}; + auto vid = EntityId(eid).Unpack(); + if (std::holds_alternative(vid)) { + if (auto ptr = impl->frag->ep->DeclFor(impl->frag->ep, eid)) { + if (auto nd = NamedDecl::from(Decl(std::move(ptr)))) { + return nd->name(); + } + } + } + return {}; +} + +static uint32_t InstructionOffset(const IRInstruction &inst) { + auto vid = EntityId(inst.id()).Unpack(); + if (auto *iid = std::get_if(&vid)) { + return iid->offset; + } + return 0; +} + +void IRInstruction::format_ref(std::ostream &os) const { + auto n = name(); + auto off = InstructionOffset(*this); + if (!n.empty()) { + os << "%" << n << "." << off; + } else { + os << "%" << off; + } +} + +std::string IRInstruction::ref_string(void) const { + std::ostringstream ss; + format_ref(ss); + return ss.str(); +} + +void IRInstruction::format(std::ostream &os) const { + if (!impl) { os << "%? = UNKNOWN"; return; } + + // Instruction reference. + format_ref(os); + os << " = "; + + // Opcode. + auto op = opcode(); + os << ir::EnumeratorName(op); + + // Sub-opcode for grouped instructions. + if (auto ai = AllocaInst::from(*this)) { + os << "/" << ir::EnumeratorName(ai->alloca_kind()); + } else if (auto mi = MemoryInst::from(*this)) { + os << "/" << ir::EnumeratorName(mi->sub_opcode()); + } else if (auto ci = ConstInst::from(*this)) { + os << "/" << ir::EnumeratorName(ci->sub_opcode()); + auto sub = ci->sub_opcode(); + if (sub >= ir::ConstOp::FLOAT32 && sub <= ir::ConstOp::FLOAT64) { + os << " " << ci->float_value(); + } else if (sub >= ir::ConstOp::UINT8 && sub <= ir::ConstOp::UINT64) { + os << " " << ci->unsigned_value(); + } else if (sub != ir::ConstOp::NULL_PTR) { + os << " " << ci->signed_value(); + } + } else if (auto ci = CastInst::from(*this)) { + os << "/" << ir::EnumeratorName(ci->sub_opcode()); + } else if (auto bi = BitwiseOpInst::from(*this)) { + os << "/" << ir::EnumeratorName(bi->sub_opcode()); + } else if (auto fi = FloatOpInst::from(*this)) { + os << "/" << ir::EnumeratorName(fi->sub_opcode()); + } + + // Operands. + unsigned n = num_operands(); + if (n > 0) { + os << " ["; + for (unsigned i = 0; i < n; ++i) { + if (i) os << ", "; + nth_operand(i).format_ref(os); + } + os << "]"; + } +} + +std::string IRInstruction::to_string(void) const { + std::ostringstream ss; + format(ss); + return ss.str(); +} + +} // namespace mx diff --git a/lib/IR/InstructionKinds.cpp b/lib/IR/InstructionKinds.cpp new file mode 100644 index 000000000..b0e9e81d3 --- /dev/null +++ b/lib/IR/InstructionKinds.cpp @@ -0,0 +1,852 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include +#include +#include +#include +#include + +#include "Impl.h" +#include "../Fragment.h" +#include "../EntityProvider.h" + +#include + +namespace mx { +namespace { + +using Pool = capnp::List::Reader; +using IntPool = capnp::List::Reader; + +Pool GetPool(const IRInstructionImpl &impl) { + return impl.frag->reader.getIrEntityPool(); +} + +IntPool GetIntPool(const IRInstructionImpl &impl) { + return impl.frag->reader.getIrIntPool(); +} + +// NOTE: For MEMORY instructions, this returns true. Loads have a result type +// at position 2; stores/bulk ops do not (the serializer omits it). +// The MemoryInst read-side code handles this via the sub-opcode. +bool HasResultType(ir::OpCode op) { + return !ir::IsTerminator(op) && + op != ir::OpCode::VA_START && + op != ir::OpCode::VA_END && + op != ir::OpCode::VA_COPY && + op != ir::OpCode::ENTER_SCOPE && + op != ir::OpCode::EXIT_SCOPE && + op != ir::OpCode::UNKNOWN; +} + +// For MEMORY instructions, check the sub-opcode to determine if there's a +// result type. Stores don't have a result type; bulk/string ops do. +bool HasResultTypeForInst(const rpc::ir::Instruction::Reader &r, + const IntPool &int_pool) { + auto op = static_cast(r.getOpcode()); + if (!HasResultType(op)) return false; + if (op == ir::OpCode::MEMORY) { + auto mop = static_cast(int_pool[r.getConstOffset()]); + // Direct stores have no result type; everything else does. + if (ir::IsDirectLoadStore(mop)) return ir::IsAnyLoad(mop); + return true; // bulk/string ops always have a result type + } + return true; +} + +// Pool position of result type (only valid if HasResultType). +uint32_t TypePos(const rpc::ir::Instruction::Reader &r) { + return r.getEntityOffset() + 2; +} + +// Pool position of first operand. +uint32_t OpBase(const rpc::ir::Instruction::Reader &r, + const IntPool &int_pool) { + auto op = static_cast(r.getOpcode()); + bool has_type = HasResultType(op); + if (has_type && op == ir::OpCode::MEMORY) { + auto mop = static_cast(int_pool[r.getConstOffset()]); + if (ir::IsDirectLoadStore(mop) && ir::IsAnyStore(mop)) has_type = false; + } + return r.getEntityOffset() + 2 + (has_type ? 1 : 0); +} + +// Pool position of first extra (after operands). +uint32_t ExtraBase(const rpc::ir::Instruction::Reader &r, + const IntPool &int_pool) { + return OpBase(r, int_pool) + r.getNumOperands(); +} + +IRInstruction MakeInst(const IRInstructionImpl &parent, uint64_t eid) { + auto vid = EntityId(eid).Unpack(); + if (auto *iid = std::get_if(&vid)) { + return IRInstruction(std::make_shared( + parent.frag, iid->offset, parent.fragment_id)); + } + return {}; +} + +IRBlock MakeBlock(const IRInstructionImpl &parent, uint64_t eid) { + auto vid = EntityId(eid).Unpack(); + if (auto *bid = std::get_if(&vid)) { + return IRBlock(std::make_shared( + parent.frag, bid->offset, parent.fragment_id)); + } + return {}; +} + +IRObject MakeObj(const IRInstructionImpl &parent, uint64_t eid) { + auto vid = EntityId(eid).Unpack(); + if (auto *oid = std::get_if(&vid)) { + return IRObject(std::make_shared( + parent.frag, oid->offset, parent.fragment_id)); + } + return {}; +} + +Type ResolveType(const IRInstructionImpl &impl, uint64_t eid) { + assert(eid != kInvalidEntityId && "Missing type entity ID"); + auto ptr = impl.frag->ep->TypeFor(impl.frag->ep, eid); + assert(ptr && "Failed to resolve type entity ID"); + return Type(std::move(ptr)); +} + +// Optional version for CallInst result type (void calls). +std::optional MaybeResolveType(const IRInstructionImpl &impl, uint64_t eid) { + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl.frag->ep->TypeFor(impl.frag->ep, eid)) { + return Type(std::move(ptr)); + } + return std::nullopt; +} + +std::optional ResolveFunc(const IRInstructionImpl &impl, uint64_t eid) { + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl.frag->ep->DeclFor(impl.frag->ep, eid)) { + return FunctionDecl::from(Decl(std::move(ptr))); + } + return std::nullopt; +} + +FieldDecl ResolveField(const IRInstructionImpl &impl, uint64_t eid) { + assert(eid != kInvalidEntityId && "Missing field entity ID"); + auto ptr = impl.frag->ep->DeclFor(impl.frag->ep, eid); + assert(ptr && "Failed to resolve field entity ID"); + auto fd = FieldDecl::from(Decl(std::move(ptr))); + assert(fd && "Entity is not a FieldDecl"); + return *fd; +} + +} // namespace + +// ---- from() methods ---- + +#define IMPL_FROM_SINGLE(Class, opcode_val) \ + std::optional Class::from(const IRInstruction &inst) { \ + if (inst.opcode() == ir::OpCode::opcode_val) \ + return Class(inst.impl_ptr()); \ + return std::nullopt; \ + } + +#define IMPL_FROM_RANGE(Class, first, last) \ + std::optional Class::from(const IRInstruction &inst) { \ + auto op = inst.opcode(); \ + if (op >= ir::OpCode::first && op <= ir::OpCode::last) \ + return Class(inst.impl_ptr()); \ + return std::nullopt; \ + } + +IMPL_FROM_SINGLE(ConstInst, CONST) +IMPL_FROM_SINGLE(AllocaInst, ALLOCA) +IMPL_FROM_SINGLE(MemoryInst, MEMORY) +std::optional GEPFieldInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::GEP_FIELD_32 || op == ir::OpCode::GEP_FIELD_64) + return GEPFieldInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional PtrAddInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::PTR_ADD_32 || op == ir::OpCode::PTR_ADD_64) + return PtrAddInst(inst.impl_ptr()); + return std::nullopt; +} +IMPL_FROM_SINGLE(ReadModifyWriteInst, READ_MODIFY_WRITE) +IMPL_FROM_SINGLE(CallInst, CALL) +IMPL_FROM_SINGLE(LastValueInst, LAST_VALUE) +IMPL_FROM_SINGLE(SelectInst, SELECT) +IMPL_FROM_SINGLE(VAStartInst, VA_START) +IMPL_FROM_SINGLE(VAEndInst, VA_END) +IMPL_FROM_SINGLE(VACopyInst, VA_COPY) +std::optional ParamPtrInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::PARAM_PTR_32 || op == ir::OpCode::PARAM_PTR_64) + return ParamPtrInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional GlobalPtrInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::GLOBAL_PTR_32 || op == ir::OpCode::GLOBAL_PTR_64) + return GlobalPtrInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional ThreadLocalPtrInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::THREAD_LOCAL_PTR_32 || op == ir::OpCode::THREAD_LOCAL_PTR_64) + return ThreadLocalPtrInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional FuncPtrInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::FUNC_PTR_32 || op == ir::OpCode::FUNC_PTR_64) + return FuncPtrInst(inst.impl_ptr()); + return std::nullopt; +} +// MultimemInst removed: merged into MemoryInst. +std::optional BitwiseOpInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op >= ir::OpCode::BITWISE_8 && op <= ir::OpCode::BITWISE_64) + return BitwiseOpInst(inst.impl_ptr()); + return std::nullopt; +} +IMPL_FROM_SINGLE(FloatOpInst, FLOAT) +std::optional FramePtrInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::FRAME_PTR_32 || op == ir::OpCode::FRAME_PTR_64) + return FramePtrInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional ReturnAddressInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::RETURN_ADDRESS_32 || op == ir::OpCode::RETURN_ADDRESS_64) + return ReturnAddressInst(inst.impl_ptr()); + return std::nullopt; +} +IMPL_FROM_SINGLE(EnterScopeInst, ENTER_SCOPE) +IMPL_FROM_SINGLE(ExitScopeInst, EXIT_SCOPE) +IMPL_FROM_SINGLE(UndefinedInst, UNDEFINED) +std::optional ReturnPtrInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::RETURN_PTR_32 || op == ir::OpCode::RETURN_PTR_64) + return ReturnPtrInst(inst.impl_ptr()); + return std::nullopt; +} + +// ConsumeVAParamInst: matches MEMORY with CONSUME_VA_PARAM sub-opcode. +std::optional ConsumeVAParamInst::from(const IRInstruction &inst) { + if (inst.opcode() != ir::OpCode::MEMORY) return std::nullopt; + // Check sub-opcode from int pool. + auto &i = *inst.impl_ptr(); + auto int_pool = GetIntPool(i); + auto r = i.reader(); + auto mop = static_cast(int_pool[r.getConstOffset()]); + if (mop != ir::MemOp::CONSUME_VA_PARAM) return std::nullopt; + return ConsumeVAParamInst(inst.impl_ptr()); +} + +IMPL_FROM_SINGLE(RetInst, RET) +IMPL_FROM_SINGLE(CondBranchInst, COND_BRANCH) +IMPL_FROM_SINGLE(SwitchInst, SWITCH) +std::optional UnreachableInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::UNREACHABLE || op == ir::OpCode::IMPLICIT_UNREACHABLE) + return UnreachableInst(inst.impl_ptr()); + return std::nullopt; +} +IMPL_FROM_SINGLE(UnknownInst, UNKNOWN) + +std::optional BinaryInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (ir::IsBinaryOp(op)) + return BinaryInst(inst.impl_ptr()); + return std::nullopt; +} +std::optional ComparisonInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (ir::IsComparison(op)) + return ComparisonInst(inst.impl_ptr()); + return std::nullopt; +} +std::optional PtrDiffInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::PTR_DIFF_32 || op == ir::OpCode::PTR_DIFF_64) + return PtrDiffInst(inst.impl_ptr()); + return std::nullopt; +} +std::optional UnaryInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (ir::IsUnaryOp(op)) + return UnaryInst(inst.impl_ptr()); + return std::nullopt; +} +IMPL_FROM_SINGLE(CastInst, CAST) + +std::optional BranchInst::from(const IRInstruction &inst) { + auto op = inst.opcode(); + if (op == ir::OpCode::GOTO || op == ir::OpCode::IMPLICIT_GOTO || + op == ir::OpCode::BREAK || op == ir::OpCode::CONTINUE || + op == ir::OpCode::FALLTHROUGH || op == ir::OpCode::IMPLICIT_FALLTHROUGH) + return BranchInst(inst.impl_ptr()); + return std::nullopt; +} + +#undef IMPL_FROM_SINGLE +#undef IMPL_FROM_RANGE + +// ---- ConstInst ---- + +ir::ConstOp ConstInst::sub_opcode(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + return static_cast(int_pool[r.getConstOffset()]); +} + +int64_t ConstInst::signed_value(void) const { + return GetIntPool(*impl)[impl->reader().getConstOffset() + 1]; +} + +uint64_t ConstInst::unsigned_value(void) const { + return static_cast(GetIntPool(*impl)[impl->reader().getConstOffset() + 2]); +} + +double ConstInst::float_value(void) const { + int64_t bits = GetIntPool(*impl)[impl->reader().getConstOffset() + 1]; + double result; + memcpy(&result, &bits, sizeof(result)); + return result; +} + +Type ConstInst::type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- AllocaInst and derived kinds ---- + +ir::AllocaKind AllocaInst::alloca_kind(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + return static_cast(int_pool[r.getConstOffset()]); +} + +// Alloca sub-kind from() implementations. +static ir::AllocaKind GetAllocaKind(const IRInstruction &inst) { + if (inst.opcode() != ir::OpCode::ALLOCA) + return static_cast(255); // invalid sentinel + auto &i = *inst.impl_ptr(); + auto int_pool = GetIntPool(i); + auto r = i.reader(); + return static_cast(int_pool[r.getConstOffset()]); +} + +std::optional LocalAllocaInst::from(const IRInstruction &inst) { + if (GetAllocaKind(inst) == ir::AllocaKind::LOCAL) + return LocalAllocaInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional ArgAllocaInst::from(const IRInstruction &inst) { + if (GetAllocaKind(inst) == ir::AllocaKind::ARG) + return ArgAllocaInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional ReturnAllocaInst::from(const IRInstruction &inst) { + if (GetAllocaKind(inst) == ir::AllocaKind::RETURN) + return ReturnAllocaInst(inst.impl_ptr()); + return std::nullopt; +} + +std::optional DynamicAllocaInst::from(const IRInstruction &inst) { + if (GetAllocaKind(inst) == ir::AllocaKind::DYNAMIC) + return DynamicAllocaInst(inst.impl_ptr()); + return std::nullopt; +} + +Type AllocaInst::allocated_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +IRObject AllocaInst::object(void) const { + return MakeObj(*impl, GetPool(*impl)[ExtraBase(impl->reader(), GetIntPool(*impl))]); +} + +uint32_t AllocaInst::size_bytes(void) const { + return object().size_bytes(); +} + +uint32_t AllocaInst::align_bytes(void) const { + return object().align_bytes(); +} + +// ---- MemoryInst ---- + +ir::MemOp MemoryInst::sub_opcode(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + return static_cast(int_pool[r.getConstOffset()]); +} + +IRInstruction MemoryInst::address(void) const { + return nth_operand(0); +} + +IRInstruction MemoryInst::stored_value(void) const { + return nth_operand(1); +} + +Type MemoryInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +uint32_t MemoryInst::bit_offset(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + // int_pool layout for MEMORY: [sub_opcode, bit_offset, bit_width] + return static_cast(int_pool[r.getConstOffset() + 1]); +} + +uint32_t MemoryInst::bit_width(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + return static_cast(int_pool[r.getConstOffset() + 2]); +} + +// ---- GEPFieldInst ---- + +IRInstruction GEPFieldInst::base(void) const { + return nth_operand(0); +} + +Type GEPFieldInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +FieldDecl GEPFieldInst::field(void) const { + auto pool = GetPool(*impl); + return ResolveField(*impl, pool[ExtraBase(impl->reader(), GetIntPool(*impl))]); +} + +int64_t GEPFieldInst::byte_offset(void) const { + return GetIntPool(*impl)[impl->reader().getConstOffset()]; +} + +// ---- PtrAddInst ---- + +IRInstruction PtrAddInst::base(void) const { + return nth_operand(0); +} + +IRInstruction PtrAddInst::index(void) const { + return nth_operand(1); +} + +Type PtrAddInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +Type PtrAddInst::element_type(void) const { + auto pool = GetPool(*impl); + return ResolveType(*impl, pool[ExtraBase(impl->reader(), GetIntPool(*impl))]); +} + +int64_t PtrAddInst::element_size(void) const { + return GetIntPool(*impl)[impl->reader().getConstOffset()]; +} + +// ---- PtrDiffInst ---- + +IRInstruction PtrDiffInst::lhs(void) const { return nth_operand(0); } +IRInstruction PtrDiffInst::rhs(void) const { return nth_operand(1); } + +Type PtrDiffInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +int64_t PtrDiffInst::element_size(void) const { + return GetIntPool(*impl)[impl->reader().getConstOffset()]; +} + +// ---- BinaryInst ---- + +IRInstruction BinaryInst::lhs(void) const { return nth_operand(0); } +IRInstruction BinaryInst::rhs(void) const { return nth_operand(1); } +Type BinaryInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- ComparisonInst ---- + +IRInstruction ComparisonInst::lhs(void) const { return nth_operand(0); } +IRInstruction ComparisonInst::rhs(void) const { return nth_operand(1); } +Type ComparisonInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- UnaryInst ---- + +IRInstruction UnaryInst::operand(void) const { return nth_operand(0); } +Type UnaryInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- CastInst ---- + +ir::CastOp CastInst::sub_opcode(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + return static_cast(int_pool[r.getConstOffset()]); +} + +IRInstruction CastInst::operand(void) const { return nth_operand(0); } +Type CastInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- ReadModifyWriteInst ---- + +IRInstruction ReadModifyWriteInst::address(void) const { return nth_operand(0); } + +ir::OpCode ReadModifyWriteInst::underlying_op(void) const { + return static_cast( + GetIntPool(*impl)[impl->reader().getConstOffset()]); +} + +int64_t ReadModifyWriteInst::element_size(void) const { + return GetIntPool(*impl)[impl->reader().getConstOffset() + 1]; +} + +bool ReadModifyWriteInst::is_big_endian(void) const { + return GetIntPool(*impl)[impl->reader().getConstOffset() + 2] != 0; +} + +bool ReadModifyWriteInst::is_atomic(void) const { + auto op = underlying_op(); + return op >= ir::OpCode::ATOMIC_ADD_8 && op <= ir::OpCode::ATOMIC_EXCHANGE_64; +} + +bool ReadModifyWriteInst::returns_new_value(void) const { + return (impl->reader().getFlags() & 1) != 0; +} + +Type ReadModifyWriteInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +gap::generator ReadModifyWriteInst::rhs_operands(void) const & { + for (unsigned i = 1; i < num_operands(); ++i) { + co_yield nth_operand(i); + } +} + +// ---- CallInst ---- + +std::optional CallInst::result_type(void) const { + return MaybeResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +std::optional CallInst::target(void) const { + auto pool = GetPool(*impl); + return ResolveFunc(*impl, pool[ExtraBase(impl->reader(), GetIntPool(*impl))]); +} + +bool CallInst::is_indirect(void) const { + auto pool = GetPool(*impl); + auto eid = pool[ExtraBase(impl->reader(), GetIntPool(*impl))]; + return eid == kInvalidEntityId; +} + +bool CallInst::has_return_value(void) const { + auto pool = GetPool(*impl); + auto base = ExtraBase(impl->reader(), GetIntPool(*impl)); + auto eid = pool[base + 1]; // extras[1] = return alloca entity ID + return eid != kInvalidEntityId; +} + +std::optional CallInst::return_alloca(void) const { + auto pool = GetPool(*impl); + auto base = ExtraBase(impl->reader(), GetIntPool(*impl)); + auto eid = pool[base + 1]; // extras[1] = return alloca entity ID + if (eid == kInvalidEntityId) return std::nullopt; + auto inst = MakeInst(*impl, eid); + return AllocaInst::from(inst); +} + +gap::generator CallInst::arguments(void) const & { + // For direct calls: all operands are ARG allocas. + // For indirect calls: operand 0 is the callee pointer, rest are ARG allocas. + bool indirect = is_indirect(); + unsigned start = indirect ? 1 : 0; + for (unsigned i = start; i < num_operands(); ++i) { + co_yield nth_operand(i); + } +} + +// ---- SelectInst ---- + +// ---- LastValueInst ---- + +IRInstruction LastValueInst::last(void) const { + return nth_operand(num_operands() - 1); +} + +Type LastValueInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- SelectInst ---- + +IRInstruction SelectInst::condition(void) const { return nth_operand(0); } +IRInstruction SelectInst::true_value(void) const { return nth_operand(1); } +IRInstruction SelectInst::false_value(void) const { return nth_operand(2); } + +Type SelectInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// CopyInst removed: use CastInst with CastOp::IDENTITY instead. + +// ---- RetInst ---- + +std::optional RetInst::return_value(void) const { + if (num_operands() > 0) return nth_operand(0); + return std::nullopt; +} + +// ---- BranchInst ---- + +IRBlock BranchInst::target_block(void) const { + auto pool = GetPool(*impl); + // For branch terminators, the target block is the first extra. + return MakeBlock(*impl, pool[ExtraBase(impl->reader(), GetIntPool(*impl))]); +} + +// ---- CondBranchInst ---- + +IRInstruction CondBranchInst::condition(void) const { return nth_operand(0); } + +IRBlock CondBranchInst::true_block(void) const { + auto pool = GetPool(*impl); + auto base = ExtraBase(impl->reader(), GetIntPool(*impl)); + return MakeBlock(*impl, pool[base]); +} + +IRBlock CondBranchInst::false_block(void) const { + auto pool = GetPool(*impl); + auto base = ExtraBase(impl->reader(), GetIntPool(*impl)); + return MakeBlock(*impl, pool[base + 1]); +} + +// ---- SwitchInst ---- + +IRInstruction SwitchInst::selector(void) const { return nth_operand(0); } + +// ---- VA* instructions ---- + +IRInstruction VAStartInst::va_list_operand(void) const { return nth_operand(0); } +IRInstruction VAEndInst::va_list_operand(void) const { return nth_operand(0); } +IRInstruction VACopyInst::dest(void) const { return nth_operand(0); } +IRInstruction VACopyInst::src(void) const { return nth_operand(1); } +// ---- ConsumeVAParamInst ---- + +IRInstruction ConsumeVAParamInst::va_list_operand(void) const { return nth_operand(0); } + +Type ConsumeVAParamInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- ParamPtrInst ---- + +uint32_t ParamPtrInst::parameter_index(void) const { + auto r = impl->reader(); + auto int_pool = GetIntPool(*impl); + return static_cast(int_pool[r.getConstOffset()]); +} + +Type ParamPtrInst::parameter_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- GlobalPtrInst / ThreadLocalPtrInst / FuncPtrInst ---- + +std::optional GlobalPtrInst::variable(void) const { + auto pool = GetPool(*impl); + auto r = impl->reader(); + auto extra_base = ExtraBase(r, GetIntPool(*impl)); + auto eid = pool[extra_base]; + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl->frag->ep->DeclFor(impl->frag->ep, eid)) { + return VarDecl::from(Decl(std::move(ptr))); + } + return std::nullopt; +} + +std::optional ThreadLocalPtrInst::variable(void) const { + auto pool = GetPool(*impl); + auto r = impl->reader(); + auto extra_base = ExtraBase(r, GetIntPool(*impl)); + auto eid = pool[extra_base]; + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl->frag->ep->DeclFor(impl->frag->ep, eid)) { + return VarDecl::from(Decl(std::move(ptr))); + } + return std::nullopt; +} + +std::optional FuncPtrInst::function(void) const { + auto pool = GetPool(*impl); + auto r = impl->reader(); + auto extra_base = ExtraBase(r, GetIntPool(*impl)); + auto eid = pool[extra_base]; + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl->frag->ep->DeclFor(impl->frag->ep, eid)) { + return FunctionDecl::from(Decl(std::move(ptr))); + } + return std::nullopt; +} + +// MultimemInst removed: merged into MemoryInst. + +// ---- BitwiseOpInst ---- + +ir::BitwiseOp BitwiseOpInst::sub_opcode(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + return static_cast(int_pool[r.getConstOffset()]); +} + +Type BitwiseOpInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- FloatOpInst ---- + +ir::FloatOp FloatOpInst::sub_opcode(void) const { + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + return static_cast(int_pool[r.getConstOffset()]); +} + +Type FloatOpInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- DynamicAllocaInst ---- + +// ---- DynamicAllocaInst ---- + +IRInstruction DynamicAllocaInst::size(void) const { return nth_operand(0); } + +// ---- FramePtrInst ---- + +IRInstruction FramePtrInst::level(void) const { return nth_operand(0); } +Type FramePtrInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- ReturnAddressInst ---- + +IRInstruction ReturnAddressInst::level(void) const { return nth_operand(0); } +Type ReturnAddressInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- ReturnPtrInst ---- + +Type ReturnPtrInst::return_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- EnterScopeInst / ExitScopeInst ---- + +IRStructure EnterScopeInst::scope(void) const { + auto pool = GetPool(*impl); + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + auto extra_base = ExtraBase(r, int_pool); + auto eid = pool[extra_base]; + auto vid = EntityId(eid).Unpack(); + if (auto *sid = std::get_if(&vid)) { + return IRStructure(std::make_shared( + impl->frag, sid->offset, impl->fragment_id)); + } + return {}; +} + +IRStructure ExitScopeInst::scope(void) const { + auto pool = GetPool(*impl); + auto int_pool = GetIntPool(*impl); + auto r = impl->reader(); + auto extra_base = ExtraBase(r, int_pool); + auto eid = pool[extra_base]; + auto vid = EntityId(eid).Unpack(); + if (auto *sid = std::get_if(&vid)) { + return IRStructure(std::make_shared( + impl->frag, sid->offset, impl->fragment_id)); + } + return {}; +} + +// ---- UndefinedInst ---- + +Type UndefinedInst::result_type(void) const { + return ResolveType(*impl, GetPool(*impl)[TypePos(impl->reader())]); +} + +// ---- SwitchInst ---- + +unsigned SwitchInst::num_cases(void) const { + auto pool = GetPool(*impl); + auto r = impl->reader(); + auto extra_base = ExtraBase(r, GetIntPool(*impl)); + // Extras: [caseType, case0_eid, case1_eid, ...] + // Count by checking how many pool entries after caseType are + // IRStructureId with SWITCH_CASE kind. + unsigned count = 0; + for (uint32_t i = extra_base + 1; ; ++i) { + if (i >= pool.size()) break; + auto vid = EntityId(pool[i]).Unpack(); + if (auto *sid = std::get_if(&vid)) { + if (sid->structure_kind == ir::StructureKind::SWITCH_CASE) { + ++count; + continue; + } + } + break; + } + return count; +} + +std::optional SwitchInst::case_type(void) const { + auto pool = GetPool(*impl); + return MaybeResolveType(*impl, pool[ExtraBase(impl->reader(), GetIntPool(*impl))]); +} + +gap::generator SwitchInst::cases(void) const & { + auto pool = GetPool(*impl); + auto r = impl->reader(); + auto extra_base = ExtraBase(r, GetIntPool(*impl)); + + // Extras: [caseType, case0_eid, case1_eid, ...] + for (uint32_t i = extra_base + 1; ; ++i) { + if (i >= pool.size()) break; + auto vid = EntityId(pool[i]).Unpack(); + if (auto *sid = std::get_if(&vid)) { + if (sid->structure_kind == ir::StructureKind::SWITCH_CASE) { + co_yield IRSwitchCaseStructure(std::make_shared( + impl->frag, sid->offset, impl->fragment_id)); + continue; + } + } + break; + } +} + +} // namespace mx diff --git a/lib/IR/Object.cpp b/lib/IR/Object.cpp new file mode 100644 index 000000000..b43f5e594 --- /dev/null +++ b/lib/IR/Object.cpp @@ -0,0 +1,66 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include +#include +#include +#include + +#include "Impl.h" +#include "../Fragment.h" +#include "../EntityProvider.h" + +namespace mx { + +EntityId IRObject::id(void) const { + if (!impl) return {}; + IRObjectId oid; + oid.fragment_id = impl->fragment_id; + oid.offset = impl->offset; + return EntityId(oid); +} + +ir::ObjectKind IRObject::kind(void) const { + if (!impl) return ir::ObjectKind::LOCAL; + return static_cast(impl->reader().getKind()); +} + +uint32_t IRObject::size_bytes(void) const { + if (!impl) return 0; + return impl->reader().getSizeBytes(); +} + +uint32_t IRObject::align_bytes(void) const { + if (!impl) return 0; + return impl->reader().getAlignBytes(); +} + +std::optional IRObject::source_declaration(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getSourceDeclId(); + if (eid == kInvalidEntityId) return std::nullopt; + auto vid = EntityId(eid).Unpack(); + if (!std::holds_alternative(vid)) return std::nullopt; + if (auto ptr = impl->frag->ep->DeclFor(impl->frag->ep, eid)) { + return VarDecl::from(Decl(std::move(ptr))); + } + return std::nullopt; +} + +std::optional IRObject::type(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getTypeEntityId(); + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl->frag->ep->TypeFor(impl->frag->ep, eid)) { + return Type(std::move(ptr)); + } + return std::nullopt; +} + +bool IRObject::needs_memory(void) const { + return ir::NeedsMemory(kind()); +} + +} // namespace mx diff --git a/lib/IR/Structure.cpp b/lib/IR/Structure.cpp new file mode 100644 index 000000000..66a2a95fb --- /dev/null +++ b/lib/IR/Structure.cpp @@ -0,0 +1,124 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include +#include +#include +#include + +#include "Impl.h" +#include "../Fragment.h" + +namespace mx { + +// Entity pool layout per structure (starting at entityOffset): +// [child0..childN, obj0..objM] +// where children are IRStructureId or IRBlockId, +// and objects are IRObjectId (only for scope kinds). + +static capnp::List::Reader +GetEntityPool(const IRStructureImpl &impl) { + return impl.frag->reader.getIrEntityPool(); +} + +EntityId IRStructure::id(void) const { + if (!impl) return {}; + IRStructureId sid; + sid.fragment_id = impl->fragment_id; + sid.offset = impl->offset; + sid.structure_kind = kind(); + return EntityId(sid); +} + +ir::StructureKind IRStructure::kind(void) const { + if (!impl) return ir::StructureKind::SCOPE; + return static_cast(impl->reader().getKind()); +} + +std::optional IRStructure::source_statement(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getSourceEntityId(); + if (eid == kInvalidEntityId) return std::nullopt; + if (auto ptr = impl->frag->ep->StmtFor(impl->frag->ep, eid)) { + return Stmt(std::move(ptr)); + } + return std::nullopt; +} + +std::optional IRStructure::parent_structure(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getParentId(); + auto vid = EntityId(eid).Unpack(); + if (auto *sid = std::get_if(&vid)) { + return IRStructure(std::make_shared( + impl->frag, sid->offset, impl->fragment_id)); + } + return std::nullopt; +} + +std::optional IRStructure::parent_function(void) const { + if (!impl) return std::nullopt; + auto eid = impl->reader().getParentId(); + auto vid = EntityId(eid).Unpack(); + if (auto *fid = std::get_if(&vid)) { + return IRFunction(std::make_shared( + impl->frag, fid->offset, impl->fragment_id)); + } + return std::nullopt; +} + +gap::generator IRStructure::child_structures(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset(); + uint16_t n = r.getNumChildren(); + for (uint16_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *sid = std::get_if(&vid)) { + co_yield IRStructure(std::make_shared( + impl->frag, sid->offset, impl->fragment_id)); + } + } +} + +gap::generator IRStructure::child_blocks(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset(); + uint16_t n = r.getNumChildren(); + for (uint16_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *bid = std::get_if(&vid)) { + co_yield IRBlock(std::make_shared( + impl->frag, bid->offset, impl->fragment_id)); + } + } +} + +gap::generator IRStructure::objects(void) const & { + if (!impl) co_return; + auto r = impl->reader(); + auto pool = GetEntityPool(*impl); + uint32_t base = r.getEntityOffset() + r.getNumChildren(); + uint16_t n = r.getNumObjects(); + for (uint16_t i = 0; i < n; ++i) { + auto eid = pool[base + i]; + auto vid = EntityId(eid).Unpack(); + if (auto *oid = std::get_if(&vid)) { + co_yield IRObject(std::make_shared( + impl->frag, oid->offset, impl->fragment_id)); + } + } +} + +bool IRStructure::is_scope(void) const { + return ir::IsScope(kind()); +} + +} // namespace mx diff --git a/lib/IR/StructureKinds.cpp b/lib/IR/StructureKinds.cpp new file mode 100644 index 000000000..037c4cd76 --- /dev/null +++ b/lib/IR/StructureKinds.cpp @@ -0,0 +1,201 @@ +// Copyright (c) 2024-present, Trail of Bits, Inc. +// +// This source code is licensed in accordance with the terms specified in +// the LICENSE file found in the root directory of this source tree. + +#include + +#include "Impl.h" +#include "../Fragment.h" + +namespace mx { +namespace { + +// Helper: find a child structure of a given kind. +static std::optional FindChild( + const IRStructure &parent, ir::StructureKind kind) { + for (auto child : parent.child_structures()) { + if (child.kind() == kind) return child; + } + return std::nullopt; +} + +} // namespace + +// --------------------------------------------------------------------------- +// from() implementations +// --------------------------------------------------------------------------- + +std::optional IRScopeStructure::from(const IRStructure &s) { + if (s.is_scope()) return IRScopeStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRIfStructure::from(const IRStructure &s) { + if (s.kind() == ir::StructureKind::IF) return IRIfStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRIfThenStructure::from(const IRStructure &s) { + if (s.kind() == ir::StructureKind::IF_THEN) + return IRIfThenStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRIfElseStructure::from(const IRStructure &s) { + if (s.kind() == ir::StructureKind::IF_ELSE) + return IRIfElseStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRForStructure::from(const IRStructure &s) { + if (s.kind() == ir::StructureKind::FOR) return IRForStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRWhileStructure::from(const IRStructure &s) { + if (s.kind() == ir::StructureKind::WHILE) + return IRWhileStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRDoWhileStructure::from( + const IRStructure &s) { + if (s.kind() == ir::StructureKind::DO_WHILE) + return IRDoWhileStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRSwitchStructure::from( + const IRStructure &s) { + if (s.kind() == ir::StructureKind::SWITCH) + return IRSwitchStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRSwitchCaseStructure::from( + const IRStructure &s) { + if (s.kind() == ir::StructureKind::SWITCH_CASE) + return IRSwitchCaseStructure(s.impl_ptr()); + return std::nullopt; +} + +std::optional IRExpressionScopeStructure::from( + const IRStructure &s) { + if (s.kind() == ir::StructureKind::EXPRESSION_SCOPE) + return IRExpressionScopeStructure(s.impl_ptr()); + return std::nullopt; +} + +// --------------------------------------------------------------------------- +// IRIfStructure +// --------------------------------------------------------------------------- + +std::optional IRIfStructure::then_branch(void) const { + return FindChild(*this, ir::StructureKind::IF_THEN); +} + +std::optional IRIfStructure::else_branch(void) const { + return FindChild(*this, ir::StructureKind::IF_ELSE); +} + +// --------------------------------------------------------------------------- +// IRForStructure +// --------------------------------------------------------------------------- + +std::optional IRForStructure::init(void) const { + return FindChild(*this, ir::StructureKind::FOR_INIT); +} + +std::optional IRForStructure::condition(void) const { + return FindChild(*this, ir::StructureKind::FOR_CONDITION); +} + +std::optional IRForStructure::body(void) const { + return FindChild(*this, ir::StructureKind::FOR_BODY); +} + +std::optional IRForStructure::increment(void) const { + return FindChild(*this, ir::StructureKind::FOR_INCREMENT); +} + +// --------------------------------------------------------------------------- +// IRWhileStructure +// --------------------------------------------------------------------------- + +std::optional IRWhileStructure::condition(void) const { + return FindChild(*this, ir::StructureKind::WHILE_CONDITION); +} + +std::optional IRWhileStructure::body(void) const { + return FindChild(*this, ir::StructureKind::WHILE_BODY); +} + +// --------------------------------------------------------------------------- +// IRDoWhileStructure +// --------------------------------------------------------------------------- + +std::optional IRDoWhileStructure::body(void) const { + return FindChild(*this, ir::StructureKind::DO_WHILE_BODY); +} + +std::optional IRDoWhileStructure::condition(void) const { + return FindChild(*this, ir::StructureKind::DO_WHILE_CONDITION); +} + +// --------------------------------------------------------------------------- +// IRSwitchStructure +// --------------------------------------------------------------------------- + +gap::generator +IRSwitchStructure::cases(void) const & { + for (auto child : child_structures()) { + if (child.kind() == ir::StructureKind::SWITCH_CASE) { + co_yield IRSwitchCaseStructure(child.impl_ptr()); + } + } +} + +std::optional +IRSwitchStructure::default_case(void) const { + for (auto child : child_structures()) { + if (child.kind() == ir::StructureKind::SWITCH_CASE) { + IRSwitchCaseStructure sc(child.impl_ptr()); + if (sc.is_default()) return sc; + } + } + return std::nullopt; +} + +// --------------------------------------------------------------------------- +// IRSwitchCaseStructure +// --------------------------------------------------------------------------- + +int64_t IRSwitchCaseStructure::low(void) const { + if (!impl_ptr()) return 0; + return impl_ptr()->reader().getCaseLow(); +} + +int64_t IRSwitchCaseStructure::high(void) const { + if (!impl_ptr()) return 0; + return impl_ptr()->reader().getCaseHigh(); +} + +bool IRSwitchCaseStructure::is_range(void) const { + return low() != high(); +} + +bool IRSwitchCaseStructure::is_default(void) const { + if (!impl_ptr()) return false; + return impl_ptr()->reader().getIsDefault(); +} + +IRBlock IRSwitchCaseStructure::target_block(void) const { + // The target block is the first child block of this SWITCH_CASE structure. + for (auto child : child_blocks()) { + return child; + } + return {}; +} + +} // namespace mx diff --git a/lib/Index.cpp b/lib/Index.cpp index 372c084ca..980d788ff 100644 --- a/lib/Index.cpp +++ b/lib/Index.cpp @@ -4,6 +4,11 @@ // the LICENSE file found in the root directory of this source tree. #include +#include +#include +#include +#include +#include "IR/Impl.h" #include #include @@ -77,6 +82,10 @@ Index Index::from_database(std::filesystem::path path) { return EntityProvider::CreateFromDatabase(std::move(path)); } +IndexVersion Index::version(void) const { + return impl->GetIndexVersion(); +} + Index Index::containing(const Compilation &entity) { return Index(entity.impl->ep); } @@ -192,12 +201,17 @@ gap::generator Index::files(void) const & { return std::nullopt; \ } -MX_FOR_EACH_ENTITY_CATEGORY(MX_DEFINE_GETTER, MX_IGNORE_ENTITY_CATEGORY, - MX_DEFINE_GETTER, MX_DEFINE_GETTER, - MX_DEFINE_GETTER, MX_DEFINE_GETTER, +MX_FOR_EACH_ENTITY_CATEGORY(MX_DEFINE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, + MX_DEFINE_GETTER, + MX_DEFINE_GETTER, + MX_DEFINE_GETTER, + MX_DEFINE_GETTER, + MX_DEFINE_GETTER, MX_DEFINE_GETTER) #undef MX_DEFINE_GETTER + // Download a fragment based off of an entity ID. std::optional Index::fragment_containing(EntityId eid) const { auto fid = mx::FragmentIdFromEntityId(eid.Pack()); @@ -272,10 +286,14 @@ VariantEntity Index::entity(EntityId eid) const { } \ assert(false); - MX_FOR_EACH_ENTITY_CATEGORY(MX_DISPATCH_GETTER, MX_IGNORE_ENTITY_CATEGORY, - MX_DISPATCH_GETTER, MX_DISPATCH_GETTER, - MX_DISPATCH_GETTER, MX_DISPATCH_GETTER, - MX_DISPATCH_GETTER) + MX_FOR_EACH_ENTITY_CATEGORY(MX_DISPATCH_GETTER, + MX_IGNORE_ENTITY_CATEGORY, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER) #undef MX_DISPATCH_GETTER diff --git a/lib/InvalidEntityProvider.cpp b/lib/InvalidEntityProvider.cpp index 47d45187b..d5727616e 100644 --- a/lib/InvalidEntityProvider.cpp +++ b/lib/InvalidEntityProvider.cpp @@ -4,6 +4,11 @@ // the LICENSE file found in the root directory of this source tree. #include "InvalidEntityProvider.h" +#include +#include +#include +#include +#include "IR/Impl.h" namespace mx { @@ -19,6 +24,7 @@ unsigned InvalidEntityProvider::VersionNumber(const Ptr &) { return 0u; } +IndexVersion InvalidEntityProvider::GetIndexVersion(void) { return {}; } void InvalidEntityProvider::VersionNumberChanged(unsigned) {} FilePathMap InvalidEntityProvider::ListFiles(const Ptr &) { @@ -95,12 +101,13 @@ gap::generator InvalidEntityProvider::FindSymbol( const Ptr &) & { co_return; } MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER) #undef MX_DECLARE_ENTITY_GETTER #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \ @@ -108,12 +115,13 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, const Ptr &, type_name ## Kind) & { co_return; } MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_LISTERS, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_LISTERS, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS Index::Index(void) diff --git a/lib/InvalidEntityProvider.h b/lib/InvalidEntityProvider.h index 897d2bf26..46fb16e65 100644 --- a/lib/InvalidEntityProvider.h +++ b/lib/InvalidEntityProvider.h @@ -22,6 +22,7 @@ class InvalidEntityProvider final : public EntityProvider { unsigned VersionNumber(void) final; unsigned VersionNumber(const Ptr &) final; + IndexVersion GetIndexVersion(void) final; void VersionNumberChanged(unsigned) final; FilePathMap ListFiles(const Ptr &) final; @@ -74,6 +75,7 @@ class InvalidEntityProvider final : public EntityProvider { MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER) #undef MX_DECLARE_ENTITY_GETTER @@ -87,6 +89,7 @@ class InvalidEntityProvider final : public EntityProvider { MX_IGNORE_ENTITY_CATEGORY, MX_DECLARE_ENTITY_LISTERS, MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS }; diff --git a/lib/RPC.capnp b/lib/RPC.capnp index 636c3e5d8..4b6d7df85 100644 --- a/lib/RPC.capnp +++ b/lib/RPC.capnp @@ -3,6 +3,9 @@ # Include the auto-generated AST schema. using AST = import "AST.capnp"; +# Include the hand-written IR schema. +using IR = import "IR.capnp"; + using Cxx = import "/capnp/c++.capnp"; $Cxx.namespace("mx::rpc"); @@ -177,6 +180,18 @@ struct Fragment @0xe5f27760091f9a3a { # them in here. textLists @25 :List(Text); uInt64Lists @26 :List(UInt64); + + # IR for function bodies in this fragment. All IR entities are flat lists, + # mirroring how decls/stmts work. Fragments without function bodies have + # empty lists (zero capnp overhead). + irFunctions @27 :List(IR.Function); + irBlocks @28 :List(IR.Block); + irInstructions @29 :List(IR.Instruction); + irObjects @30 :List(IR.Object); + irSwitchCasesRemoved @31 :Void; # Removed: switch cases are now IRStructure entities + irStructures @34 :List(IR.Structure); + irEntityPool @32 :List(UInt64); # Shared entity ID pool for all IR entities + irIntPool @33 :List(Int64); # Shared integer/constant pool } struct Compilation @0xc8b5fa5dd0739e82 { diff --git a/lib/RPC.capnp.c++ b/lib/RPC.capnp.c++ new file mode 100644 index 000000000..a527c8e93 --- /dev/null +++ b/lib/RPC.capnp.c++ @@ -0,0 +1,1960 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: RPC.capnp + +#include "RPC.capnp.h" + +namespace capnp { +namespace schemas { +static const ::capnp::_::AlignedData<49> b_de297748edec6a08 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 8, 106, 236, 237, 72, 119, 41, 222, + 10, 0, 0, 0, 2, 0, 0, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 55, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 73, 110, 99, 108, 117, 100, + 101, 80, 97, 116, 104, 76, 111, 99, + 97, 116, 105, 111, 110, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 0, 0, 0, + 21, 0, 0, 0, 31, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 130, 0, 0, 0, + 57, 0, 0, 0, 31, 0, 0, 0, + 97, 98, 115, 111, 108, 117, 116, 101, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 74, 0, 0, 0, + 97, 98, 115, 111, 108, 117, 116, 101, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 121, 115, 114, 111, 111, 116, 82, + 101, 108, 97, 116, 105, 118, 101, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 138, 0, 0, 0, + 115, 121, 115, 114, 111, 111, 116, 95, + 114, 101, 108, 97, 116, 105, 118, 101, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_de297748edec6a08 = b_de297748edec6a08.words; +#if !CAPNP_LITE +static const uint16_t m_de297748edec6a08[] = {0, 1}; +const ::capnp::_::RawSchema s_de297748edec6a08 = { + 0xde297748edec6a08, b_de297748edec6a08.words, 49, nullptr, m_de297748edec6a08, + 0, 2, nullptr, nullptr, nullptr, { &s_de297748edec6a08, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +CAPNP_DEFINE_ENUM(IncludePathLocation_de297748edec6a08, de297748edec6a08); +static const ::capnp::_::AlignedData<49> b_8b7f7dfed6973665 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 101, 54, 151, 214, 254, 125, 127, 139, + 10, 0, 0, 0, 1, 0, 1, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 178, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 73, 110, 99, 108, 117, 100, + 101, 80, 97, 116, 104, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 100, 105, 114, 101, 99, 116, 111, 114, + 121, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 111, 99, 97, 116, 105, 111, 110, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 8, 106, 236, 237, 72, 119, 41, 222, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8b7f7dfed6973665 = b_8b7f7dfed6973665.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_8b7f7dfed6973665[] = { + &s_de297748edec6a08, +}; +static const uint16_t m_8b7f7dfed6973665[] = {0, 1}; +static const uint16_t i_8b7f7dfed6973665[] = {0, 1}; +const ::capnp::_::RawSchema s_8b7f7dfed6973665 = { + 0x8b7f7dfed6973665, b_8b7f7dfed6973665.words, 49, d_8b7f7dfed6973665, m_8b7f7dfed6973665, + 1, 2, i_8b7f7dfed6973665, nullptr, nullptr, { &s_8b7f7dfed6973665, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<250> b_ab30180088262c95 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 149, 44, 38, 136, 0, 24, 48, 171, + 10, 0, 0, 0, 1, 0, 0, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 13, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 223, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 67, 111, 109, 112, 105, 108, + 101, 67, 111, 109, 109, 97, 110, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 52, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 1, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 1, 0, 0, 3, 0, 1, 0, + 104, 1, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 1, 0, 0, 3, 0, 1, 0, + 112, 1, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 1, 0, 0, 138, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 1, 0, 0, 3, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 162, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 1, 0, 0, 3, 0, 1, 0, + 136, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 1, 0, 0, 218, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 1, 0, 0, 3, 0, 1, 0, + 152, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 1, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 1, 0, 0, 3, 0, 1, 0, + 164, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 161, 1, 0, 0, 178, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 164, 1, 0, 0, 3, 0, 1, 0, + 176, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 173, 1, 0, 0, 154, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 1, 0, 0, 3, 0, 1, 0, + 204, 1, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 1, 0, 0, 138, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 204, 1, 0, 0, 3, 0, 1, 0, + 232, 1, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 229, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 1, 0, 0, 3, 0, 1, 0, + 0, 2, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 253, 1, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 252, 1, 0, 0, 3, 0, 1, 0, + 24, 2, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 2, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 20, 2, 0, 0, 3, 0, 1, 0, + 32, 2, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 2, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 3, 0, 1, 0, + 40, 2, 0, 0, 2, 0, 1, 0, + 115, 111, 117, 114, 99, 101, 80, 97, + 116, 104, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 109, 112, 105, 108, 101, 114, + 80, 97, 116, 104, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 119, 111, 114, 107, 105, 110, 103, 68, + 105, 114, 101, 99, 116, 111, 114, 121, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 121, 115, 116, 101, 109, 82, 111, + 111, 116, 68, 105, 114, 101, 99, 116, + 111, 114, 121, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 121, 115, 116, 101, 109, 82, 111, + 111, 116, 73, 110, 99, 108, 117, 100, + 101, 68, 105, 114, 101, 99, 116, 111, + 114, 121, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 115, 111, 117, 114, 99, 101, + 68, 105, 114, 101, 99, 116, 111, 114, + 121, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 115, 116, 97, 108, 108, 97, + 116, 105, 111, 110, 68, 105, 114, 101, + 99, 116, 111, 114, 121, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 121, 115, 116, 101, 109, 73, 110, + 99, 108, 117, 100, 101, 80, 97, 116, + 104, 115, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 101, 54, 151, 214, 254, 125, 127, 139, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 115, 101, 114, 73, 110, 99, 108, + 117, 100, 101, 80, 97, 116, 104, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 101, 54, 151, 214, 254, 125, 127, 139, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 114, 97, 109, 101, 119, 111, 114, + 107, 80, 97, 116, 104, 115, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 101, 54, 151, 214, 254, 125, 127, 139, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 114, 103, 117, 109, 101, 110, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 97, 114, 103, 101, 116, 84, 114, + 105, 112, 108, 101, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 117, 120, 84, 97, 114, 103, 101, + 116, 84, 114, 105, 112, 108, 101, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ab30180088262c95 = b_ab30180088262c95.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ab30180088262c95[] = { + &s_8b7f7dfed6973665, +}; +static const uint16_t m_ab30180088262c95[] = {10, 12, 1, 9, 6, 5, 0, 7, 3, 4, 11, 8, 2}; +static const uint16_t i_ab30180088262c95[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; +const ::capnp::_::RawSchema s_ab30180088262c95 = { + 0xab30180088262c95, b_ab30180088262c95.words, 250, d_ab30180088262c95, m_ab30180088262c95, + 1, 13, i_ab30180088262c95, nullptr, nullptr, { &s_ab30180088262c95, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<47> b_df7bccc629d6dcf9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 249, 220, 214, 41, 198, 204, 123, 223, + 10, 0, 0, 0, 1, 0, 1, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 170, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 85, 112, 112, 101, 114, 66, + 111, 117, 110, 100, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 118, 97, 108, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 102, 102, 115, 101, 116, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_df7bccc629d6dcf9 = b_df7bccc629d6dcf9.words; +#if !CAPNP_LITE +static const uint16_t m_df7bccc629d6dcf9[] = {1, 0}; +static const uint16_t i_df7bccc629d6dcf9[] = {0, 1}; +const ::capnp::_::RawSchema s_df7bccc629d6dcf9 = { + 0xdf7bccc629d6dcf9, b_df7bccc629d6dcf9.words, 47, nullptr, m_df7bccc629d6dcf9, + 0, 2, i_df7bccc629d6dcf9, nullptr, nullptr, { &s_df7bccc629d6dcf9, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_b9ff75e040124cb3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 179, 76, 18, 64, 224, 117, 255, 185, + 10, 0, 0, 0, 1, 0, 2, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 186, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 84, 111, 107, 101, 110, 67, + 111, 110, 116, 101, 120, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 112, 97, 114, 101, 110, 116, 73, 110, + 100, 101, 120, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 116, 105, 116, 121, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b9ff75e040124cb3 = b_b9ff75e040124cb3.words; +#if !CAPNP_LITE +static const uint16_t m_b9ff75e040124cb3[] = {1, 0}; +static const uint16_t i_b9ff75e040124cb3[] = {0, 1}; +const ::capnp::_::RawSchema s_b9ff75e040124cb3 = { + 0xb9ff75e040124cb3, b_b9ff75e040124cb3.words, 49, nullptr, m_b9ff75e040124cb3, + 0, 2, i_b9ff75e040124cb3, nullptr, nullptr, { &s_b9ff75e040124cb3, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<91> b_987f05f6a48636d5 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 213, 54, 134, 164, 246, 5, 127, 152, + 10, 0, 0, 0, 1, 0, 0, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 122, 0, 0, 0, + 25, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 70, 105, 108, 101, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 1, 0, + 104, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 0, 0, 0, 3, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 152, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 3, 0, 1, 0, + 176, 0, 0, 0, 2, 0, 1, 0, + 100, 97, 116, 97, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 75, 105, 110, + 100, 115, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 79, 102, 102, + 115, 101, 116, 115, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 111, 108, 79, 102, 102, 115, 101, + 116, 115, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 249, 220, 214, 41, 198, 204, 123, 223, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_987f05f6a48636d5 = b_987f05f6a48636d5.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_987f05f6a48636d5[] = { + &s_df7bccc629d6dcf9, +}; +static const uint16_t m_987f05f6a48636d5[] = {0, 3, 1, 2}; +static const uint16_t i_987f05f6a48636d5[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_987f05f6a48636d5 = { + 0x987f05f6a48636d5, b_987f05f6a48636d5.words, 91, d_987f05f6a48636d5, m_987f05f6a48636d5, + 1, 4, i_987f05f6a48636d5, nullptr, nullptr, { &s_987f05f6a48636d5, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<47> b_fd1022cb187f18f8 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 248, 24, 127, 24, 203, 34, 16, 253, + 10, 0, 0, 0, 1, 0, 1, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 154, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 70, 105, 108, 101, 73, 110, + 102, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 105, 100, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 116, 104, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_fd1022cb187f18f8 = b_fd1022cb187f18f8.words; +#if !CAPNP_LITE +static const uint16_t m_fd1022cb187f18f8[] = {0, 1}; +static const uint16_t i_fd1022cb187f18f8[] = {0, 1}; +const ::capnp::_::RawSchema s_fd1022cb187f18f8 = { + 0xfd1022cb187f18f8, b_fd1022cb187f18f8.words, 47, nullptr, m_fd1022cb187f18f8, + 0, 2, i_fd1022cb187f18f8, nullptr, nullptr, { &s_fd1022cb187f18f8, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<66> b_d023961e5f656717 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 23, 103, 101, 95, 30, 150, 35, 208, + 10, 0, 0, 0, 1, 0, 2, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 78, 101, 115, 116, 101, 100, + 70, 114, 97, 103, 109, 101, 110, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 0, 0, 194, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 84, 0, 0, 0, 3, 0, 1, 0, + 96, 0, 0, 0, 2, 0, 1, 0, + 105, 100, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 80, 97, 114, 115, 101, + 100, 84, 111, 107, 101, 110, 115, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 102, 102, 115, 101, 116, 73, 110, + 80, 97, 114, 115, 101, 100, 84, 111, + 107, 101, 110, 76, 105, 115, 116, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d023961e5f656717 = b_d023961e5f656717.words; +#if !CAPNP_LITE +static const uint16_t m_d023961e5f656717[] = {0, 1, 2}; +static const uint16_t i_d023961e5f656717[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_d023961e5f656717 = { + 0xd023961e5f656717, b_d023961e5f656717.words, 66, nullptr, m_d023961e5f656717, + 0, 3, i_d023961e5f656717, nullptr, nullptr, { &s_d023961e5f656717, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<721> b_e5f27760091f9a3a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 58, 154, 31, 9, 96, 119, 242, 229, + 10, 0, 0, 0, 1, 0, 4, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 30, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 154, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 70, 114, 97, 103, 109, 101, + 110, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 140, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 197, 3, 0, 0, 138, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 3, 0, 0, 3, 0, 1, 0, + 212, 3, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 3, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 3, 0, 0, 3, 0, 1, 0, + 236, 3, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 3, 0, 0, 138, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 3, 0, 0, 3, 0, 1, 0, + 248, 3, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 245, 3, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 244, 3, 0, 0, 3, 0, 1, 0, + 0, 4, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 253, 3, 0, 0, 170, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 3, 0, 1, 0, + 28, 4, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 4, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 4, 0, 0, 3, 0, 1, 0, + 52, 4, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 4, 0, 0, 26, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 60, 4, 0, 0, 3, 0, 1, 0, + 88, 4, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 85, 4, 0, 0, 202, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 4, 0, 0, 3, 0, 1, 0, + 120, 4, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 4, 0, 0, 162, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 4, 0, 0, 3, 0, 1, 0, + 148, 4, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 4, 0, 0, 210, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 4, 0, 0, 3, 0, 1, 0, + 180, 4, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 177, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 4, 0, 0, 3, 0, 1, 0, + 188, 4, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 185, 4, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 4, 0, 0, 3, 0, 1, 0, + 212, 4, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 4, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 4, 0, 0, 3, 0, 1, 0, + 236, 4, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 4, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 4, 0, 0, 3, 0, 1, 0, + 4, 5, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 5, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 3, 0, 1, 0, + 28, 5, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 5, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 5, 0, 0, 3, 0, 1, 0, + 36, 5, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 5, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 5, 0, 0, 3, 0, 1, 0, + 72, 5, 0, 0, 2, 0, 1, 0, + 17, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 5, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 5, 0, 0, 3, 0, 1, 0, + 108, 5, 0, 0, 2, 0, 1, 0, + 18, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 5, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 5, 0, 0, 3, 0, 1, 0, + 144, 5, 0, 0, 2, 0, 1, 0, + 19, 0, 0, 0, 15, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 5, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 5, 0, 0, 3, 0, 1, 0, + 180, 5, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 20, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 177, 5, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 180, 5, 0, 0, 3, 0, 1, 0, + 208, 5, 0, 0, 2, 0, 1, 0, + 21, 0, 0, 0, 17, 0, 0, 0, + 0, 0, 1, 0, 21, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 5, 0, 0, 186, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 5, 0, 0, 3, 0, 1, 0, + 236, 5, 0, 0, 2, 0, 1, 0, + 22, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 5, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 5, 0, 0, 3, 0, 1, 0, + 8, 6, 0, 0, 2, 0, 1, 0, + 23, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 1, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 6, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 6, 0, 0, 3, 0, 1, 0, + 32, 6, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 20, 0, 0, 0, + 0, 0, 1, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 6, 0, 0, 162, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 6, 0, 0, 3, 0, 1, 0, + 60, 6, 0, 0, 2, 0, 1, 0, + 25, 0, 0, 0, 21, 0, 0, 0, + 0, 0, 1, 0, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 57, 6, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 56, 6, 0, 0, 3, 0, 1, 0, + 84, 6, 0, 0, 2, 0, 1, 0, + 26, 0, 0, 0, 22, 0, 0, 0, + 0, 0, 1, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 81, 6, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 80, 6, 0, 0, 3, 0, 1, 0, + 108, 6, 0, 0, 2, 0, 1, 0, + 27, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 1, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 6, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 6, 0, 0, 3, 0, 1, 0, + 132, 6, 0, 0, 2, 0, 1, 0, + 28, 0, 0, 0, 24, 0, 0, 0, + 0, 0, 1, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 6, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 6, 0, 0, 3, 0, 1, 0, + 156, 6, 0, 0, 2, 0, 1, 0, + 29, 0, 0, 0, 25, 0, 0, 0, + 0, 0, 1, 0, 29, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 6, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 6, 0, 0, 3, 0, 1, 0, + 180, 6, 0, 0, 2, 0, 1, 0, + 30, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 1, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 177, 6, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 6, 0, 0, 3, 0, 1, 0, + 204, 6, 0, 0, 2, 0, 1, 0, + 31, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 6, 0, 0, 170, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 204, 6, 0, 0, 3, 0, 1, 0, + 216, 6, 0, 0, 2, 0, 1, 0, + 33, 0, 0, 0, 27, 0, 0, 0, + 0, 0, 1, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 213, 6, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 212, 6, 0, 0, 3, 0, 1, 0, + 240, 6, 0, 0, 2, 0, 1, 0, + 34, 0, 0, 0, 28, 0, 0, 0, + 0, 0, 1, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 6, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 6, 0, 0, 3, 0, 1, 0, + 8, 7, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 29, 0, 0, 0, + 0, 0, 1, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 7, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 7, 0, 0, 3, 0, 1, 0, + 32, 7, 0, 0, 2, 0, 1, 0, + 112, 97, 114, 101, 110, 116, 70, 114, + 97, 103, 109, 101, 110, 116, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 70, 114, + 97, 103, 109, 101, 110, 116, 115, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 23, 103, 101, 95, 30, 150, 35, 208, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 105, 114, 115, 116, 70, 105, 108, + 101, 84, 111, 107, 101, 110, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 97, 115, 116, 70, 105, 108, 101, + 84, 111, 107, 101, 110, 73, 100, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 112, 76, 101, 118, 101, 108, + 68, 101, 99, 108, 97, 114, 97, 116, + 105, 111, 110, 115, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 112, 76, 101, 118, 101, 108, + 77, 97, 99, 114, 111, 115, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 97, 99, 114, 111, 84, 111, 107, + 101, 110, 73, 110, 100, 101, 120, 84, + 111, 80, 97, 114, 115, 101, 100, 84, + 111, 107, 101, 110, 79, 102, 102, 115, + 101, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 97, 99, 114, 111, 84, 111, 107, + 101, 110, 73, 110, 100, 101, 120, 84, + 111, 77, 97, 99, 114, 111, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 114, 115, 101, 100, 84, 111, + 107, 101, 110, 67, 111, 110, 116, 101, + 120, 116, 115, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 179, 76, 18, 64, 224, 117, 255, 185, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 114, 115, 101, 100, 84, 111, + 107, 101, 110, 67, 111, 110, 116, 101, + 120, 116, 79, 102, 102, 115, 101, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 68, 97, 116, + 97, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 79, 102, 102, + 115, 101, 116, 115, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 75, 105, 110, + 100, 115, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 101, 114, 105, 118, 101, 100, 84, + 111, 107, 101, 110, 73, 100, 115, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 108, 97, 116, 101, 100, 69, + 110, 116, 105, 116, 121, 73, 100, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 73, 100, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 101, 99, 108, 115, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 182, 237, 250, 31, 118, 121, 88, 251, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 109, 116, 115, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 50, 154, 222, 250, 48, 125, 18, 145, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 116, 116, 114, 115, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 243, 169, 45, 102, 70, 7, 183, 229, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 97, 99, 114, 111, 115, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 255, 238, 242, 139, 251, 87, 129, 248, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 109, 112, 108, 97, 116, 101, + 65, 114, 103, 117, 109, 101, 110, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 103, 47, 153, 1, 173, 125, 18, 181, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 109, 112, 108, 97, 116, 101, + 80, 97, 114, 97, 109, 101, 116, 101, + 114, 76, 105, 115, 116, 115, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 222, 253, 146, 186, 106, 78, 13, 238, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 88, 88, 66, 97, 115, 101, 83, + 112, 101, 99, 105, 102, 105, 101, 114, + 115, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 159, 233, 107, 171, 36, 64, 14, 142, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 101, 115, 105, 103, 110, 97, 116, + 111, 114, 115, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 158, 51, 18, 216, 149, 213, 162, 143, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 88, 88, 67, 116, 111, 114, 73, + 110, 105, 116, 105, 97, 108, 105, 122, + 101, 114, 115, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 64, 112, 21, 161, 225, 44, 186, 150, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 76, 105, 115, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 76, 105, + 115, 116, 115, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 70, 117, 110, 99, 116, 105, + 111, 110, 115, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 16, 134, 33, 89, 162, 49, 190, 230, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 66, 108, 111, 99, 107, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 38, 75, 201, 188, 134, 19, 20, 177, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 73, 110, 115, 116, 114, 117, + 99, 116, 105, 111, 110, 115, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 43, 150, 217, 54, 25, 49, 187, 198, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 79, 98, 106, 101, 99, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 107, 3, 220, 253, 107, 92, 98, 167, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 83, 119, 105, 116, 99, 104, + 67, 97, 115, 101, 115, 82, 101, 109, + 111, 118, 101, 100, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 69, 110, 116, 105, 116, 121, + 80, 111, 111, 108, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 73, 110, 116, 80, 111, 111, + 108, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 114, 83, 116, 114, 117, 99, 116, + 117, 114, 101, 115, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 86, 16, 243, 233, 194, 183, 168, 212, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e5f27760091f9a3a = b_e5f27760091f9a3a.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_e5f27760091f9a3a[] = { + &s_8e0e4024ab6be99f, + &s_8fa2d595d812339e, + &s_91127d30fade9a32, + &s_96ba2ce1a1157040, + &s_a7625c6bfddc036b, + &s_b1141386bcc94b26, + &s_b5127dad01992f67, + &s_b9ff75e040124cb3, + &s_c6bb311936d9962b, + &s_d023961e5f656717, + &s_d4a8b7c2e9f31056, + &s_e5b70746662da9f3, + &s_e6be31a259218610, + &s_ee0d4e6aba92fdde, + &s_f88157fb8bf2eeff, + &s_fb5879761ffaedb6, +}; +static const uint16_t m_e5f27760091f9a3a[] = {18, 22, 24, 15, 16, 13, 23, 2, 28, 32, 27, 29, 33, 30, 34, 31, 3, 7, 6, 19, 1, 0, 9, 8, 14, 17, 20, 21, 25, 10, 12, 11, 4, 5, 26}; +static const uint16_t i_e5f27760091f9a3a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34}; +const ::capnp::_::RawSchema s_e5f27760091f9a3a = { + 0xe5f27760091f9a3a, b_e5f27760091f9a3a.words, 721, d_e5f27760091f9a3a, m_e5f27760091f9a3a, + 16, 35, i_e5f27760091f9a3a, nullptr, nullptr, { &s_e5f27760091f9a3a, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<148> b_c8b5fa5dd0739e82 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 130, 158, 115, 208, 93, 250, 181, 200, + 10, 0, 0, 0, 1, 0, 1, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 6, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 178, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 143, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 67, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 28, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 180, 0, 0, 0, 3, 0, 1, 0, + 208, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 0, 0, 0, 3, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 0, 0, 0, 3, 0, 1, 0, + 252, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 249, 0, 0, 0, 162, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 252, 0, 0, 0, 3, 0, 1, 0, + 24, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 1, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 20, 1, 0, 0, 3, 0, 1, 0, + 48, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 1, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 1, 0, 0, 3, 0, 1, 0, + 56, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 1, 0, 0, 3, 0, 1, 0, + 60, 1, 0, 0, 2, 0, 1, 0, + 102, 114, 97, 103, 109, 101, 110, 116, + 73, 100, 115, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 105, 108, 101, 73, 100, 115, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 117, 105, 108, 116, 105, 110, 77, + 97, 99, 114, 111, 73, 100, 115, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 109, 109, 97, 110, 100, 76, + 105, 110, 101, 77, 97, 99, 114, 111, + 73, 100, 115, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 97, 99, 114, 111, 73, 100, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 97, 105, 110, 70, 105, 108, 101, + 73, 100, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 109, 109, 97, 110, 100, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 149, 44, 38, 136, 0, 24, 48, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c8b5fa5dd0739e82 = b_c8b5fa5dd0739e82.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c8b5fa5dd0739e82[] = { + &s_ab30180088262c95, +}; +static const uint16_t m_c8b5fa5dd0739e82[] = {2, 6, 3, 1, 0, 4, 5}; +static const uint16_t i_c8b5fa5dd0739e82[] = {0, 1, 2, 3, 4, 5, 6}; +const ::capnp::_::RawSchema s_c8b5fa5dd0739e82 = { + 0xc8b5fa5dd0739e82, b_c8b5fa5dd0739e82.words, 148, d_c8b5fa5dd0739e82, m_c8b5fa5dd0739e82, + 1, 7, i_c8b5fa5dd0739e82, nullptr, nullptr, { &s_c8b5fa5dd0739e82, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<149> b_d2d91de1b5fe2e03 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 3, 46, 254, 181, 225, 29, 217, 210, + 10, 0, 0, 0, 1, 0, 0, 0, + 10, 7, 6, 69, 254, 255, 227, 220, + 7, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 122, 0, 0, 0, + 25, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 143, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 82, 80, 67, 46, 99, 97, 112, 110, + 112, 58, 84, 121, 112, 101, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 28, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 0, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 0, 0, 0, 3, 0, 1, 0, + 212, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 0, 0, 0, 194, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 212, 0, 0, 0, 3, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 0, 0, 0, 3, 0, 1, 0, + 248, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 245, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 244, 0, 0, 0, 3, 0, 1, 0, + 16, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 1, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 0, 0, 3, 0, 1, 0, + 40, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 1, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 1, 0, 0, 3, 0, 1, 0, + 64, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 61, 1, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 56, 1, 0, 0, 3, 0, 1, 0, + 68, 1, 0, 0, 2, 0, 1, 0, + 116, 121, 112, 101, 84, 111, 107, 101, + 110, 67, 111, 110, 116, 101, 120, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 179, 76, 18, 64, 224, 117, 255, 185, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 121, 112, 101, 84, 111, 107, 101, + 110, 67, 111, 110, 116, 101, 120, 116, + 79, 102, 102, 115, 101, 116, 115, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 68, 97, 116, + 97, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 79, 102, 102, + 115, 101, 116, 115, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 111, 107, 101, 110, 75, 105, 110, + 100, 115, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 108, 97, 116, 101, 100, 69, + 110, 116, 105, 116, 121, 73, 100, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 121, 112, 101, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 215, 63, 27, 188, 8, 232, 57, 215, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d2d91de1b5fe2e03 = b_d2d91de1b5fe2e03.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_d2d91de1b5fe2e03[] = { + &s_b9ff75e040124cb3, + &s_d739e808bc1b3fd7, +}; +static const uint16_t m_d2d91de1b5fe2e03[] = {5, 2, 4, 3, 6, 1, 0}; +static const uint16_t i_d2d91de1b5fe2e03[] = {0, 1, 2, 3, 4, 5, 6}; +const ::capnp::_::RawSchema s_d2d91de1b5fe2e03 = { + 0xd2d91de1b5fe2e03, b_d2d91de1b5fe2e03.words, 149, d_d2d91de1b5fe2e03, m_d2d91de1b5fe2e03, + 2, 7, i_d2d91de1b5fe2e03, nullptr, nullptr, { &s_d2d91de1b5fe2e03, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +} // namespace schemas +} // namespace capnp + +// ======================================================================================= + +namespace mx { +namespace rpc { + +// IncludePath +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t IncludePath::_capnpPrivate::dataWordSize; +constexpr uint16_t IncludePath::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind IncludePath::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* IncludePath::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// CompileCommand +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t CompileCommand::_capnpPrivate::dataWordSize; +constexpr uint16_t CompileCommand::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind CompileCommand::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* CompileCommand::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// UpperBound +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t UpperBound::_capnpPrivate::dataWordSize; +constexpr uint16_t UpperBound::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind UpperBound::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* UpperBound::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// TokenContext +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t TokenContext::_capnpPrivate::dataWordSize; +constexpr uint16_t TokenContext::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind TokenContext::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TokenContext::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// File +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t File::_capnpPrivate::dataWordSize; +constexpr uint16_t File::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind File::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* File::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// FileInfo +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t FileInfo::_capnpPrivate::dataWordSize; +constexpr uint16_t FileInfo::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind FileInfo::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* FileInfo::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// NestedFragment +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t NestedFragment::_capnpPrivate::dataWordSize; +constexpr uint16_t NestedFragment::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind NestedFragment::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* NestedFragment::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// Fragment +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Fragment::_capnpPrivate::dataWordSize; +constexpr uint16_t Fragment::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Fragment::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Fragment::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// Compilation +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Compilation::_capnpPrivate::dataWordSize; +constexpr uint16_t Compilation::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Compilation::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Compilation::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// Type +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t Type::_capnpPrivate::dataWordSize; +constexpr uint16_t Type::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind Type::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* Type::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + + +} // namespace +} // namespace + diff --git a/lib/RPC.capnp.h b/lib/RPC.capnp.h new file mode 100644 index 000000000..db81bbed6 --- /dev/null +++ b/lib/RPC.capnp.h @@ -0,0 +1,4086 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: RPC.capnp + +#pragma once + +#include +#include + +#ifndef CAPNP_VERSION +#error "CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?" +#elif CAPNP_VERSION != 1001000 +#error "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." +#endif + +#include "AST.capnp.h" +#include "IR.capnp.h" + +CAPNP_BEGIN_HEADER + +namespace capnp { +namespace schemas { + +CAPNP_DECLARE_SCHEMA(de297748edec6a08); +enum class IncludePathLocation_de297748edec6a08: uint16_t { + ABSOLUTE, + SYSROOT_RELATIVE, +}; +CAPNP_DECLARE_ENUM(IncludePathLocation, de297748edec6a08); +CAPNP_DECLARE_SCHEMA(8b7f7dfed6973665); +CAPNP_DECLARE_SCHEMA(ab30180088262c95); +CAPNP_DECLARE_SCHEMA(df7bccc629d6dcf9); +CAPNP_DECLARE_SCHEMA(b9ff75e040124cb3); +CAPNP_DECLARE_SCHEMA(987f05f6a48636d5); +CAPNP_DECLARE_SCHEMA(fd1022cb187f18f8); +CAPNP_DECLARE_SCHEMA(d023961e5f656717); +CAPNP_DECLARE_SCHEMA(e5f27760091f9a3a); +CAPNP_DECLARE_SCHEMA(c8b5fa5dd0739e82); +CAPNP_DECLARE_SCHEMA(d2d91de1b5fe2e03); + +} // namespace schemas +} // namespace capnp + +namespace mx { +namespace rpc { + +typedef ::capnp::schemas::IncludePathLocation_de297748edec6a08 IncludePathLocation; + +struct IncludePath { + IncludePath() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8b7f7dfed6973665, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct CompileCommand { + CompileCommand() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ab30180088262c95, 0, 13) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct UpperBound { + UpperBound() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(df7bccc629d6dcf9, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TokenContext { + TokenContext() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b9ff75e040124cb3, 2, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct File { + File() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(987f05f6a48636d5, 0, 4) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct FileInfo { + FileInfo() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(fd1022cb187f18f8, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct NestedFragment { + NestedFragment() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d023961e5f656717, 2, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct Fragment { + Fragment() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e5f27760091f9a3a, 4, 30) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct Compilation { + Compilation() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c8b5fa5dd0739e82, 1, 6) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct Type { + Type() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d2d91de1b5fe2e03, 0, 7) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +// ======================================================================================= + +class IncludePath::Reader { +public: + typedef IncludePath Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasDirectory() const; + inline ::capnp::Text::Reader getDirectory() const; + + inline ::mx::rpc::IncludePathLocation getLocation() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class IncludePath::Builder { +public: + typedef IncludePath Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasDirectory(); + inline ::capnp::Text::Builder getDirectory(); + inline void setDirectory( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initDirectory(unsigned int size); + inline void adoptDirectory(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownDirectory(); + + inline ::mx::rpc::IncludePathLocation getLocation(); + inline void setLocation( ::mx::rpc::IncludePathLocation value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class IncludePath::Pipeline { +public: + typedef IncludePath Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class CompileCommand::Reader { +public: + typedef CompileCommand Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasSourcePath() const; + inline ::capnp::Text::Reader getSourcePath() const; + + inline bool hasCompilerPath() const; + inline ::capnp::Text::Reader getCompilerPath() const; + + inline bool hasWorkingDirectory() const; + inline ::capnp::Text::Reader getWorkingDirectory() const; + + inline bool hasSystemRootDirectory() const; + inline ::capnp::Text::Reader getSystemRootDirectory() const; + + inline bool hasSystemRootIncludeDirectory() const; + inline ::capnp::Text::Reader getSystemRootIncludeDirectory() const; + + inline bool hasResourceDirectory() const; + inline ::capnp::Text::Reader getResourceDirectory() const; + + inline bool hasInstallationDirectory() const; + inline ::capnp::Text::Reader getInstallationDirectory() const; + + inline bool hasSystemIncludePaths() const; + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader getSystemIncludePaths() const; + + inline bool hasUserIncludePaths() const; + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader getUserIncludePaths() const; + + inline bool hasFrameworkPaths() const; + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader getFrameworkPaths() const; + + inline bool hasArguments() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getArguments() const; + + inline bool hasTargetTriple() const; + inline ::capnp::Text::Reader getTargetTriple() const; + + inline bool hasAuxTargetTriple() const; + inline ::capnp::Text::Reader getAuxTargetTriple() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class CompileCommand::Builder { +public: + typedef CompileCommand Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasSourcePath(); + inline ::capnp::Text::Builder getSourcePath(); + inline void setSourcePath( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initSourcePath(unsigned int size); + inline void adoptSourcePath(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownSourcePath(); + + inline bool hasCompilerPath(); + inline ::capnp::Text::Builder getCompilerPath(); + inline void setCompilerPath( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCompilerPath(unsigned int size); + inline void adoptCompilerPath(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownCompilerPath(); + + inline bool hasWorkingDirectory(); + inline ::capnp::Text::Builder getWorkingDirectory(); + inline void setWorkingDirectory( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initWorkingDirectory(unsigned int size); + inline void adoptWorkingDirectory(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownWorkingDirectory(); + + inline bool hasSystemRootDirectory(); + inline ::capnp::Text::Builder getSystemRootDirectory(); + inline void setSystemRootDirectory( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initSystemRootDirectory(unsigned int size); + inline void adoptSystemRootDirectory(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownSystemRootDirectory(); + + inline bool hasSystemRootIncludeDirectory(); + inline ::capnp::Text::Builder getSystemRootIncludeDirectory(); + inline void setSystemRootIncludeDirectory( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initSystemRootIncludeDirectory(unsigned int size); + inline void adoptSystemRootIncludeDirectory(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownSystemRootIncludeDirectory(); + + inline bool hasResourceDirectory(); + inline ::capnp::Text::Builder getResourceDirectory(); + inline void setResourceDirectory( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initResourceDirectory(unsigned int size); + inline void adoptResourceDirectory(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownResourceDirectory(); + + inline bool hasInstallationDirectory(); + inline ::capnp::Text::Builder getInstallationDirectory(); + inline void setInstallationDirectory( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initInstallationDirectory(unsigned int size); + inline void adoptInstallationDirectory(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownInstallationDirectory(); + + inline bool hasSystemIncludePaths(); + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder getSystemIncludePaths(); + inline void setSystemIncludePaths( ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder initSystemIncludePaths(unsigned int size); + inline void adoptSystemIncludePaths(::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>> disownSystemIncludePaths(); + + inline bool hasUserIncludePaths(); + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder getUserIncludePaths(); + inline void setUserIncludePaths( ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder initUserIncludePaths(unsigned int size); + inline void adoptUserIncludePaths(::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>> disownUserIncludePaths(); + + inline bool hasFrameworkPaths(); + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder getFrameworkPaths(); + inline void setFrameworkPaths( ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder initFrameworkPaths(unsigned int size); + inline void adoptFrameworkPaths(::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>> disownFrameworkPaths(); + + inline bool hasArguments(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getArguments(); + inline void setArguments( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setArguments(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initArguments(unsigned int size); + inline void adoptArguments(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownArguments(); + + inline bool hasTargetTriple(); + inline ::capnp::Text::Builder getTargetTriple(); + inline void setTargetTriple( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTargetTriple(unsigned int size); + inline void adoptTargetTriple(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTargetTriple(); + + inline bool hasAuxTargetTriple(); + inline ::capnp::Text::Builder getAuxTargetTriple(); + inline void setAuxTargetTriple( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAuxTargetTriple(unsigned int size); + inline void adoptAuxTargetTriple(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownAuxTargetTriple(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class CompileCommand::Pipeline { +public: + typedef CompileCommand Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class UpperBound::Reader { +public: + typedef UpperBound Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getVal() const; + + inline ::uint32_t getOffset() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class UpperBound::Builder { +public: + typedef UpperBound Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getVal(); + inline void setVal( ::uint32_t value); + + inline ::uint32_t getOffset(); + inline void setOffset( ::uint32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class UpperBound::Pipeline { +public: + typedef UpperBound Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TokenContext::Reader { +public: + typedef TokenContext Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getParentIndex() const; + + inline ::uint64_t getEntityId() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TokenContext::Builder { +public: + typedef TokenContext Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getParentIndex(); + inline void setParentIndex( ::uint32_t value); + + inline ::uint64_t getEntityId(); + inline void setEntityId( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TokenContext::Pipeline { +public: + typedef TokenContext Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class File::Reader { +public: + typedef File Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasData() const; + inline ::capnp::Text::Reader getData() const; + + inline bool hasTokenKinds() const; + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getTokenKinds() const; + + inline bool hasTokenOffsets() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getTokenOffsets() const; + + inline bool hasEolOffsets() const; + inline ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Reader getEolOffsets() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class File::Builder { +public: + typedef File Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasData(); + inline ::capnp::Text::Builder getData(); + inline void setData( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initData(unsigned int size); + inline void adoptData(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownData(); + + inline bool hasTokenKinds(); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder getTokenKinds(); + inline void setTokenKinds( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTokenKinds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder initTokenKinds(unsigned int size); + inline void adoptTokenKinds(::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> disownTokenKinds(); + + inline bool hasTokenOffsets(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getTokenOffsets(); + inline void setTokenOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTokenOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initTokenOffsets(unsigned int size); + inline void adoptTokenOffsets(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownTokenOffsets(); + + inline bool hasEolOffsets(); + inline ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Builder getEolOffsets(); + inline void setEolOffsets( ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Builder initEolOffsets(unsigned int size); + inline void adoptEolOffsets(::capnp::Orphan< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>> disownEolOffsets(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class File::Pipeline { +public: + typedef File Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class FileInfo::Reader { +public: + typedef FileInfo Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getId() const; + + inline bool hasPath() const; + inline ::capnp::Text::Reader getPath() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class FileInfo::Builder { +public: + typedef FileInfo Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getId(); + inline void setId( ::uint64_t value); + + inline bool hasPath(); + inline ::capnp::Text::Builder getPath(); + inline void setPath( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPath(unsigned int size); + inline void adoptPath(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPath(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class FileInfo::Pipeline { +public: + typedef FileInfo Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class NestedFragment::Reader { +public: + typedef NestedFragment Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getId() const; + + inline ::uint32_t getNumParsedTokens() const; + + inline ::uint32_t getOffsetInParsedTokenList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class NestedFragment::Builder { +public: + typedef NestedFragment Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getId(); + inline void setId( ::uint64_t value); + + inline ::uint32_t getNumParsedTokens(); + inline void setNumParsedTokens( ::uint32_t value); + + inline ::uint32_t getOffsetInParsedTokenList(); + inline void setOffsetInParsedTokenList( ::uint32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class NestedFragment::Pipeline { +public: + typedef NestedFragment Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class Fragment::Reader { +public: + typedef Fragment Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getParentFragmentId() const; + + inline bool hasNestedFragments() const; + inline ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Reader getNestedFragments() const; + + inline ::uint64_t getFirstFileTokenId() const; + + inline ::uint64_t getLastFileTokenId() const; + + inline bool hasTopLevelDeclarations() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTopLevelDeclarations() const; + + inline bool hasTopLevelMacros() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTopLevelMacros() const; + + inline bool hasMacroTokenIndexToParsedTokenOffset() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getMacroTokenIndexToParsedTokenOffset() const; + + inline bool hasMacroTokenIndexToMacroId() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getMacroTokenIndexToMacroId() const; + + inline bool hasParsedTokenContexts() const; + inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader getParsedTokenContexts() const; + + inline bool hasParsedTokenContextOffsets() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getParsedTokenContextOffsets() const; + + inline bool hasTokenData() const; + inline ::capnp::Text::Reader getTokenData() const; + + inline bool hasTokenOffsets() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getTokenOffsets() const; + + inline bool hasTokenKinds() const; + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getTokenKinds() const; + + inline bool hasDerivedTokenIds() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getDerivedTokenIds() const; + + inline bool hasRelatedEntityId() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getRelatedEntityId() const; + + inline ::uint64_t getCompilationId() const; + + inline bool hasDecls() const; + inline ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader getDecls() const; + + inline bool hasStmts() const; + inline ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader getStmts() const; + + inline bool hasAttrs() const; + inline ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader getAttrs() const; + + inline bool hasMacros() const; + inline ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader getMacros() const; + + inline bool hasTemplateArguments() const; + inline ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Reader getTemplateArguments() const; + + inline bool hasTemplateParameterLists() const; + inline ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Reader getTemplateParameterLists() const; + + inline bool hasCXXBaseSpecifiers() const; + inline ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Reader getCXXBaseSpecifiers() const; + + inline bool hasDesignators() const; + inline ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Reader getDesignators() const; + + inline bool hasCXXCtorInitializers() const; + inline ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Reader getCXXCtorInitializers() const; + + inline bool hasTextLists() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getTextLists() const; + + inline bool hasUInt64Lists() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt64Lists() const; + + inline bool hasIrFunctions() const; + inline ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Reader getIrFunctions() const; + + inline bool hasIrBlocks() const; + inline ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Reader getIrBlocks() const; + + inline bool hasIrInstructions() const; + inline ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Reader getIrInstructions() const; + + inline bool hasIrObjects() const; + inline ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Reader getIrObjects() const; + + inline ::capnp::Void getIrSwitchCasesRemoved() const; + + inline bool hasIrEntityPool() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getIrEntityPool() const; + + inline bool hasIrIntPool() const; + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader getIrIntPool() const; + + inline bool hasIrStructures() const; + inline ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Reader getIrStructures() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Fragment::Builder { +public: + typedef Fragment Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getParentFragmentId(); + inline void setParentFragmentId( ::uint64_t value); + + inline bool hasNestedFragments(); + inline ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Builder getNestedFragments(); + inline void setNestedFragments( ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Builder initNestedFragments(unsigned int size); + inline void adoptNestedFragments(::capnp::Orphan< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>> disownNestedFragments(); + + inline ::uint64_t getFirstFileTokenId(); + inline void setFirstFileTokenId( ::uint64_t value); + + inline ::uint64_t getLastFileTokenId(); + inline void setLastFileTokenId( ::uint64_t value); + + inline bool hasTopLevelDeclarations(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTopLevelDeclarations(); + inline void setTopLevelDeclarations( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTopLevelDeclarations(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTopLevelDeclarations(unsigned int size); + inline void adoptTopLevelDeclarations(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTopLevelDeclarations(); + + inline bool hasTopLevelMacros(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTopLevelMacros(); + inline void setTopLevelMacros( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTopLevelMacros(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTopLevelMacros(unsigned int size); + inline void adoptTopLevelMacros(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTopLevelMacros(); + + inline bool hasMacroTokenIndexToParsedTokenOffset(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getMacroTokenIndexToParsedTokenOffset(); + inline void setMacroTokenIndexToParsedTokenOffset( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setMacroTokenIndexToParsedTokenOffset(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initMacroTokenIndexToParsedTokenOffset(unsigned int size); + inline void adoptMacroTokenIndexToParsedTokenOffset(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownMacroTokenIndexToParsedTokenOffset(); + + inline bool hasMacroTokenIndexToMacroId(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getMacroTokenIndexToMacroId(); + inline void setMacroTokenIndexToMacroId( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setMacroTokenIndexToMacroId(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initMacroTokenIndexToMacroId(unsigned int size); + inline void adoptMacroTokenIndexToMacroId(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownMacroTokenIndexToMacroId(); + + inline bool hasParsedTokenContexts(); + inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder getParsedTokenContexts(); + inline void setParsedTokenContexts( ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder initParsedTokenContexts(unsigned int size); + inline void adoptParsedTokenContexts(::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>> disownParsedTokenContexts(); + + inline bool hasParsedTokenContextOffsets(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getParsedTokenContextOffsets(); + inline void setParsedTokenContextOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setParsedTokenContextOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initParsedTokenContextOffsets(unsigned int size); + inline void adoptParsedTokenContextOffsets(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownParsedTokenContextOffsets(); + + inline bool hasTokenData(); + inline ::capnp::Text::Builder getTokenData(); + inline void setTokenData( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTokenData(unsigned int size); + inline void adoptTokenData(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTokenData(); + + inline bool hasTokenOffsets(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getTokenOffsets(); + inline void setTokenOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTokenOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initTokenOffsets(unsigned int size); + inline void adoptTokenOffsets(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownTokenOffsets(); + + inline bool hasTokenKinds(); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder getTokenKinds(); + inline void setTokenKinds( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTokenKinds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder initTokenKinds(unsigned int size); + inline void adoptTokenKinds(::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> disownTokenKinds(); + + inline bool hasDerivedTokenIds(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getDerivedTokenIds(); + inline void setDerivedTokenIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setDerivedTokenIds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initDerivedTokenIds(unsigned int size); + inline void adoptDerivedTokenIds(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownDerivedTokenIds(); + + inline bool hasRelatedEntityId(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getRelatedEntityId(); + inline void setRelatedEntityId( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setRelatedEntityId(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initRelatedEntityId(unsigned int size); + inline void adoptRelatedEntityId(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownRelatedEntityId(); + + inline ::uint64_t getCompilationId(); + inline void setCompilationId( ::uint64_t value); + + inline bool hasDecls(); + inline ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder getDecls(); + inline void setDecls( ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value); + inline void setDecls(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder initDecls(unsigned int size); + inline void adoptDecls(::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> disownDecls(); + + inline bool hasStmts(); + inline ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder getStmts(); + inline void setStmts( ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value); + inline void setStmts(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder initStmts(unsigned int size); + inline void adoptStmts(::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> disownStmts(); + + inline bool hasAttrs(); + inline ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder getAttrs(); + inline void setAttrs( ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value); + inline void setAttrs(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder initAttrs(unsigned int size); + inline void adoptAttrs(::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> disownAttrs(); + + inline bool hasMacros(); + inline ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder getMacros(); + inline void setMacros( ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value); + inline void setMacros(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder initMacros(unsigned int size); + inline void adoptMacros(::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> disownMacros(); + + inline bool hasTemplateArguments(); + inline ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Builder getTemplateArguments(); + inline void setTemplateArguments( ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Builder initTemplateArguments(unsigned int size); + inline void adoptTemplateArguments(::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>> disownTemplateArguments(); + + inline bool hasTemplateParameterLists(); + inline ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Builder getTemplateParameterLists(); + inline void setTemplateParameterLists( ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Builder initTemplateParameterLists(unsigned int size); + inline void adoptTemplateParameterLists(::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>> disownTemplateParameterLists(); + + inline bool hasCXXBaseSpecifiers(); + inline ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Builder getCXXBaseSpecifiers(); + inline void setCXXBaseSpecifiers( ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Builder initCXXBaseSpecifiers(unsigned int size); + inline void adoptCXXBaseSpecifiers(::capnp::Orphan< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>> disownCXXBaseSpecifiers(); + + inline bool hasDesignators(); + inline ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Builder getDesignators(); + inline void setDesignators( ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Builder initDesignators(unsigned int size); + inline void adoptDesignators(::capnp::Orphan< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>> disownDesignators(); + + inline bool hasCXXCtorInitializers(); + inline ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Builder getCXXCtorInitializers(); + inline void setCXXCtorInitializers( ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Builder initCXXCtorInitializers(unsigned int size); + inline void adoptCXXCtorInitializers(::capnp::Orphan< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>> disownCXXCtorInitializers(); + + inline bool hasTextLists(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getTextLists(); + inline void setTextLists( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setTextLists(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initTextLists(unsigned int size); + inline void adoptTextLists(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownTextLists(); + + inline bool hasUInt64Lists(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt64Lists(); + inline void setUInt64Lists( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt64Lists(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt64Lists(unsigned int size); + inline void adoptUInt64Lists(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownUInt64Lists(); + + inline bool hasIrFunctions(); + inline ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Builder getIrFunctions(); + inline void setIrFunctions( ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Builder initIrFunctions(unsigned int size); + inline void adoptIrFunctions(::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>> disownIrFunctions(); + + inline bool hasIrBlocks(); + inline ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Builder getIrBlocks(); + inline void setIrBlocks( ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Builder initIrBlocks(unsigned int size); + inline void adoptIrBlocks(::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>> disownIrBlocks(); + + inline bool hasIrInstructions(); + inline ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Builder getIrInstructions(); + inline void setIrInstructions( ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Builder initIrInstructions(unsigned int size); + inline void adoptIrInstructions(::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>> disownIrInstructions(); + + inline bool hasIrObjects(); + inline ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Builder getIrObjects(); + inline void setIrObjects( ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Builder initIrObjects(unsigned int size); + inline void adoptIrObjects(::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>> disownIrObjects(); + + inline ::capnp::Void getIrSwitchCasesRemoved(); + inline void setIrSwitchCasesRemoved( ::capnp::Void value = ::capnp::VOID); + + inline bool hasIrEntityPool(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getIrEntityPool(); + inline void setIrEntityPool( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setIrEntityPool(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initIrEntityPool(unsigned int size); + inline void adoptIrEntityPool(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownIrEntityPool(); + + inline bool hasIrIntPool(); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder getIrIntPool(); + inline void setIrIntPool( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setIrIntPool(::kj::ArrayPtr value); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder initIrIntPool(unsigned int size); + inline void adoptIrIntPool(::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> disownIrIntPool(); + + inline bool hasIrStructures(); + inline ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Builder getIrStructures(); + inline void setIrStructures( ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Builder initIrStructures(unsigned int size); + inline void adoptIrStructures(::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>> disownIrStructures(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Fragment::Pipeline { +public: + typedef Fragment Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class Compilation::Reader { +public: + typedef Compilation Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasFragmentIds() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFragmentIds() const; + + inline bool hasFileIds() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFileIds() const; + + inline bool hasBuiltinMacroIds() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getBuiltinMacroIds() const; + + inline bool hasCommandLineMacroIds() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getCommandLineMacroIds() const; + + inline bool hasMacroIds() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getMacroIds() const; + + inline ::uint64_t getMainFileId() const; + + inline bool hasCommand() const; + inline ::mx::rpc::CompileCommand::Reader getCommand() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Compilation::Builder { +public: + typedef Compilation Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasFragmentIds(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFragmentIds(); + inline void setFragmentIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFragmentIds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFragmentIds(unsigned int size); + inline void adoptFragmentIds(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFragmentIds(); + + inline bool hasFileIds(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFileIds(); + inline void setFileIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFileIds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFileIds(unsigned int size); + inline void adoptFileIds(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFileIds(); + + inline bool hasBuiltinMacroIds(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getBuiltinMacroIds(); + inline void setBuiltinMacroIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setBuiltinMacroIds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initBuiltinMacroIds(unsigned int size); + inline void adoptBuiltinMacroIds(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownBuiltinMacroIds(); + + inline bool hasCommandLineMacroIds(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getCommandLineMacroIds(); + inline void setCommandLineMacroIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setCommandLineMacroIds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initCommandLineMacroIds(unsigned int size); + inline void adoptCommandLineMacroIds(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownCommandLineMacroIds(); + + inline bool hasMacroIds(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getMacroIds(); + inline void setMacroIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setMacroIds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initMacroIds(unsigned int size); + inline void adoptMacroIds(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownMacroIds(); + + inline ::uint64_t getMainFileId(); + inline void setMainFileId( ::uint64_t value); + + inline bool hasCommand(); + inline ::mx::rpc::CompileCommand::Builder getCommand(); + inline void setCommand( ::mx::rpc::CompileCommand::Reader value); + inline ::mx::rpc::CompileCommand::Builder initCommand(); + inline void adoptCommand(::capnp::Orphan< ::mx::rpc::CompileCommand>&& value); + inline ::capnp::Orphan< ::mx::rpc::CompileCommand> disownCommand(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Compilation::Pipeline { +public: + typedef Compilation Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::mx::rpc::CompileCommand::Pipeline getCommand(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class Type::Reader { +public: + typedef Type Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasTypeTokenContexts() const; + inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader getTypeTokenContexts() const; + + inline bool hasTypeTokenContextOffsets() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getTypeTokenContextOffsets() const; + + inline bool hasTokenData() const; + inline ::capnp::Text::Reader getTokenData() const; + + inline bool hasTokenOffsets() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getTokenOffsets() const; + + inline bool hasTokenKinds() const; + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getTokenKinds() const; + + inline bool hasRelatedEntityId() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getRelatedEntityId() const; + + inline bool hasType() const; + inline ::mx::ast::Type::Reader getType() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class Type::Builder { +public: + typedef Type Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasTypeTokenContexts(); + inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder getTypeTokenContexts(); + inline void setTypeTokenContexts( ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder initTypeTokenContexts(unsigned int size); + inline void adoptTypeTokenContexts(::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>> disownTypeTokenContexts(); + + inline bool hasTypeTokenContextOffsets(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getTypeTokenContextOffsets(); + inline void setTypeTokenContextOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTypeTokenContextOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initTypeTokenContextOffsets(unsigned int size); + inline void adoptTypeTokenContextOffsets(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownTypeTokenContextOffsets(); + + inline bool hasTokenData(); + inline ::capnp::Text::Builder getTokenData(); + inline void setTokenData( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTokenData(unsigned int size); + inline void adoptTokenData(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTokenData(); + + inline bool hasTokenOffsets(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getTokenOffsets(); + inline void setTokenOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTokenOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initTokenOffsets(unsigned int size); + inline void adoptTokenOffsets(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownTokenOffsets(); + + inline bool hasTokenKinds(); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder getTokenKinds(); + inline void setTokenKinds( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTokenKinds(::kj::ArrayPtr value); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder initTokenKinds(unsigned int size); + inline void adoptTokenKinds(::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> disownTokenKinds(); + + inline bool hasRelatedEntityId(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getRelatedEntityId(); + inline void setRelatedEntityId( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setRelatedEntityId(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initRelatedEntityId(unsigned int size); + inline void adoptRelatedEntityId(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownRelatedEntityId(); + + inline bool hasType(); + inline ::mx::ast::Type::Builder getType(); + inline void setType( ::mx::ast::Type::Reader value); + inline ::mx::ast::Type::Builder initType(); + inline void adoptType(::capnp::Orphan< ::mx::ast::Type>&& value); + inline ::capnp::Orphan< ::mx::ast::Type> disownType(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class Type::Pipeline { +public: + typedef Type Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::mx::ast::Type::Pipeline getType(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +// ======================================================================================= + +inline bool IncludePath::Reader::hasDirectory() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool IncludePath::Builder::hasDirectory() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader IncludePath::Reader::getDirectory() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder IncludePath::Builder::getDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void IncludePath::Builder::setDirectory( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder IncludePath::Builder::initDirectory(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void IncludePath::Builder::adoptDirectory( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> IncludePath::Builder::disownDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::mx::rpc::IncludePathLocation IncludePath::Reader::getLocation() const { + return _reader.getDataField< ::mx::rpc::IncludePathLocation>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::mx::rpc::IncludePathLocation IncludePath::Builder::getLocation() { + return _builder.getDataField< ::mx::rpc::IncludePathLocation>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void IncludePath::Builder::setLocation( ::mx::rpc::IncludePathLocation value) { + _builder.setDataField< ::mx::rpc::IncludePathLocation>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool CompileCommand::Reader::hasSourcePath() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasSourcePath() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getSourcePath() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getSourcePath() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setSourcePath( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initSourcePath(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptSourcePath( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownSourcePath() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasCompilerPath() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasCompilerPath() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getCompilerPath() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getCompilerPath() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setCompilerPath( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initCompilerPath(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptCompilerPath( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownCompilerPath() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasWorkingDirectory() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasWorkingDirectory() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getWorkingDirectory() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getWorkingDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setWorkingDirectory( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initWorkingDirectory(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptWorkingDirectory( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownWorkingDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasSystemRootDirectory() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasSystemRootDirectory() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getSystemRootDirectory() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getSystemRootDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setSystemRootDirectory( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initSystemRootDirectory(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptSystemRootDirectory( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownSystemRootDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasSystemRootIncludeDirectory() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasSystemRootIncludeDirectory() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getSystemRootIncludeDirectory() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getSystemRootIncludeDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setSystemRootIncludeDirectory( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initSystemRootIncludeDirectory(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptSystemRootIncludeDirectory( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownSystemRootIncludeDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasResourceDirectory() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasResourceDirectory() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getResourceDirectory() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getResourceDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setResourceDirectory( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initResourceDirectory(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptResourceDirectory( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownResourceDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasInstallationDirectory() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasInstallationDirectory() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getInstallationDirectory() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getInstallationDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setInstallationDirectory( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initInstallationDirectory(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptInstallationDirectory( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownInstallationDirectory() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasSystemIncludePaths() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasSystemIncludePaths() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader CompileCommand::Reader::getSystemIncludePaths() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder CompileCommand::Builder::getSystemIncludePaths() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setSystemIncludePaths( ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder CompileCommand::Builder::initSystemIncludePaths(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptSystemIncludePaths( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>> CompileCommand::Builder::disownSystemIncludePaths() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasUserIncludePaths() const { + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasUserIncludePaths() { + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader CompileCommand::Reader::getUserIncludePaths() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder CompileCommand::Builder::getUserIncludePaths() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setUserIncludePaths( ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder CompileCommand::Builder::initUserIncludePaths(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptUserIncludePaths( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>> CompileCommand::Builder::disownUserIncludePaths() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasFrameworkPaths() const { + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasFrameworkPaths() { + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader CompileCommand::Reader::getFrameworkPaths() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder CompileCommand::Builder::getFrameworkPaths() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setFrameworkPaths( ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>::Builder CompileCommand::Builder::initFrameworkPaths(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptFrameworkPaths( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>> CompileCommand::Builder::disownFrameworkPaths() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::IncludePath, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasArguments() const { + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasArguments() { + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader CompileCommand::Reader::getArguments() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder CompileCommand::Builder::getArguments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setArguments( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline void CompileCommand::Builder::setArguments(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder CompileCommand::Builder::initArguments(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptArguments( + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> CompileCommand::Builder::disownArguments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasTargetTriple() const { + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasTargetTriple() { + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getTargetTriple() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getTargetTriple() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setTargetTriple( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initTargetTriple(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptTargetTriple( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownTargetTriple() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} + +inline bool CompileCommand::Reader::hasAuxTargetTriple() const { + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline bool CompileCommand::Builder::hasAuxTargetTriple() { + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader CompileCommand::Reader::getAuxTargetTriple() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder CompileCommand::Builder::getAuxTargetTriple() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline void CompileCommand::Builder::setAuxTargetTriple( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder CompileCommand::Builder::initAuxTargetTriple(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), size); +} +inline void CompileCommand::Builder::adoptAuxTargetTriple( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> CompileCommand::Builder::disownAuxTargetTriple() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} + +inline ::uint32_t UpperBound::Reader::getVal() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t UpperBound::Builder::getVal() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void UpperBound::Builder::setVal( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t UpperBound::Reader::getOffset() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t UpperBound::Builder::getOffset() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void UpperBound::Builder::setOffset( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t TokenContext::Reader::getParentIndex() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TokenContext::Builder::getParentIndex() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TokenContext::Builder::setParentIndex( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t TokenContext::Reader::getEntityId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TokenContext::Builder::getEntityId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TokenContext::Builder::setEntityId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline bool File::Reader::hasData() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool File::Builder::hasData() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader File::Reader::getData() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder File::Builder::getData() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void File::Builder::setData( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder File::Builder::initData(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void File::Builder::adoptData( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> File::Builder::disownData() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool File::Reader::hasTokenKinds() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool File::Builder::hasTokenKinds() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader File::Reader::getTokenKinds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder File::Builder::getTokenKinds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void File::Builder::setTokenKinds( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void File::Builder::setTokenKinds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder File::Builder::initTokenKinds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void File::Builder::adoptTokenKinds( + ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> File::Builder::disownTokenKinds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool File::Reader::hasTokenOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool File::Builder::hasTokenOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader File::Reader::getTokenOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder File::Builder::getTokenOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void File::Builder::setTokenOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void File::Builder::setTokenOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder File::Builder::initTokenOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void File::Builder::adoptTokenOffsets( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> File::Builder::disownTokenOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool File::Reader::hasEolOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool File::Builder::hasEolOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Reader File::Reader::getEolOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Builder File::Builder::getEolOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void File::Builder::setEolOffsets( ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>::Builder File::Builder::initEolOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void File::Builder::adoptEolOffsets( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>> File::Builder::disownEolOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::UpperBound, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::uint64_t FileInfo::Reader::getId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t FileInfo::Builder::getId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void FileInfo::Builder::setId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool FileInfo::Reader::hasPath() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool FileInfo::Builder::hasPath() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader FileInfo::Reader::getPath() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder FileInfo::Builder::getPath() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void FileInfo::Builder::setPath( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder FileInfo::Builder::initPath(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void FileInfo::Builder::adoptPath( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> FileInfo::Builder::disownPath() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint64_t NestedFragment::Reader::getId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t NestedFragment::Builder::getId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void NestedFragment::Builder::setId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t NestedFragment::Reader::getNumParsedTokens() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t NestedFragment::Builder::getNumParsedTokens() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void NestedFragment::Builder::setNumParsedTokens( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t NestedFragment::Reader::getOffsetInParsedTokenList() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t NestedFragment::Builder::getOffsetInParsedTokenList() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline void NestedFragment::Builder::setOffsetInParsedTokenList( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Fragment::Reader::getParentFragmentId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Fragment::Builder::getParentFragmentId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Fragment::Builder::setParentFragmentId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool Fragment::Reader::hasNestedFragments() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasNestedFragments() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getNestedFragments() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getNestedFragments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setNestedFragments( ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initNestedFragments(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptNestedFragments( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>> Fragment::Builder::disownNestedFragments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::NestedFragment, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint64_t Fragment::Reader::getFirstFileTokenId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Fragment::Builder::getFirstFileTokenId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void Fragment::Builder::setFirstFileTokenId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t Fragment::Reader::getLastFileTokenId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Fragment::Builder::getLastFileTokenId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void Fragment::Builder::setLastFileTokenId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline bool Fragment::Reader::hasTopLevelDeclarations() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTopLevelDeclarations() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getTopLevelDeclarations() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getTopLevelDeclarations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTopLevelDeclarations( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setTopLevelDeclarations(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initTopLevelDeclarations(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTopLevelDeclarations( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownTopLevelDeclarations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasTopLevelMacros() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTopLevelMacros() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getTopLevelMacros() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getTopLevelMacros() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTopLevelMacros( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setTopLevelMacros(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initTopLevelMacros(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTopLevelMacros( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownTopLevelMacros() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasMacroTokenIndexToParsedTokenOffset() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasMacroTokenIndexToParsedTokenOffset() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getMacroTokenIndexToParsedTokenOffset() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getMacroTokenIndexToParsedTokenOffset() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setMacroTokenIndexToParsedTokenOffset( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setMacroTokenIndexToParsedTokenOffset(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initMacroTokenIndexToParsedTokenOffset(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptMacroTokenIndexToParsedTokenOffset( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownMacroTokenIndexToParsedTokenOffset() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasMacroTokenIndexToMacroId() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasMacroTokenIndexToMacroId() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getMacroTokenIndexToMacroId() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getMacroTokenIndexToMacroId() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setMacroTokenIndexToMacroId( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setMacroTokenIndexToMacroId(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initMacroTokenIndexToMacroId(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptMacroTokenIndexToMacroId( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownMacroTokenIndexToMacroId() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasParsedTokenContexts() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasParsedTokenContexts() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getParsedTokenContexts() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getParsedTokenContexts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setParsedTokenContexts( ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initParsedTokenContexts(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptParsedTokenContexts( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>> Fragment::Builder::disownParsedTokenContexts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasParsedTokenContextOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasParsedTokenContextOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getParsedTokenContextOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getParsedTokenContextOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setParsedTokenContextOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setParsedTokenContextOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initParsedTokenContextOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptParsedTokenContextOffsets( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownParsedTokenContextOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasTokenData() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTokenData() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader Fragment::Reader::getTokenData() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder Fragment::Builder::getTokenData() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTokenData( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder Fragment::Builder::initTokenData(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTokenData( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> Fragment::Builder::disownTokenData() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasTokenOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTokenOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getTokenOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getTokenOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTokenOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setTokenOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initTokenOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTokenOffsets( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownTokenOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasTokenKinds() const { + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTokenKinds() { + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getTokenKinds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getTokenKinds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTokenKinds( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setTokenKinds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initTokenKinds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTokenKinds( + ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownTokenKinds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasDerivedTokenIds() const { + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasDerivedTokenIds() { + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getDerivedTokenIds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getDerivedTokenIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setDerivedTokenIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setDerivedTokenIds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initDerivedTokenIds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptDerivedTokenIds( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownDerivedTokenIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasRelatedEntityId() const { + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasRelatedEntityId() { + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getRelatedEntityId() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getRelatedEntityId() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setRelatedEntityId( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setRelatedEntityId(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initRelatedEntityId(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptRelatedEntityId( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownRelatedEntityId() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} + +inline ::uint64_t Fragment::Reader::getCompilationId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Fragment::Builder::getCompilationId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline void Fragment::Builder::setCompilationId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); +} + +inline bool Fragment::Reader::hasDecls() const { + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasDecls() { + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader Fragment::Reader::getDecls() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::getDecls() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setDecls( ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setDecls(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::initDecls(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptDecls( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> Fragment::Builder::disownDecls() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Decl, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasStmts() const { + return !_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasStmts() { + return !_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader Fragment::Reader::getStmts() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::getStmts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setStmts( ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setStmts(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::initStmts(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptStmts( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> Fragment::Builder::disownStmts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Stmt, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasAttrs() const { + return !_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasAttrs() { + return !_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader Fragment::Reader::getAttrs() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::getAttrs() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setAttrs( ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setAttrs(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::initAttrs(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptAttrs( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> Fragment::Builder::disownAttrs() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Attr, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasMacros() const { + return !_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasMacros() { + return !_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader Fragment::Reader::getMacros() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::getMacros() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setMacros( ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setMacros(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder Fragment::Builder::initMacros(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptMacros( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> Fragment::Builder::disownMacros() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::mx::ast::Macro, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasTemplateArguments() const { + return !_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTemplateArguments() { + return !_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getTemplateArguments() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getTemplateArguments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTemplateArguments( ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initTemplateArguments(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTemplateArguments( + ::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>> Fragment::Builder::disownTemplateArguments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateArgument, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasTemplateParameterLists() const { + return !_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTemplateParameterLists() { + return !_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getTemplateParameterLists() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getTemplateParameterLists() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTemplateParameterLists( ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initTemplateParameterLists(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTemplateParameterLists( + ::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>> Fragment::Builder::disownTemplateParameterLists() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::TemplateParameterList, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasCXXBaseSpecifiers() const { + return !_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasCXXBaseSpecifiers() { + return !_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getCXXBaseSpecifiers() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getCXXBaseSpecifiers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setCXXBaseSpecifiers( ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initCXXBaseSpecifiers(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptCXXBaseSpecifiers( + ::capnp::Orphan< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>> Fragment::Builder::disownCXXBaseSpecifiers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXBaseSpecifier, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasDesignators() const { + return !_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasDesignators() { + return !_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getDesignators() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getDesignators() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setDesignators( ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initDesignators(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptDesignators( + ::capnp::Orphan< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>> Fragment::Builder::disownDesignators() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::Designator, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasCXXCtorInitializers() const { + return !_reader.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasCXXCtorInitializers() { + return !_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getCXXCtorInitializers() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getCXXCtorInitializers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setCXXCtorInitializers( ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initCXXCtorInitializers(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptCXXCtorInitializers( + ::capnp::Orphan< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>> Fragment::Builder::disownCXXCtorInitializers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::ast::CXXCtorInitializer, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasTextLists() const { + return !_reader.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasTextLists() { + return !_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader Fragment::Reader::getTextLists() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Fragment::Builder::getTextLists() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setTextLists( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setTextLists(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Fragment::Builder::initTextLists(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptTextLists( + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> Fragment::Builder::disownTextLists() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasUInt64Lists() const { + return !_reader.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasUInt64Lists() { + return !_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getUInt64Lists() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getUInt64Lists() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setUInt64Lists( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setUInt64Lists(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initUInt64Lists(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptUInt64Lists( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownUInt64Lists() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasIrFunctions() const { + return !_reader.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasIrFunctions() { + return !_builder.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getIrFunctions() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getIrFunctions() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setIrFunctions( ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initIrFunctions(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptIrFunctions( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>> Fragment::Builder::disownIrFunctions() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Function, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<23>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasIrBlocks() const { + return !_reader.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasIrBlocks() { + return !_builder.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getIrBlocks() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getIrBlocks() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setIrBlocks( ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initIrBlocks(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptIrBlocks( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>> Fragment::Builder::disownIrBlocks() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Block, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<24>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasIrInstructions() const { + return !_reader.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasIrInstructions() { + return !_builder.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getIrInstructions() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getIrInstructions() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setIrInstructions( ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initIrInstructions(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptIrInstructions( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>> Fragment::Builder::disownIrInstructions() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Instruction, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<25>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasIrObjects() const { + return !_reader.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasIrObjects() { + return !_builder.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getIrObjects() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getIrObjects() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setIrObjects( ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initIrObjects(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptIrObjects( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>> Fragment::Builder::disownIrObjects() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Object, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<26>() * ::capnp::POINTERS)); +} + +inline ::capnp::Void Fragment::Reader::getIrSwitchCasesRemoved() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void Fragment::Builder::getIrSwitchCasesRemoved() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Fragment::Builder::setIrSwitchCasesRemoved( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool Fragment::Reader::hasIrEntityPool() const { + return !_reader.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasIrEntityPool() { + return !_builder.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getIrEntityPool() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getIrEntityPool() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setIrEntityPool( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setIrEntityPool(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initIrEntityPool(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptIrEntityPool( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownIrEntityPool() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<27>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasIrIntPool() const { + return !_reader.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasIrIntPool() { + return !_builder.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader Fragment::Reader::getIrIntPool() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::getIrIntPool() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setIrIntPool( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS), value); +} +inline void Fragment::Builder::setIrIntPool(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder Fragment::Builder::initIrIntPool(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptIrIntPool( + ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> Fragment::Builder::disownIrIntPool() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<28>() * ::capnp::POINTERS)); +} + +inline bool Fragment::Reader::hasIrStructures() const { + return !_reader.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS).isNull(); +} +inline bool Fragment::Builder::hasIrStructures() { + return !_builder.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Reader Fragment::Reader::getIrStructures() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::getIrStructures() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS)); +} +inline void Fragment::Builder::setIrStructures( ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>::Builder Fragment::Builder::initIrStructures(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS), size); +} +inline void Fragment::Builder::adoptIrStructures( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>> Fragment::Builder::disownIrStructures() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::ir::Structure, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<29>() * ::capnp::POINTERS)); +} + +inline bool Compilation::Reader::hasFragmentIds() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool Compilation::Builder::hasFragmentIds() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Compilation::Reader::getFragmentIds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::getFragmentIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Compilation::Builder::setFragmentIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void Compilation::Builder::setFragmentIds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::initFragmentIds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void Compilation::Builder::adoptFragmentIds( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Compilation::Builder::disownFragmentIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool Compilation::Reader::hasFileIds() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool Compilation::Builder::hasFileIds() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Compilation::Reader::getFileIds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::getFileIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Compilation::Builder::setFileIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void Compilation::Builder::setFileIds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::initFileIds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void Compilation::Builder::adoptFileIds( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Compilation::Builder::disownFileIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool Compilation::Reader::hasBuiltinMacroIds() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool Compilation::Builder::hasBuiltinMacroIds() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Compilation::Reader::getBuiltinMacroIds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::getBuiltinMacroIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void Compilation::Builder::setBuiltinMacroIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void Compilation::Builder::setBuiltinMacroIds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::initBuiltinMacroIds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void Compilation::Builder::adoptBuiltinMacroIds( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Compilation::Builder::disownBuiltinMacroIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool Compilation::Reader::hasCommandLineMacroIds() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool Compilation::Builder::hasCommandLineMacroIds() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Compilation::Reader::getCommandLineMacroIds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::getCommandLineMacroIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void Compilation::Builder::setCommandLineMacroIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void Compilation::Builder::setCommandLineMacroIds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::initCommandLineMacroIds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void Compilation::Builder::adoptCommandLineMacroIds( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Compilation::Builder::disownCommandLineMacroIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool Compilation::Reader::hasMacroIds() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool Compilation::Builder::hasMacroIds() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Compilation::Reader::getMacroIds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::getMacroIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void Compilation::Builder::setMacroIds( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void Compilation::Builder::setMacroIds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Compilation::Builder::initMacroIds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void Compilation::Builder::adoptMacroIds( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Compilation::Builder::disownMacroIds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline ::uint64_t Compilation::Reader::getMainFileId() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t Compilation::Builder::getMainFileId() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void Compilation::Builder::setMainFileId( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool Compilation::Reader::hasCommand() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool Compilation::Builder::hasCommand() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::mx::rpc::CompileCommand::Reader Compilation::Reader::getCommand() const { + return ::capnp::_::PointerHelpers< ::mx::rpc::CompileCommand>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::mx::rpc::CompileCommand::Builder Compilation::Builder::getCommand() { + return ::capnp::_::PointerHelpers< ::mx::rpc::CompileCommand>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::mx::rpc::CompileCommand::Pipeline Compilation::Pipeline::getCommand() { + return ::mx::rpc::CompileCommand::Pipeline(_typeless.getPointerField(5)); +} +#endif // !CAPNP_LITE +inline void Compilation::Builder::setCommand( ::mx::rpc::CompileCommand::Reader value) { + ::capnp::_::PointerHelpers< ::mx::rpc::CompileCommand>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::mx::rpc::CompileCommand::Builder Compilation::Builder::initCommand() { + return ::capnp::_::PointerHelpers< ::mx::rpc::CompileCommand>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void Compilation::Builder::adoptCommand( + ::capnp::Orphan< ::mx::rpc::CompileCommand>&& value) { + ::capnp::_::PointerHelpers< ::mx::rpc::CompileCommand>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::mx::rpc::CompileCommand> Compilation::Builder::disownCommand() { + return ::capnp::_::PointerHelpers< ::mx::rpc::CompileCommand>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool Type::Reader::hasTypeTokenContexts() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool Type::Builder::hasTypeTokenContexts() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader Type::Reader::getTypeTokenContexts() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder Type::Builder::getTypeTokenContexts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Type::Builder::setTypeTokenContexts( ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>::Builder Type::Builder::initTypeTokenContexts(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void Type::Builder::adoptTypeTokenContexts( + ::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>> Type::Builder::disownTypeTokenContexts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::mx::rpc::TokenContext, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool Type::Reader::hasTypeTokenContextOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool Type::Builder::hasTypeTokenContextOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader Type::Reader::getTypeTokenContextOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::getTypeTokenContextOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Type::Builder::setTypeTokenContextOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void Type::Builder::setTypeTokenContextOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::initTypeTokenContextOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void Type::Builder::adoptTypeTokenContextOffsets( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> Type::Builder::disownTypeTokenContextOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool Type::Reader::hasTokenData() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool Type::Builder::hasTokenData() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader Type::Reader::getTokenData() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder Type::Builder::getTokenData() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void Type::Builder::setTokenData( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder Type::Builder::initTokenData(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void Type::Builder::adoptTokenData( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> Type::Builder::disownTokenData() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool Type::Reader::hasTokenOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool Type::Builder::hasTokenOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader Type::Reader::getTokenOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::getTokenOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void Type::Builder::setTokenOffsets( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void Type::Builder::setTokenOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::initTokenOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void Type::Builder::adoptTokenOffsets( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> Type::Builder::disownTokenOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool Type::Reader::hasTokenKinds() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool Type::Builder::hasTokenKinds() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader Type::Reader::getTokenKinds() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::getTokenKinds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void Type::Builder::setTokenKinds( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void Type::Builder::setTokenKinds(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::initTokenKinds(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void Type::Builder::adoptTokenKinds( + ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> Type::Builder::disownTokenKinds() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool Type::Reader::hasRelatedEntityId() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool Type::Builder::hasRelatedEntityId() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader Type::Reader::getRelatedEntityId() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::getRelatedEntityId() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void Type::Builder::setRelatedEntityId( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline void Type::Builder::setRelatedEntityId(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder Type::Builder::initRelatedEntityId(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void Type::Builder::adoptRelatedEntityId( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> Type::Builder::disownRelatedEntityId() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool Type::Reader::hasType() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool Type::Builder::hasType() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::mx::ast::Type::Reader Type::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::mx::ast::Type>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::mx::ast::Type::Builder Type::Builder::getType() { + return ::capnp::_::PointerHelpers< ::mx::ast::Type>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::mx::ast::Type::Pipeline Type::Pipeline::getType() { + return ::mx::ast::Type::Pipeline(_typeless.getPointerField(6)); +} +#endif // !CAPNP_LITE +inline void Type::Builder::setType( ::mx::ast::Type::Reader value) { + ::capnp::_::PointerHelpers< ::mx::ast::Type>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::mx::ast::Type::Builder Type::Builder::initType() { + return ::capnp::_::PointerHelpers< ::mx::ast::Type>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void Type::Builder::adoptType( + ::capnp::Orphan< ::mx::ast::Type>&& value) { + ::capnp::_::PointerHelpers< ::mx::ast::Type>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::mx::ast::Type> Type::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::mx::ast::Type>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +} // namespace +} // namespace + +CAPNP_END_HEADER + diff --git a/lib/Reference.cpp b/lib/Reference.cpp index 8d88b7f34..308ad686d 100644 --- a/lib/Reference.cpp +++ b/lib/Reference.cpp @@ -6,6 +6,11 @@ #include "Reference.h" #include +#include +#include +#include +#include +#include "IR/Impl.h" #include "Attr.h" #include "Compilation.h" @@ -36,10 +41,14 @@ static OpaqueImplPtr ReferencedEntity(const EntityProviderPtr &ep, } else if (std::holds_alternative(vid)) { \ return OpaqueImplPtr(ep->type_name ## For(ep, raw_id)); \ - MX_FOR_EACH_ENTITY_CATEGORY(MX_DISPATCH_GETTER, MX_IGNORE_ENTITY_CATEGORY, - MX_DISPATCH_GETTER, MX_DISPATCH_GETTER, - MX_DISPATCH_GETTER, MX_DISPATCH_GETTER, - MX_DISPATCH_GETTER) + MX_FOR_EACH_ENTITY_CATEGORY(MX_DISPATCH_GETTER, + MX_IGNORE_ENTITY_CATEGORY, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER, + MX_DISPATCH_GETTER) #undef MX_DISPATCH_GETTER // It's a reference to a parsed token resident in a fragment. @@ -244,12 +253,13 @@ VariantEntity Reference::as_variant(void) const noexcept { break; MX_FOR_EACH_ENTITY_CATEGORY(DEFINE_REF_GETTER, - DEFINE_REF_GETTER, - DEFINE_REF_GETTER, - DEFINE_REF_GETTER, - DEFINE_REF_GETTER, - DEFINE_REF_GETTER, - DEFINE_REF_GETTER) + DEFINE_REF_GETTER, + DEFINE_REF_GETTER, + DEFINE_REF_GETTER, + DEFINE_REF_GETTER, + DEFINE_REF_GETTER, + DEFINE_REF_GETTER, + DEFINE_REF_GETTER) #undef DEFINE_REF_GETTER } return NotAnEntity{}; @@ -314,6 +324,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(DEFINE_REF_GETTER, DEFINE_REF_GETTER, DEFINE_REF_GETTER, DEFINE_REF_GETTER, + DEFINE_REF_GETTER, DEFINE_REF_GETTER) #undef DEFINE_REF_GETTER diff --git a/lib/SQLiteEntityProvider.cpp b/lib/SQLiteEntityProvider.cpp index de25edf54..8659808c9 100644 --- a/lib/SQLiteEntityProvider.cpp +++ b/lib/SQLiteEntityProvider.cpp @@ -4,6 +4,11 @@ // the LICENSE file found in the root directory of this source tree. #include "SQLiteEntityProvider.h" +#include +#include +#include +#include +#include "IR/Impl.h" #include #include @@ -412,6 +417,17 @@ unsigned SQLiteEntityProvider::VersionNumber(const Ptr &) { return VersionNumber(); } +IndexVersion SQLiteEntityProvider::GetIndexVersion(void) { + IndexVersion iv; + iv.version = VersionNumber(); + ImplPtr context = impl.Lock(); + auto stmt = context->db.Prepare("SELECT id FROM index_id LIMIT 1"); + if (stmt.ExecuteStep()) { + stmt.Row().Columns(iv.index_id); + } + return iv; +} + void SQLiteEntityProvider::VersionNumberChanged(unsigned) { dict.reset(new SQLiteDecompressionDictionary(db_path, dict.get())); } @@ -1073,16 +1089,69 @@ gap::generator SQLiteEntityProvider::FindSymbol( // Go make things like `EntityFor(ep, entity_id)`. E.g. go find a specific // declaration by its unique ID in the index. MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_ENTITY_GETTER, - MX_DECLARE_FRAGMENT_OFFSET_GETTER, - MX_DECLARE_FRAGMENT_PSEUDO_GETTER, - MX_DECLARE_ENTITY_GETTER) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_FRAGMENT_OFFSET_GETTER, + MX_DECLARE_FRAGMENT_PSEUDO_GETTER, + MX_DECLARE_ENTITY_GETTER, + MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_GETTER #undef MX_DECLARE_FRAGMENT_OFFSET_GETTER #undef MX_DECLARE_FRAGMENT_PSEUDO_GETTER +// IR entities are stored inside fragments. Extract the fragment_id from the +// entity ID, load the fragment, and create an impl with the offset. +IRFunctionImplPtr SQLiteEntityProvider::IRFunctionFor( + const Ptr &self, RawEntityId raw_id) { + auto eid = EntityId(raw_id).Extract(); + if (!eid) return {}; + auto frag = self->FragmentFor(self, PackedFragmentId(FragmentId(eid->fragment_id))); + if (!frag) return {}; + return std::make_shared( + std::move(frag), eid->offset, eid->fragment_id); +} + +IRBlockImplPtr SQLiteEntityProvider::IRBlockFor( + const Ptr &self, RawEntityId raw_id) { + auto eid = EntityId(raw_id).Extract(); + if (!eid) return {}; + auto frag = self->FragmentFor(self, PackedFragmentId(FragmentId(eid->fragment_id))); + if (!frag) return {}; + return std::make_shared( + std::move(frag), eid->offset, eid->fragment_id); +} + +IRInstructionImplPtr SQLiteEntityProvider::IRInstructionFor( + const Ptr &self, RawEntityId raw_id) { + auto eid = EntityId(raw_id).Extract(); + if (!eid) return {}; + auto frag = self->FragmentFor(self, PackedFragmentId(FragmentId(eid->fragment_id))); + if (!frag) return {}; + return std::make_shared( + std::move(frag), eid->offset, eid->fragment_id); +} + +IRObjectImplPtr SQLiteEntityProvider::IRObjectFor( + const Ptr &self, RawEntityId raw_id) { + auto eid = EntityId(raw_id).Extract(); + if (!eid) return {}; + auto frag = self->FragmentFor(self, PackedFragmentId(FragmentId(eid->fragment_id))); + if (!frag) return {}; + return std::make_shared( + std::move(frag), eid->offset, eid->fragment_id); +} + +IRStructureImplPtr SQLiteEntityProvider::IRStructureFor( + const Ptr &self, RawEntityId raw_id) { + auto eid = EntityId(raw_id).Extract(); + if (!eid) return {}; + auto frag = self->FragmentFor(self, PackedFragmentId(FragmentId(eid->fragment_id))); + if (!frag) return {}; + return std::make_shared( + std::move(frag), eid->offset, eid->fragment_id); +} + // Get a list of `Decl`, `Stmt`, `Attr`, `Designator`, etc. #define MX_DECLARE_FRAGMENT_OFFSET_LIST_GETTER(ns_path, type_name, lower_name, enum_name, category) \ gap::generator SQLiteEntityProvider::type_name ## sFor( \ @@ -1255,17 +1324,25 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER, // Go make things like `EntitysFor(ep)`. E.g. find all declarations in the // index. MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_LIST_GETTER, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_ENTITY_LIST_GETTER, - MX_DECLARE_ENTITY_LIST_GETTER, - MX_DECLARE_FRAGMENT_OFFSET_LIST_GETTER, - MX_DECLARE_FRAGMENT_PSEUDO_LIST_GETTER, - MX_DECLARE_ENTITY_LIST_GETTER) + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_ENTITY_LIST_GETTER, + MX_DECLARE_ENTITY_LIST_GETTER, + MX_DECLARE_FRAGMENT_OFFSET_LIST_GETTER, + MX_DECLARE_FRAGMENT_PSEUDO_LIST_GETTER, + MX_DECLARE_ENTITY_LIST_GETTER, + MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LIST_GETTER #undef MX_DECLARE_FRAGMENT_OFFSET_LIST_GETTER #undef MX_DECLARE_FRAGMENT_PSEUDO_LIST_GETTER +// IR entity list stubs. +gap::generator SQLiteEntityProvider::IRFunctionsFor(const Ptr &) & { co_return; } +gap::generator SQLiteEntityProvider::IRBlocksFor(const Ptr &) & { co_return; } +gap::generator SQLiteEntityProvider::IRInstructionsFor(const Ptr &) & { co_return; } +gap::generator SQLiteEntityProvider::IRObjectsFor(const Ptr &) & { co_return; } +gap::generator SQLiteEntityProvider::IRStructuresFor(const Ptr &) & { co_return; } + // Get all types of a specific kind. gap::generator SQLiteEntityProvider::TypesFor( const Ptr &self, TypeKind kind) & { @@ -1377,12 +1454,13 @@ gap::generator SQLiteEntityProvider::TypesFor( } MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY, - MX_DECLARE_FRAGMENT_OFFSET_LISTERS, - MX_IGNORE_ENTITY_CATEGORY, - MX_IGNORE_ENTITY_CATEGORY) + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_DECLARE_FRAGMENT_OFFSET_LISTERS, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_FRAGMENT_OFFSET_LISTERS EntityProviderPtr EntityProvider::CreateFromDatabase(std::filesystem::path path) { diff --git a/lib/SQLiteEntityProvider.h b/lib/SQLiteEntityProvider.h index b709f7ed7..0a6c21739 100644 --- a/lib/SQLiteEntityProvider.h +++ b/lib/SQLiteEntityProvider.h @@ -51,6 +51,7 @@ class SQLiteEntityProvider final : public EntityProvider { unsigned VersionNumber(void) final; unsigned VersionNumber(const Ptr &) final; + IndexVersion GetIndexVersion(void) final; void VersionNumberChanged(unsigned) final; FilePathMap ListFiles(const Ptr &) final; @@ -105,6 +106,7 @@ class SQLiteEntityProvider final : public EntityProvider { MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER, + MX_DECLARE_ENTITY_GETTER, MX_DECLARE_ENTITY_GETTER) #undef MX_DECLARE_ENTITY_GETTER @@ -118,6 +120,7 @@ class SQLiteEntityProvider final : public EntityProvider { MX_IGNORE_ENTITY_CATEGORY, MX_DECLARE_ENTITY_LISTERS, MX_IGNORE_ENTITY_CATEGORY, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DECLARE_ENTITY_LISTERS }; diff --git a/lib/SQLiteStore.cpp b/lib/SQLiteStore.cpp index ce6fd4b4f..9d0123e11 100644 --- a/lib/SQLiteStore.cpp +++ b/lib/SQLiteStore.cpp @@ -5,6 +5,8 @@ #include "SQLiteStore.h" +#include +#include #include #include #include @@ -147,7 +149,20 @@ ConnectionImpl::~ConnectionImpl(void) { stmts.clear(); - sqlite3_close(db); + int close_result = sqlite3_close(db); + if (close_result == SQLITE_OK) { + return; + } + + assert(close_result == SQLITE_BUSY); + sqlite3_stmt *leaked = nullptr; + while ((leaked = sqlite3_next_stmt(db, leaked)) != nullptr) { + const char *sql = sqlite3_sql(leaked); + fprintf(stderr, "LEAKED STATEMENT on conn %p: %s\n", + static_cast(db), sql ? sql : "(unknown)"); + } + + assert(false); // Good to know if we ever hit it. } Error::Error(const std::string &msg, sqlite3 *db) diff --git a/lib/TokenContext.cpp b/lib/TokenContext.cpp index 9d72160cc..d4eb66ddf 100644 --- a/lib/TokenContext.cpp +++ b/lib/TokenContext.cpp @@ -34,6 +34,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_DEFINE_GETTER, MX_DEFINE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DEFINE_GETTER @@ -74,6 +75,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_DEFINE_GETTER, MX_DEFINE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DEFINE_GETTER @@ -155,6 +157,7 @@ VariantEntity TokenContext::as_variant(void) const noexcept { MX_IGNORE_ENTITY_CATEGORY, MX_DEFINE_GETTER, MX_DEFINE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) default: break; } @@ -176,6 +179,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_DEFINE_GETTER, MX_DEFINE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_DEFINE_GETTER diff --git a/lib/TokenContext.h b/lib/TokenContext.h index 25f36dcef..80aba1173 100644 --- a/lib/TokenContext.h +++ b/lib/TokenContext.h @@ -25,6 +25,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_FORWARD_DECLARE_GETTER, MX_FORWARD_DECLARE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_FORWARD_DECLARE_GETTER @@ -55,6 +56,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_FORWARD_DECLARE_GETTER, MX_FORWARD_DECLARE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_FORWARD_DECLARE_GETTER @@ -84,6 +86,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY, MX_FORWARD_DECLARE_GETTER, MX_FORWARD_DECLARE_GETTER, + MX_IGNORE_ENTITY_CATEGORY, MX_IGNORE_ENTITY_CATEGORY) #undef MX_FORWARD_DECLARE_GETTER diff --git a/lib/Types.cpp b/lib/Types.cpp index a397b7409..e2ab64051 100644 --- a/lib/Types.cpp +++ b/lib/Types.cpp @@ -50,12 +50,28 @@ static constexpr uint64_t kNumMacroKinds = NumEnumerators(MacroKind{}); // NOTE(pag): Keep up-to-date with `IdentifiedPseudo`. static constexpr uint64_t kNumPseudoKinds = 5u; -static constexpr unsigned kSubKindNumBits = 11u; +// IR sub_kind layout within kIRSubKindBase: +// 0 → IRFunctionId +// 1..kNumBlockKinds → IRBlockId (1 per BlockKind) +// 1+kNumBlockKinds..+kNumOpCodes → IRInstructionId (1 per OpCode) +// last → IRObjectId +static constexpr uint64_t kNumBlockKinds = 17u; // BlockKind enum count +static constexpr uint64_t kNumOpCodes = 251u; // OpCode enum count (ATOMIC_EXCHANGE_64=250) +static constexpr uint64_t kNumStructureKinds = 19u; // StructureKind enum count (EXPRESSION_SCOPE=18) +static constexpr uint64_t kIRFunctionOffset = 0u; +static constexpr uint64_t kIRBlockOffset = 1u; +static constexpr uint64_t kIRInstructionOffset = kIRBlockOffset + kNumBlockKinds; +static constexpr uint64_t kIRObjectOffset = kIRInstructionOffset + kNumOpCodes; +static constexpr uint64_t kIRStructureOffset = kIRObjectOffset + 1u; +static constexpr uint64_t kNumIREntityKinds = kIRStructureOffset + kNumStructureKinds; + +static constexpr unsigned kSubKindNumBits = 12u; static_assert((kNumDeclKinds + kNumStmtKinds + kNumAttrKinds + kNumTokenKinds /* fragment tokens */ + kNumTokenKinds /* macro tokens */ + kNumMacroKinds + - kNumPseudoKinds) <= + kNumPseudoKinds + + kNumIREntityKinds) <= (1u << kSubKindNumBits)); static constexpr unsigned kOtherKindBits = 3u; @@ -192,6 +208,7 @@ const char *EnumeratorName(EntityCategory e) noexcept { MX_ENTITY_CASE_NAME, MX_ENTITY_CASE_NAME, MX_ENTITY_CASE_NAME, + MX_ENTITY_CASE_NAME, MX_ENTITY_CASE_NAME) #undef MX_ENTITY_CASE_NAME } @@ -693,6 +710,65 @@ EntityId::EntityId(CXXCtorInitializerId id) { } } +// IR entity IDs follow the same sub_kind pattern as pseudo entities. +static constexpr uint64_t kIRSubKindBase = + kNumDeclKinds + kNumStmtKinds + kNumAttrKinds + + kNumTokenKinds + kNumTokenKinds + kNumMacroKinds + kNumPseudoKinds; + +static void PackIREntity(uint64_t &opaque, uint64_t fragment_id, + uint64_t sub_kind_offset, uint32_t offset) { + PackedEntityId packed = {}; + if (fragment_id >= kMaxBigFragmentId) { + packed.small_entity.fragment_id = fragment_id - kMaxBigFragmentId; + packed.small_entity.is_big = 0u; + packed.small_entity.is_fragment_entity = 1u; + packed.small_entity.sub_kind = kIRSubKindBase + sub_kind_offset; + packed.small_entity.offset = offset; + RETURN_EARLY_IF_NOT(packed.small_entity.offset == offset); + } else { + packed.big_entity.fragment_id = fragment_id; + packed.big_entity.is_big = 1u; + packed.big_entity.is_fragment_entity = 1u; + packed.big_entity.sub_kind = kIRSubKindBase + sub_kind_offset; + packed.big_entity.offset = offset; + RETURN_EARLY_IF_NOT(packed.big_entity.offset == offset); + } + opaque = packed.opaque; +} + +EntityId::EntityId(IRFunctionId id) { + if (id.fragment_id) { + PackIREntity(opaque, id.fragment_id, kIRFunctionOffset, id.offset); + } +} + +EntityId::EntityId(IRBlockId id) { + if (id.fragment_id) { + PackIREntity(opaque, id.fragment_id, + kIRBlockOffset + static_cast(id.block_kind), id.offset); + } +} + +EntityId::EntityId(IRInstructionId id) { + if (id.fragment_id) { + PackIREntity(opaque, id.fragment_id, + kIRInstructionOffset + static_cast(id.opcode), id.offset); + } +} + +EntityId::EntityId(IRObjectId id) { + if (id.fragment_id) { + PackIREntity(opaque, id.fragment_id, kIRObjectOffset, id.offset); + } +} + +EntityId::EntityId(IRStructureId id) { + if (id.fragment_id) { + PackIREntity(opaque, id.fragment_id, + kIRStructureOffset + static_cast(id.structure_kind), id.offset); + } +} + EntityId::EntityId(CompilationId id) { if (id.compilation_id) { PackedEntityId packed = {}; @@ -1029,7 +1105,30 @@ VariantId EntityId::Unpack(void) const noexcept { id.offset = static_cast(packed.big_entity.offset); return id; } - } + } + } + + sub_kind -= kNumPseudoKinds; + if (sub_kind < kNumIREntityKinds) { + auto fid = packed.big_entity.fragment_id; + auto off = static_cast(packed.big_entity.offset); + if (sub_kind == kIRFunctionOffset) { + return IRFunctionId{fid, off}; + } else if (sub_kind >= kIRBlockOffset && + sub_kind < kIRBlockOffset + kNumBlockKinds) { + return IRBlockId{fid, off, + static_cast(sub_kind - kIRBlockOffset)}; + } else if (sub_kind >= kIRInstructionOffset && + sub_kind < kIRInstructionOffset + kNumOpCodes) { + return IRInstructionId{fid, off, + static_cast(sub_kind - kIRInstructionOffset)}; + } else if (sub_kind == kIRObjectOffset) { + return IRObjectId{fid, off}; + } else if (sub_kind >= kIRStructureOffset && + sub_kind < kIRStructureOffset + kNumStructureKinds) { + return IRStructureId{fid, off, + static_cast(sub_kind - kIRStructureOffset)}; + } } return InvalidId{}; @@ -1131,7 +1230,30 @@ VariantId EntityId::Unpack(void) const noexcept { id.offset = static_cast(packed.small_entity.offset); return id; } - } + } + } + + sub_kind -= kNumPseudoKinds; + if (sub_kind < kNumIREntityKinds) { + auto fid = packed.small_entity.fragment_id + kMaxBigFragmentId; + auto off = static_cast(packed.small_entity.offset); + if (sub_kind == kIRFunctionOffset) { + return IRFunctionId{fid, off}; + } else if (sub_kind >= kIRBlockOffset && + sub_kind < kIRBlockOffset + kNumBlockKinds) { + return IRBlockId{fid, off, + static_cast(sub_kind - kIRBlockOffset)}; + } else if (sub_kind >= kIRInstructionOffset && + sub_kind < kIRInstructionOffset + kNumOpCodes) { + return IRInstructionId{fid, off, + static_cast(sub_kind - kIRInstructionOffset)}; + } else if (sub_kind == kIRObjectOffset) { + return IRObjectId{fid, off}; + } else if (sub_kind >= kIRStructureOffset && + sub_kind < kIRStructureOffset + kNumStructureKinds) { + return IRStructureId{fid, off, + static_cast(sub_kind - kIRStructureOffset)}; + } } return InvalidId{}; diff --git a/tests/InterpretIR/run_tests.sh b/tests/InterpretIR/run_tests.sh new file mode 100755 index 000000000..b2b605eca --- /dev/null +++ b/tests/InterpretIR/run_tests.sh @@ -0,0 +1,81 @@ +#!/bin/bash +# Run all IR interpreter tests against an indexed database. +# Usage: ./run_tests.sh /path/to/tests.db [/path/to/mx-interpret-ir] + +DB="${1:?Usage: $0 [mx-interpret-ir_path]}" +INTERP="${2:-mx-interpret-ir}" + +PASS=0 +FAIL=0 +SKIP=0 +ERRORS="" + +# All test_* functions return 0 on success, nonzero (error code) on failure. +TEST_FUNCS=( + test_arithmetic + test_bitfields + test_casts + test_compound_assign + test_control_flow + test_function_calls + test_globals + test_goto + test_init_lists + test_memory_ops + test_pointers + test_scopes + test_sizeof_alignof + test_switch + test_array_decay + test_struct_assign + test_string_literals + test_variadics + test_dynamic_alloca + test_byvalue + test_evil_goto + test_conditional_exec + test_unsigned + test_c23 + test_float_compound + test_unsigned_compound + test_float_precision + test_width_arithmetic + test_width_comparisons + test_float_ops + test_logical_misc + test_width_rmw + test_overflow_exact + test_cast_precision +) + +for func in "${TEST_FUNCS[@]}"; do + output=$("$INTERP" --db "$DB" --entity_name "$func" 2>&1) + exit_code=$? + + # Look for the return value in the output. + ret_val=$(echo "$output" | sed -n 's/.*Return value: \([-0-9]*\).*/\1/p' | tail -1) + + if [ $exit_code -ne 0 ]; then + echo "CRASH $func (exit code $exit_code)" + ERRORS="$ERRORS\n $func: crashed (exit $exit_code)" + FAIL=$((FAIL + 1)) + elif [ -z "$ret_val" ]; then + echo "SKIP $func (no return value found)" + SKIP=$((SKIP + 1)) + elif [ "$ret_val" = "0" ]; then + echo "PASS $func" + PASS=$((PASS + 1)) + else + echo "FAIL $func (returned $ret_val)" + ERRORS="$ERRORS\n $func: returned $ret_val" + FAIL=$((FAIL + 1)) + fi +done + +echo "" +echo "Results: $PASS passed, $FAIL failed, $SKIP skipped" +if [ -n "$ERRORS" ]; then + echo -e "Failures:$ERRORS" +fi + +exit $FAIL diff --git a/tests/InterpretIR/test_arithmetic.c b/tests/InterpretIR/test_arithmetic.c new file mode 100644 index 000000000..aa3d65715 --- /dev/null +++ b/tests/InterpretIR/test_arithmetic.c @@ -0,0 +1,613 @@ +// Tests: integer arithmetic (ADD, SUB, MUL, DIV, REM), unary (NEG), +// bitwise (AND, OR, XOR, SHL, SHR, NOT), logical (AND, OR, NOT), +// comparisons (EQ, NE, LT, LE, GT, GE), and the comma operator (LAST_VALUE). + +/* + * Expected IR: + * + * function test_arithmetic (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (a) + * obj_1 LOCAL_VALUE size=4 align=4 (b) + * obj_2 LOCAL_VALUE size=4 align=4 (add) + * obj_3 LOCAL_VALUE size=4 align=4 (sub) + * obj_4 LOCAL_VALUE size=4 align=4 (mul) + * obj_5 LOCAL_VALUE size=4 align=4 (div) + * obj_6 LOCAL_VALUE size=4 align=4 (rem) + * obj_7 LOCAL_VALUE size=4 align=4 (neg) + * obj_8 LOCAL_VALUE size=4 align=4 (band) + * obj_9 LOCAL_VALUE size=4 align=4 (bor) + * obj_10 LOCAL_VALUE size=4 align=4 (bxor) + * obj_11 LOCAL_VALUE size=4 align=4 (shl) + * obj_12 LOCAL_VALUE size=4 align=4 (shr) + * obj_13 LOCAL_VALUE size=4 align=4 (bnot) + * obj_14 LOCAL_VALUE size=4 align=4 (land) + * obj_15 LOCAL_VALUE size=4 align=4 (lor) + * obj_16 LOCAL_VALUE size=4 align=4 (lnot) + * obj_17 LOCAL_VALUE size=4 align=4 (eq) + * obj_18 LOCAL_VALUE size=4 align=4 (ne) + * obj_19 LOCAL_VALUE size=4 align=4 (lt) + * obj_20 LOCAL_VALUE size=4 align=4 (le) + * obj_21 LOCAL_VALUE size=4 align=4 (gt) + * obj_22 LOCAL_VALUE size=4 align=4 (ge) + * obj_23 LOCAL_VALUE size=4 align=4 (comma) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %a.0 = ALLOCA/LOCAL size=4 align=4 + * >> %b.1 = ALLOCA/LOCAL size=4 align=4 + * >> %add.2 = ALLOCA/LOCAL size=4 align=4 + * >> %sub.3 = ALLOCA/LOCAL size=4 align=4 + * >> %mul.4 = ALLOCA/LOCAL size=4 align=4 + * >> %div.5 = ALLOCA/LOCAL size=4 align=4 + * >> %rem.6 = ALLOCA/LOCAL size=4 align=4 + * >> %neg.7 = ALLOCA/LOCAL size=4 align=4 + * >> %band.8 = ALLOCA/LOCAL size=4 align=4 + * >> %bor.9 = ALLOCA/LOCAL size=4 align=4 + * >> %bxor.10 = ALLOCA/LOCAL size=4 align=4 + * >> %shl.11 = ALLOCA/LOCAL size=4 align=4 + * >> %shr.12 = ALLOCA/LOCAL size=4 align=4 + * >> %bnot.13 = ALLOCA/LOCAL size=4 align=4 + * >> %land.14 = ALLOCA/LOCAL size=4 align=4 + * >> %lor.15 = ALLOCA/LOCAL size=4 align=4 + * >> %lnot.16 = ALLOCA/LOCAL size=4 align=4 + * >> %eq.17 = ALLOCA/LOCAL size=4 align=4 + * >> %ne.18 = ALLOCA/LOCAL size=4 align=4 + * >> %lt.19 = ALLOCA/LOCAL size=4 align=4 + * >> %le.20 = ALLOCA/LOCAL size=4 align=4 + * >> %gt.21 = ALLOCA/LOCAL size=4 align=4 + * >> %ge.22 = ALLOCA/LOCAL size=4 align=4 + * >> %comma.23 = ALLOCA/LOCAL size=4 align=4 + * >> %24 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %25 = ENTER_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * %a.0 = ALLOCA/LOCAL size=4 align=4 + * %26 = CONST/INT32 10 // 10 + * >> %a.27 = MEMORY/STORE_LE_32 [%a.0, %26] + * %b.1 = ALLOCA/LOCAL size=4 align=4 + * %28 = CONST/INT32 3 // 3 + * >> %b.29 = MEMORY/STORE_LE_32 [%b.1, %28] + * %add.2 = ALLOCA/LOCAL size=4 align=4 + * %30 = MEMORY/LOAD_LE_32 [%a.0] // a + * %31 = MEMORY/LOAD_LE_32 [%b.1] // b + * %32 = ADD [%30, %31] // a + b + * >> %add.33 = MEMORY/STORE_LE_32 [%add.2, %32] + * %sub.3 = ALLOCA/LOCAL size=4 align=4 + * %34 = MEMORY/LOAD_LE_32 [%a.0] // a + * %35 = MEMORY/LOAD_LE_32 [%b.1] // b + * %36 = SUB [%34, %35] // a - b + * >> %sub.37 = MEMORY/STORE_LE_32 [%sub.3, %36] + * %mul.4 = ALLOCA/LOCAL size=4 align=4 + * %38 = MEMORY/LOAD_LE_32 [%a.0] // a + * %39 = MEMORY/LOAD_LE_32 [%b.1] // b + * %40 = MUL [%38, %39] // a * b + * >> %mul.41 = MEMORY/STORE_LE_32 [%mul.4, %40] + * %div.5 = ALLOCA/LOCAL size=4 align=4 + * %42 = MEMORY/LOAD_LE_32 [%a.0] // a + * %43 = MEMORY/LOAD_LE_32 [%b.1] // b + * %44 = DIV [%42, %43] // a / b + * >> %div.45 = MEMORY/STORE_LE_32 [%div.5, %44] + * %rem.6 = ALLOCA/LOCAL size=4 align=4 + * %46 = MEMORY/LOAD_LE_32 [%a.0] // a + * %47 = MEMORY/LOAD_LE_32 [%b.1] // b + * %48 = REM [%46, %47] // a % b + * >> %rem.49 = MEMORY/STORE_LE_32 [%rem.6, %48] + * %neg.7 = ALLOCA/LOCAL size=4 align=4 + * %50 = MEMORY/LOAD_LE_32 [%a.0] // a + * %51 = NEG [%50] // -a + * >> %neg.52 = MEMORY/STORE_LE_32 [%neg.7, %51] + * %band.8 = ALLOCA/LOCAL size=4 align=4 + * %53 = MEMORY/LOAD_LE_32 [%a.0] // a + * %54 = MEMORY/LOAD_LE_32 [%b.1] // b + * %55 = BIT_AND [%53, %54] // a & b + * >> %band.56 = MEMORY/STORE_LE_32 [%band.8, %55] + * %bor.9 = ALLOCA/LOCAL size=4 align=4 + * %57 = MEMORY/LOAD_LE_32 [%a.0] // a + * %58 = MEMORY/LOAD_LE_32 [%b.1] // b + * %59 = BIT_OR [%57, %58] // a | b + * >> %bor.60 = MEMORY/STORE_LE_32 [%bor.9, %59] + * %bxor.10 = ALLOCA/LOCAL size=4 align=4 + * %61 = MEMORY/LOAD_LE_32 [%a.0] // a + * %62 = MEMORY/LOAD_LE_32 [%b.1] // b + * %63 = BIT_XOR [%61, %62] // a ^ b + * >> %bxor.64 = MEMORY/STORE_LE_32 [%bxor.10, %63] + * %shl.11 = ALLOCA/LOCAL size=4 align=4 + * %65 = MEMORY/LOAD_LE_32 [%a.0] // a + * %66 = CONST/INT32 1 // 1 + * %67 = SHL [%65, %66] // a << 1 + * >> %shl.68 = MEMORY/STORE_LE_32 [%shl.11, %67] + * %shr.12 = ALLOCA/LOCAL size=4 align=4 + * %69 = MEMORY/LOAD_LE_32 [%a.0] // a + * %70 = CONST/INT32 1 // 1 + * %71 = SHR [%69, %70] // a >> 1 + * >> %shr.72 = MEMORY/STORE_LE_32 [%shr.12, %71] + * %bnot.13 = ALLOCA/LOCAL size=4 align=4 + * %73 = MEMORY/LOAD_LE_32 [%a.0] // a + * %74 = BIT_NOT [%73] // ~a + * >> %bnot.75 = MEMORY/STORE_LE_32 [%bnot.13, %74] + * %land.14 = ALLOCA/LOCAL size=4 align=4 + * %76 = MEMORY/LOAD_LE_32 [%a.0] // a + * %77 = MEMORY/LOAD_LE_32 [%b.1] // b + * %78 = LOGICAL_AND [%76, %77] // a && b + * >> %land.79 = MEMORY/STORE_LE_32 [%land.14, %78] + * %lor.15 = ALLOCA/LOCAL size=4 align=4 + * %80 = MEMORY/LOAD_LE_32 [%a.0] // a + * %81 = CONST/INT32 0 // 0 + * %82 = LOGICAL_OR [%80, %81] // a || 0 + * >> %lor.83 = MEMORY/STORE_LE_32 [%lor.15, %82] + * %lnot.16 = ALLOCA/LOCAL size=4 align=4 + * %84 = MEMORY/LOAD_LE_32 [%a.0] // a + * %85 = LOGICAL_NOT [%84] // !a + * >> %lnot.86 = MEMORY/STORE_LE_32 [%lnot.16, %85] + * %eq.17 = ALLOCA/LOCAL size=4 align=4 + * %87 = MEMORY/LOAD_LE_32 [%a.0] // a + * %88 = MEMORY/LOAD_LE_32 [%b.1] // b + * %89 = CMP_EQ [%87, %88] // a == b + * >> %eq.90 = MEMORY/STORE_LE_32 [%eq.17, %89] + * %ne.18 = ALLOCA/LOCAL size=4 align=4 + * %91 = MEMORY/LOAD_LE_32 [%a.0] // a + * %92 = MEMORY/LOAD_LE_32 [%b.1] // b + * %93 = CMP_NE [%91, %92] // a != b + * >> %ne.94 = MEMORY/STORE_LE_32 [%ne.18, %93] + * %lt.19 = ALLOCA/LOCAL size=4 align=4 + * %95 = MEMORY/LOAD_LE_32 [%a.0] // a + * %96 = MEMORY/LOAD_LE_32 [%b.1] // b + * %97 = CMP_LT [%95, %96] // a < b + * >> %lt.98 = MEMORY/STORE_LE_32 [%lt.19, %97] + * %le.20 = ALLOCA/LOCAL size=4 align=4 + * %99 = MEMORY/LOAD_LE_32 [%a.0] // a + * %100 = MEMORY/LOAD_LE_32 [%b.1] // b + * %101 = CMP_LE [%99, %100] // a <= b + * >> %le.102 = MEMORY/STORE_LE_32 [%le.20, %101] + * %gt.21 = ALLOCA/LOCAL size=4 align=4 + * %103 = MEMORY/LOAD_LE_32 [%a.0] // a + * %104 = MEMORY/LOAD_LE_32 [%b.1] // b + * %105 = CMP_GT [%103, %104] // a > b + * >> %gt.106 = MEMORY/STORE_LE_32 [%gt.21, %105] + * %ge.22 = ALLOCA/LOCAL size=4 align=4 + * %107 = MEMORY/LOAD_LE_32 [%a.0] // a + * %108 = MEMORY/LOAD_LE_32 [%b.1] // b + * %109 = CMP_GE [%107, %108] // a >= b + * >> %ge.110 = MEMORY/STORE_LE_32 [%ge.22, %109] + * %comma.23 = ALLOCA/LOCAL size=4 align=4 + * %111 = CONST/INT32 1 // 1 + * %112 = CONST/INT32 2 // 2 + * %113 = LAST_VALUE [%111, %112] // 1, 2 + * %114 = CONST/INT32 3 // 3 + * %115 = LAST_VALUE [%113, %114] // 1, 2, 3 + * >> %comma.116 = MEMORY/STORE_LE_32 [%comma.23, %115] + * %117 = MEMORY/LOAD_LE_32 [%add.2] // add + * %118 = CONST/INT32 13 // 13 + * %119 = CMP_NE [%117, %118] // add != 13 + * >> %120 = COND_BRANCH [%119] // if (add != 13) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %126 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %sub.3 = ALLOCA/LOCAL size=4 align=4 + * %127 = MEMORY/LOAD_LE_32 [%sub.3] // sub + * %128 = CONST/INT32 7 // 7 + * %129 = CMP_NE [%127, %128] // sub != 7 + * >> %130 = COND_BRANCH [%129] // if (sub != 7) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %136 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %mul.4 = ALLOCA/LOCAL size=4 align=4 + * %137 = MEMORY/LOAD_LE_32 [%mul.4] // mul + * %138 = CONST/INT32 30 // 30 + * %139 = CMP_NE [%137, %138] // mul != 30 + * >> %140 = COND_BRANCH [%139] // if (mul != 30) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %146 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %div.5 = ALLOCA/LOCAL size=4 align=4 + * %147 = MEMORY/LOAD_LE_32 [%div.5] // div + * %148 = CONST/INT32 3 // 3 + * %149 = CMP_NE [%147, %148] // div != 3 + * >> %150 = COND_BRANCH [%149] // if (div != 3) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %156 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %rem.6 = ALLOCA/LOCAL size=4 align=4 + * %157 = MEMORY/LOAD_LE_32 [%rem.6] // rem + * %158 = CONST/INT32 1 // 1 + * %159 = CMP_NE [%157, %158] // rem != 1 + * >> %160 = COND_BRANCH [%159] // if (rem != 1) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %166 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %neg.7 = ALLOCA/LOCAL size=4 align=4 + * %167 = MEMORY/LOAD_LE_32 [%neg.7] // neg + * %168 = CONST/INT32 10 // 10 + * %169 = NEG [%168] // -10 + * %170 = CMP_NE [%167, %169] // neg != -10 + * >> %171 = COND_BRANCH [%170] // if (neg != -10) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %177 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %band.8 = ALLOCA/LOCAL size=4 align=4 + * %178 = MEMORY/LOAD_LE_32 [%band.8] // band + * %179 = CONST/INT32 2 // 2 + * %180 = CMP_NE [%178, %179] // band != 2 + * >> %181 = COND_BRANCH [%180] // if (band != 2) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %187 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %bor.9 = ALLOCA/LOCAL size=4 align=4 + * %188 = MEMORY/LOAD_LE_32 [%bor.9] // bor + * %189 = CONST/INT32 11 // 11 + * %190 = CMP_NE [%188, %189] // bor != 11 + * >> %191 = COND_BRANCH [%190] // if (bor != 11) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %197 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %bxor.10 = ALLOCA/LOCAL size=4 align=4 + * %198 = MEMORY/LOAD_LE_32 [%bxor.10] // bxor + * %199 = CONST/INT32 9 // 9 + * %200 = CMP_NE [%198, %199] // bxor != 9 + * >> %201 = COND_BRANCH [%200] // if (bxor != 9) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %207 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %shl.11 = ALLOCA/LOCAL size=4 align=4 + * %208 = MEMORY/LOAD_LE_32 [%shl.11] // shl + * %209 = CONST/INT32 20 // 20 + * %210 = CMP_NE [%208, %209] // shl != 20 + * >> %211 = COND_BRANCH [%210] // if (shl != 20) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %217 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %shr.12 = ALLOCA/LOCAL size=4 align=4 + * %218 = MEMORY/LOAD_LE_32 [%shr.12] // shr + * %219 = CONST/INT32 5 // 5 + * %220 = CMP_NE [%218, %219] // shr != 5 + * >> %221 = COND_BRANCH [%220] // if (shr != 5) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %227 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %bnot.13 = ALLOCA/LOCAL size=4 align=4 + * %228 = MEMORY/LOAD_LE_32 [%bnot.13] // bnot + * %229 = CONST/INT32 11 // 11 + * %230 = NEG [%229] // -11 + * %231 = CMP_NE [%228, %230] // bnot != -11 + * >> %232 = COND_BRANCH [%231] // if (bnot != -11) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %238 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %land.14 = ALLOCA/LOCAL size=4 align=4 + * %239 = MEMORY/LOAD_LE_32 [%land.14] // land + * %240 = CONST/INT32 1 // 1 + * %241 = CMP_NE [%239, %240] // land != 1 + * >> %242 = COND_BRANCH [%241] // if (land != 1) return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %248 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %lor.15 = ALLOCA/LOCAL size=4 align=4 + * %249 = MEMORY/LOAD_LE_32 [%lor.15] // lor + * %250 = CONST/INT32 1 // 1 + * %251 = CMP_NE [%249, %250] // lor != 1 + * >> %252 = COND_BRANCH [%251] // if (lor != 1) return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %258 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %lnot.16 = ALLOCA/LOCAL size=4 align=4 + * %259 = MEMORY/LOAD_LE_32 [%lnot.16] // lnot + * %260 = CONST/INT32 0 // 0 + * %261 = CMP_NE [%259, %260] // lnot != 0 + * >> %262 = COND_BRANCH [%261] // if (lnot != 0) return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %268 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %eq.17 = ALLOCA/LOCAL size=4 align=4 + * %269 = MEMORY/LOAD_LE_32 [%eq.17] // eq + * %270 = CONST/INT32 0 // 0 + * %271 = CMP_NE [%269, %270] // eq != 0 + * >> %272 = COND_BRANCH [%271] // if (eq != 0) return 16 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %278 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %ne.18 = ALLOCA/LOCAL size=4 align=4 + * %279 = MEMORY/LOAD_LE_32 [%ne.18] // ne + * %280 = CONST/INT32 1 // 1 + * %281 = CMP_NE [%279, %280] // ne != 1 + * >> %282 = COND_BRANCH [%281] // if (ne != 1) return 17 + * -> [block_50, block_51] + * block_51 IF_ELSE <- [block_49]: + * >> %288 = IMPLICIT_GOTO + * -> [block_52] + * block_52 IF_MERGE <- [block_51]: + * %lt.19 = ALLOCA/LOCAL size=4 align=4 + * %289 = MEMORY/LOAD_LE_32 [%lt.19] // lt + * %290 = CONST/INT32 0 // 0 + * %291 = CMP_NE [%289, %290] // lt != 0 + * >> %292 = COND_BRANCH [%291] // if (lt != 0) return 18 + * -> [block_53, block_54] + * block_54 IF_ELSE <- [block_52]: + * >> %298 = IMPLICIT_GOTO + * -> [block_55] + * block_55 IF_MERGE <- [block_54]: + * %le.20 = ALLOCA/LOCAL size=4 align=4 + * %299 = MEMORY/LOAD_LE_32 [%le.20] // le + * %300 = CONST/INT32 0 // 0 + * %301 = CMP_NE [%299, %300] // le != 0 + * >> %302 = COND_BRANCH [%301] // if (le != 0) return 19 + * -> [block_56, block_57] + * block_57 IF_ELSE <- [block_55]: + * >> %308 = IMPLICIT_GOTO + * -> [block_58] + * block_58 IF_MERGE <- [block_57]: + * %gt.21 = ALLOCA/LOCAL size=4 align=4 + * %309 = MEMORY/LOAD_LE_32 [%gt.21] // gt + * %310 = CONST/INT32 1 // 1 + * %311 = CMP_NE [%309, %310] // gt != 1 + * >> %312 = COND_BRANCH [%311] // if (gt != 1) return 20 + * -> [block_59, block_60] + * block_60 IF_ELSE <- [block_58]: + * >> %318 = IMPLICIT_GOTO + * -> [block_61] + * block_61 IF_MERGE <- [block_60]: + * %ge.22 = ALLOCA/LOCAL size=4 align=4 + * %319 = MEMORY/LOAD_LE_32 [%ge.22] // ge + * %320 = CONST/INT32 1 // 1 + * %321 = CMP_NE [%319, %320] // ge != 1 + * >> %322 = COND_BRANCH [%321] // if (ge != 1) return 21 + * -> [block_62, block_63] + * block_63 IF_ELSE <- [block_61]: + * >> %328 = IMPLICIT_GOTO + * -> [block_64] + * block_64 IF_MERGE <- [block_63]: + * %comma.23 = ALLOCA/LOCAL size=4 align=4 + * %329 = MEMORY/LOAD_LE_32 [%comma.23] // comma + * %330 = CONST/INT32 3 // 3 + * %331 = CMP_NE [%329, %330] // comma != 3 + * >> %332 = COND_BRANCH [%331] // if (comma != 3) return 22 + * -> [block_65, block_66] + * block_66 IF_ELSE <- [block_64]: + * >> %338 = IMPLICIT_GOTO + * -> [block_67] + * block_67 IF_MERGE <- [block_66]: + * %340 = RETURN_PTR // return 0 + * %339 = CONST/INT32 0 // 0 + * >> %341 = MEMORY/STORE_LE_32 [%340, %339] // return 0 + * >> %342 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %343 = RET [%339] // return 0 + * block_65 IF_THEN <- [block_64]: + * %334 = RETURN_PTR // return 22 + * %333 = CONST/INT32 22 // 22 + * >> %335 = MEMORY/STORE_LE_32 [%334, %333] // return 22 + * >> %336 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %337 = RET [%333] // return 22 + * block_62 IF_THEN <- [block_61]: + * %324 = RETURN_PTR // return 21 + * %323 = CONST/INT32 21 // 21 + * >> %325 = MEMORY/STORE_LE_32 [%324, %323] // return 21 + * >> %326 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %327 = RET [%323] // return 21 + * block_59 IF_THEN <- [block_58]: + * %314 = RETURN_PTR // return 20 + * %313 = CONST/INT32 20 // 20 + * >> %315 = MEMORY/STORE_LE_32 [%314, %313] // return 20 + * >> %316 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %317 = RET [%313] // return 20 + * block_56 IF_THEN <- [block_55]: + * %304 = RETURN_PTR // return 19 + * %303 = CONST/INT32 19 // 19 + * >> %305 = MEMORY/STORE_LE_32 [%304, %303] // return 19 + * >> %306 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %307 = RET [%303] // return 19 + * block_53 IF_THEN <- [block_52]: + * %294 = RETURN_PTR // return 18 + * %293 = CONST/INT32 18 // 18 + * >> %295 = MEMORY/STORE_LE_32 [%294, %293] // return 18 + * >> %296 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %297 = RET [%293] // return 18 + * block_50 IF_THEN <- [block_49]: + * %284 = RETURN_PTR // return 17 + * %283 = CONST/INT32 17 // 17 + * >> %285 = MEMORY/STORE_LE_32 [%284, %283] // return 17 + * >> %286 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %287 = RET [%283] // return 17 + * block_47 IF_THEN <- [block_46]: + * %274 = RETURN_PTR // return 16 + * %273 = CONST/INT32 16 // 16 + * >> %275 = MEMORY/STORE_LE_32 [%274, %273] // return 16 + * >> %276 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %277 = RET [%273] // return 16 + * block_44 IF_THEN <- [block_43]: + * %264 = RETURN_PTR // return 15 + * %263 = CONST/INT32 15 // 15 + * >> %265 = MEMORY/STORE_LE_32 [%264, %263] // return 15 + * >> %266 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %267 = RET [%263] // return 15 + * block_41 IF_THEN <- [block_40]: + * %254 = RETURN_PTR // return 14 + * %253 = CONST/INT32 14 // 14 + * >> %255 = MEMORY/STORE_LE_32 [%254, %253] // return 14 + * >> %256 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %257 = RET [%253] // return 14 + * block_38 IF_THEN <- [block_37]: + * %244 = RETURN_PTR // return 13 + * %243 = CONST/INT32 13 // 13 + * >> %245 = MEMORY/STORE_LE_32 [%244, %243] // return 13 + * >> %246 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %247 = RET [%243] // return 13 + * block_35 IF_THEN <- [block_34]: + * %234 = RETURN_PTR // return 12 + * %233 = CONST/INT32 12 // 12 + * >> %235 = MEMORY/STORE_LE_32 [%234, %233] // return 12 + * >> %236 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %237 = RET [%233] // return 12 + * block_32 IF_THEN <- [block_31]: + * %223 = RETURN_PTR // return 11 + * %222 = CONST/INT32 11 // 11 + * >> %224 = MEMORY/STORE_LE_32 [%223, %222] // return 11 + * >> %225 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %226 = RET [%222] // return 11 + * block_29 IF_THEN <- [block_28]: + * %213 = RETURN_PTR // return 10 + * %212 = CONST/INT32 10 // 10 + * >> %214 = MEMORY/STORE_LE_32 [%213, %212] // return 10 + * >> %215 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %216 = RET [%212] // return 10 + * block_26 IF_THEN <- [block_25]: + * %203 = RETURN_PTR // return 9 + * %202 = CONST/INT32 9 // 9 + * >> %204 = MEMORY/STORE_LE_32 [%203, %202] // return 9 + * >> %205 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %206 = RET [%202] // return 9 + * block_23 IF_THEN <- [block_22]: + * %193 = RETURN_PTR // return 8 + * %192 = CONST/INT32 8 // 8 + * >> %194 = MEMORY/STORE_LE_32 [%193, %192] // return 8 + * >> %195 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %196 = RET [%192] // return 8 + * block_20 IF_THEN <- [block_19]: + * %183 = RETURN_PTR // return 7 + * %182 = CONST/INT32 7 // 7 + * >> %184 = MEMORY/STORE_LE_32 [%183, %182] // return 7 + * >> %185 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %186 = RET [%182] // return 7 + * block_17 IF_THEN <- [block_16]: + * %173 = RETURN_PTR // return 6 + * %172 = CONST/INT32 6 // 6 + * >> %174 = MEMORY/STORE_LE_32 [%173, %172] // return 6 + * >> %175 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %176 = RET [%172] // return 6 + * block_14 IF_THEN <- [block_13]: + * %162 = RETURN_PTR // return 5 + * %161 = CONST/INT32 5 // 5 + * >> %163 = MEMORY/STORE_LE_32 [%162, %161] // return 5 + * >> %164 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %165 = RET [%161] // return 5 + * block_11 IF_THEN <- [block_10]: + * %152 = RETURN_PTR // return 4 + * %151 = CONST/INT32 4 // 4 + * >> %153 = MEMORY/STORE_LE_32 [%152, %151] // return 4 + * >> %154 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %155 = RET [%151] // return 4 + * block_8 IF_THEN <- [block_7]: + * %142 = RETURN_PTR // return 3 + * %141 = CONST/INT32 3 // 3 + * >> %143 = MEMORY/STORE_LE_32 [%142, %141] // return 3 + * >> %144 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %145 = RET [%141] // return 3 + * block_5 IF_THEN <- [block_4]: + * %132 = RETURN_PTR // return 2 + * %131 = CONST/INT32 2 // 2 + * >> %133 = MEMORY/STORE_LE_32 [%132, %131] // return 2 + * >> %134 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %135 = RET [%131] // return 2 + * block_2 IF_THEN <- [block_1]: + * %122 = RETURN_PTR // return 1 + * %121 = CONST/INT32 1 // 1 + * >> %123 = MEMORY/STORE_LE_32 [%122, %121] // return 1 + * >> %124 = EXIT_SCOPE // { int a = 10, b = 3; // Basic arithmet... + * >> %125 = RET [%121] // return 1 + * } + */ + + + + + + + + + + +int test_arithmetic(void) { + int a = 10, b = 3; + + // Basic arithmetic. + int add = a + b; // 13 + int sub = a - b; // 7 + int mul = a * b; // 30 + int div = a / b; // 3 + int rem = a % b; // 1 + + // Unary. + int neg = -a; // -10 + + // Bitwise. + int band = a & b; // 2 + int bor = a | b; // 11 + int bxor = a ^ b; // 9 + int shl = a << 1; // 20 + int shr = a >> 1; // 5 + int bnot = ~a; // -11 + + // Logical. + int land = a && b; // 1 + int lor = a || 0; // 1 + int lnot = !a; // 0 + + // Comparisons. + int eq = (a == b); // 0 + int ne = (a != b); // 1 + int lt = (a < b); // 0 + int le = (a <= b); // 0 + int gt = (a > b); // 1 + int ge = (a >= b); // 1 + + // Comma operator (LAST_VALUE). + int comma = (1, 2, 3); // 3 + + // Verify all results. + if (add != 13) return 1; + if (sub != 7) return 2; + if (mul != 30) return 3; + if (div != 3) return 4; + if (rem != 1) return 5; + if (neg != -10) return 6; + if (band != 2) return 7; + if (bor != 11) return 8; + if (bxor != 9) return 9; + if (shl != 20) return 10; + if (shr != 5) return 11; + if (bnot != -11) return 12; + if (land != 1) return 13; + if (lor != 1) return 14; + if (lnot != 0) return 15; + if (eq != 0) return 16; + if (ne != 1) return 17; + if (lt != 0) return 18; + if (le != 0) return 19; + if (gt != 1) return 20; + if (ge != 1) return 21; + if (comma != 3) return 22; + + return 0; +} diff --git a/tests/InterpretIR/test_array_decay.c b/tests/InterpretIR/test_array_decay.c new file mode 100644 index 000000000..371d895ff --- /dev/null +++ b/tests/InterpretIR/test_array_decay.c @@ -0,0 +1,285 @@ +// Tests: array-to-pointer decay (ArrayToPointerDecay → EmitLValue, not EmitRValue), +// passing arrays to functions, array parameters adjusted to pointers by Clang. + +/* + * Expected IR: + * + * function test_array_decay (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=20 align=4 (arr) + * obj_1 LOCAL_VALUE size=4 align=4 (total) + * obj_2 LOCAL_VALUE size=4 align=4 (first) + * obj_3 LOCAL_VALUE size=12 align=4 (buf) + * obj_4 LOCAL_VALUE size=8 align=8 (p) + * obj_5 LOCAL_VALUE size=8 align=8 (q) + * obj_6 PARAMETER size=8 align=8 + * obj_7 PARAMETER size=4 align=4 + * obj_8 RETURN_SLOT size=4 align=4 + * obj_9 PARAMETER size=8 align=8 + * obj_10 RETURN_SLOT size=4 align=4 + * obj_11 PARAMETER size=8 align=8 + * obj_12 PARAMETER size=4 align=4 + * obj_13 PARAMETER size=4 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %arr.0 = ALLOCA/LOCAL size=20 align=4 + * >> %total.1 = ALLOCA/LOCAL size=4 align=4 + * >> %first.2 = ALLOCA/LOCAL size=4 align=4 + * >> %buf.3 = ALLOCA/LOCAL size=12 align=4 + * >> %p.4 = ALLOCA/LOCAL size=8 align=8 + * >> %q.5 = ALLOCA/LOCAL size=8 align=8 + * >> %6 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %7 = ENTER_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * %arr.8 = CONST/UINT8 0 + * %arr.9 = CONST/UINT64 20 + * >> %arr.10 = MEMORY/MEMSET [%arr.0, %arr.8, %arr.9] + * %11 = CONST/INT32 10 // 10 + * >> %arr.12 = MEMORY/STORE_LE_32 [%arr.0, %11] + * %arr.13 = CONST/INT64 1 + * %arr.14 = PTR_ADD elem_size=4 [%arr.0, %arr.13] + * %15 = CONST/INT32 20 // 20 + * >> %arr.16 = MEMORY/STORE_LE_32 [%arr.14, %15] + * %arr.17 = CONST/INT64 2 + * %arr.18 = PTR_ADD elem_size=4 [%arr.0, %arr.17] + * %19 = CONST/INT32 30 // 30 + * >> %arr.20 = MEMORY/STORE_LE_32 [%arr.18, %19] + * %arr.21 = CONST/INT64 3 + * %arr.22 = PTR_ADD elem_size=4 [%arr.0, %arr.21] + * %23 = CONST/INT32 40 // 40 + * >> %arr.24 = MEMORY/STORE_LE_32 [%arr.22, %23] + * %arr.25 = CONST/INT64 4 + * %arr.26 = PTR_ADD elem_size=4 [%arr.0, %arr.25] + * %27 = CONST/INT32 50 // 50 + * >> %arr.28 = MEMORY/STORE_LE_32 [%arr.26, %27] + * >> %29 = ENTER_SCOPE // sum_array(arr, 5) + * %30 = ALLOCA/ARG size=8 align=8 // arr + * >> %31 = MEMORY/STORE_LE_64 [%30, %arr.0] // arr + * %33 = ALLOCA/ARG size=4 align=4 // 5 + * %32 = CONST/INT32 5 // 5 + * >> %34 = MEMORY/STORE_LE_32 [%33, %32] // 5 + * %total.1 = ALLOCA/LOCAL size=4 align=4 + * %36 = CALL @sum_array [%30, %33] // sum_array(arr, 5) + * >> %total.37 = MEMORY/STORE_LE_32 [%total.1, %36] + * >> %41 = EXIT_SCOPE + * %38 = MEMORY/LOAD_LE_32 [%total.1] // total + * %39 = CONST/INT32 150 // 150 + * %40 = CMP_NE [%38, %39] // total != 150 + * >> %42 = COND_BRANCH [%40] // if (total != 150) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %49 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * >> %50 = ENTER_SCOPE // first_element(arr) + * %51 = ALLOCA/ARG size=8 align=8 // arr + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * >> %52 = MEMORY/STORE_LE_64 [%51, %arr.0] // arr + * %first.2 = ALLOCA/LOCAL size=4 align=4 + * %54 = CALL @first_element [%51] // first_element(arr) + * >> %first.55 = MEMORY/STORE_LE_32 [%first.2, %54] + * >> %59 = EXIT_SCOPE + * %56 = MEMORY/LOAD_LE_32 [%first.2] // first + * %57 = CONST/INT32 10 // 10 + * %58 = CMP_NE [%56, %57] // first != 10 + * >> %60 = COND_BRANCH [%58] // if (first != 10) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %67 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * >> %68 = ENTER_SCOPE // fill_array(buf, 42, 3) + * %69 = ALLOCA/ARG size=8 align=8 // buf + * %buf.3 = ALLOCA/LOCAL size=12 align=4 + * >> %70 = MEMORY/STORE_LE_64 [%69, %buf.3] // buf + * %72 = ALLOCA/ARG size=4 align=4 // 42 + * %71 = CONST/INT32 42 // 42 + * >> %73 = MEMORY/STORE_LE_32 [%72, %71] // 42 + * %75 = ALLOCA/ARG size=4 align=4 // 3 + * %74 = CONST/INT32 3 // 3 + * >> %76 = MEMORY/STORE_LE_32 [%75, %74] // 3 + * >> %77 = CALL @fill_array [%69, %72, %75] // fill_array(buf, 42, 3) + * >> %78 = EXIT_SCOPE + * %79 = CONST/INT32 0 // 0 + * %80 = PTR_ADD elem_size=4 [%buf.3, %79] // buf[0] + * %81 = MEMORY/LOAD_LE_32 [%80] // buf[0] + * %82 = CONST/INT32 42 // 42 + * %83 = CMP_NE [%81, %82] // buf[0] != 42 + * >> %84 = COND_BRANCH [%83] // if (buf[0] != 42) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %90 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %buf.3 = ALLOCA/LOCAL size=12 align=4 + * %91 = CONST/INT32 1 // 1 + * %92 = PTR_ADD elem_size=4 [%buf.3, %91] // buf[1] + * %93 = MEMORY/LOAD_LE_32 [%92] // buf[1] + * %94 = CONST/INT32 42 // 42 + * %95 = CMP_NE [%93, %94] // buf[1] != 42 + * >> %96 = COND_BRANCH [%95] // if (buf[1] != 42) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %102 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %buf.3 = ALLOCA/LOCAL size=12 align=4 + * %103 = CONST/INT32 2 // 2 + * %104 = PTR_ADD elem_size=4 [%buf.3, %103] // buf[2] + * %105 = MEMORY/LOAD_LE_32 [%104] // buf[2] + * %106 = CONST/INT32 42 // 42 + * %107 = CMP_NE [%105, %106] // buf[2] != 42 + * >> %108 = COND_BRANCH [%107] // if (buf[2] != 42) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %114 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %p.4 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * >> %p.115 = MEMORY/STORE_LE_64 [%p.4, %arr.0] + * %116 = MEMORY/LOAD_LE_64 [%p.4] // p + * %117 = CONST/INT32 2 // 2 + * %118 = PTR_ADD elem_size=4 [%116, %117] // p[2] + * %119 = CONST/INT32 99 // 99 + * >> %120 = MEMORY/STORE_LE_32 [%118, %119] // p[2] = 99 + * %121 = CONST/INT32 2 // 2 + * %122 = PTR_ADD elem_size=4 [%arr.0, %121] // arr[2] + * %123 = MEMORY/LOAD_LE_32 [%122] // arr[2] + * %124 = CONST/INT32 99 // 99 + * %125 = CMP_NE [%123, %124] // arr[2] != 99 + * >> %126 = COND_BRANCH [%125] // if (arr[2] != 99) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %132 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %q.5 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * %133 = CONST/INT32 3 // 3 + * %134 = PTR_ADD elem_size=4 [%arr.0, %133] // arr + 3 + * >> %q.135 = MEMORY/STORE_LE_64 [%q.5, %134] + * %136 = MEMORY/LOAD_LE_64 [%q.5] // q + * %137 = MEMORY/LOAD_LE_32 [%136] // *q + * %138 = CONST/INT32 40 // 40 + * %139 = CMP_NE [%137, %138] // *q != 40 + * >> %140 = COND_BRANCH [%139] // if (*q != 40) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %146 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %148 = RETURN_PTR // return 0 + * %147 = CONST/INT32 0 // 0 + * >> %149 = MEMORY/STORE_LE_32 [%148, %147] // return 0 + * >> %150 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %151 = RET [%147] // return 0 + * block_20 IF_THEN <- [block_19]: + * %142 = RETURN_PTR // return 7 + * %141 = CONST/INT32 7 // 7 + * >> %143 = MEMORY/STORE_LE_32 [%142, %141] // return 7 + * >> %144 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %145 = RET [%141] // return 7 + * block_17 IF_THEN <- [block_16]: + * %128 = RETURN_PTR // return 6 + * %127 = CONST/INT32 6 // 6 + * >> %129 = MEMORY/STORE_LE_32 [%128, %127] // return 6 + * >> %130 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %131 = RET [%127] // return 6 + * block_14 IF_THEN <- [block_13]: + * %110 = RETURN_PTR // return 5 + * %109 = CONST/INT32 5 // 5 + * >> %111 = MEMORY/STORE_LE_32 [%110, %109] // return 5 + * >> %112 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %113 = RET [%109] // return 5 + * block_11 IF_THEN <- [block_10]: + * %98 = RETURN_PTR // return 4 + * %97 = CONST/INT32 4 // 4 + * >> %99 = MEMORY/STORE_LE_32 [%98, %97] // return 4 + * >> %100 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %101 = RET [%97] // return 4 + * block_8 IF_THEN <- [block_7]: + * %86 = RETURN_PTR // return 3 + * %85 = CONST/INT32 3 // 3 + * >> %87 = MEMORY/STORE_LE_32 [%86, %85] // return 3 + * >> %88 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %89 = RET [%85] // return 3 + * block_5 IF_THEN <- [block_4]: + * %62 = RETURN_PTR // return 2 + * %61 = CONST/INT32 2 // 2 + * >> %63 = MEMORY/STORE_LE_32 [%62, %61] // return 2 + * >> %64 = EXIT_SCOPE // first_element(arr) + * >> %65 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %66 = RET [%61] // return 2 + * block_2 IF_THEN <- [block_1]: + * %44 = RETURN_PTR // return 1 + * %43 = CONST/INT32 1 // 1 + * >> %45 = MEMORY/STORE_LE_32 [%44, %43] // return 1 + * >> %46 = EXIT_SCOPE // sum_array(arr, 5) + * >> %47 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %48 = RET [%43] // return 1 + * } + */ + + + + + + + + + + +static int sum_array(int *arr, int n) { + int total = 0; + for (int i = 0; i < n; i++) { + total += arr[i]; + } + return total; +} + +static int first_element(int arr[10]) { + // Clang adjusts int arr[10] to int *arr. + return arr[0]; +} + +static void fill_array(int *dst, int val, int n) { + for (int i = 0; i < n; i++) { + dst[i] = val; + } +} + +int test_array_decay(void) { + int arr[5] = {10, 20, 30, 40, 50}; + + // Pass array to function — array decays to pointer. + // The ALLOCA for arr IS the decayed pointer. + int total = sum_array(arr, 5); + if (total != 150) return 1; + + // Pass array with explicit size in parameter type. + int first = first_element(arr); + if (first != 10) return 2; + + // Pass array to function that modifies it. + int buf[3]; + fill_array(buf, 42, 3); + if (buf[0] != 42) return 3; + if (buf[1] != 42) return 4; + if (buf[2] != 42) return 5; + + // Assign array element via decayed pointer. + int *p = arr; + p[2] = 99; + if (arr[2] != 99) return 6; + + // Array decay in expressions. + int *q = arr + 3; + if (*q != 40) return 7; + + return 0; +} diff --git a/tests/InterpretIR/test_bitfields.c b/tests/InterpretIR/test_bitfields.c new file mode 100644 index 000000000..490028e7f --- /dev/null +++ b/tests/InterpretIR/test_bitfields.c @@ -0,0 +1,276 @@ +// Tests: bit-field access (BIT_READ_LE/BE, BIT_WRITE_LE/BE), +// bit-field initialization, reading back bit-field values, +// and bit-field in compound expressions. + +/* + * Expected IR: + * + * function test_bitfields (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (f) + * obj_1 LOCAL_VALUE size=4 align=4 (g) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %f.0 = ALLOCA/LOCAL size=4 align=4 + * >> %g.1 = ALLOCA/LOCAL size=4 align=4 + * >> %2 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %3 = ENTER_SCOPE // { struct Flags f = {0}; // Write indiv... + * %f.0 = ALLOCA/LOCAL size=4 align=4 + * %f.4 = CONST/UINT8 0 + * %f.5 = CONST/UINT64 4 + * >> %f.6 = MEMORY/MEMSET [%f.0, %f.4, %f.5] + * %7 = CONST/INT32 0 // 0 + * %8 = CAST/IDENTITY [%7] // 0 + * >> %f.9 = MEMORY/BIT_WRITE_LE off=0 w=1 [%f.0, %8] + * %10 = CONST/INT32 0 + * >> %f.11 = MEMORY/BIT_WRITE_LE off=1 w=1 [%f.0, %10] + * %12 = CONST/INT32 0 + * >> %f.13 = MEMORY/BIT_WRITE_LE off=2 w=1 [%f.0, %12] + * %14 = CONST/INT32 0 + * >> %f.15 = MEMORY/BIT_WRITE_LE off=3 w=4 [%f.0, %14] + * %16 = CONST/INT32 0 + * >> %f.17 = MEMORY/BIT_WRITE_LE off=7 w=25 [%f.0, %16] + * %18 = CONST/INT32 1 // 1 + * %19 = CAST/IDENTITY [%18] // 1 + * >> %20 = MEMORY/BIT_WRITE_LE off=0 w=1 [%f.0, %19] // f.read = 1 + * %21 = CONST/INT32 0 // 0 + * %22 = CAST/IDENTITY [%21] // 0 + * >> %23 = MEMORY/BIT_WRITE_LE off=1 w=1 [%f.0, %22] // f.write = 0 + * %24 = CONST/INT32 1 // 1 + * %25 = CAST/IDENTITY [%24] // 1 + * >> %26 = MEMORY/BIT_WRITE_LE off=2 w=1 [%f.0, %25] // f.exec = 1 + * %27 = CONST/INT32 7 // 7 + * %28 = CAST/IDENTITY [%27] // 7 + * >> %29 = MEMORY/BIT_WRITE_LE off=3 w=4 [%f.0, %28] // f.mode = 7 + * %30 = MEMORY/BIT_READ_LE off=0 w=1 [%f.0] // f.read + * %31 = CAST/IDENTITY [%30] // f.read + * %32 = CONST/INT32 1 // 1 + * %33 = CMP_NE [%31, %32] // f.read != 1 + * >> %34 = COND_BRANCH [%33] // if (f.read != 1) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %40 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %f.0 = ALLOCA/LOCAL size=4 align=4 + * %41 = MEMORY/BIT_READ_LE off=1 w=1 [%f.0] // f.write + * %42 = CAST/IDENTITY [%41] // f.write + * %43 = CONST/INT32 0 // 0 + * %44 = CMP_NE [%42, %43] // f.write != 0 + * >> %45 = COND_BRANCH [%44] // if (f.write != 0) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %51 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %f.0 = ALLOCA/LOCAL size=4 align=4 + * %52 = MEMORY/BIT_READ_LE off=2 w=1 [%f.0] // f.exec + * %53 = CAST/IDENTITY [%52] // f.exec + * %54 = CONST/INT32 1 // 1 + * %55 = CMP_NE [%53, %54] // f.exec != 1 + * >> %56 = COND_BRANCH [%55] // if (f.exec != 1) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %62 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %f.0 = ALLOCA/LOCAL size=4 align=4 + * %63 = MEMORY/BIT_READ_LE off=3 w=4 [%f.0] // f.mode + * %64 = CAST/IDENTITY [%63] // f.mode + * %65 = CONST/INT32 7 // 7 + * %66 = CMP_NE [%64, %65] // f.mode != 7 + * >> %67 = COND_BRANCH [%66] // if (f.mode != 7) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %73 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %g.1 = ALLOCA/LOCAL size=4 align=4 + * %g.74 = CONST/UINT8 0 + * %g.75 = CONST/UINT64 4 + * >> %g.76 = MEMORY/MEMSET [%g.1, %g.74, %g.75] + * %77 = CONST/INT32 1 // 1 + * %78 = CAST/IDENTITY [%77] // 1 + * >> %g.79 = MEMORY/BIT_WRITE_LE off=0 w=1 [%g.1, %78] + * %80 = CONST/INT32 1 // 1 + * %81 = CAST/IDENTITY [%80] // 1 + * >> %g.82 = MEMORY/BIT_WRITE_LE off=1 w=1 [%g.1, %81] + * %83 = CONST/INT32 0 // 0 + * %84 = CAST/IDENTITY [%83] // 0 + * >> %g.85 = MEMORY/BIT_WRITE_LE off=2 w=1 [%g.1, %84] + * %86 = CONST/INT32 5 // 5 + * %87 = CAST/IDENTITY [%86] // 5 + * >> %g.88 = MEMORY/BIT_WRITE_LE off=3 w=4 [%g.1, %87] + * %89 = CONST/INT32 0 + * >> %g.90 = MEMORY/BIT_WRITE_LE off=7 w=25 [%g.1, %89] + * %91 = MEMORY/BIT_READ_LE off=0 w=1 [%g.1] // g.read + * %92 = CAST/IDENTITY [%91] // g.read + * %93 = CONST/INT32 1 // 1 + * %94 = CMP_NE [%92, %93] // g.read != 1 + * >> %95 = COND_BRANCH [%94] // if (g.read != 1) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %101 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %g.1 = ALLOCA/LOCAL size=4 align=4 + * %102 = MEMORY/BIT_READ_LE off=1 w=1 [%g.1] // g.write + * %103 = CAST/IDENTITY [%102] // g.write + * %104 = CONST/INT32 1 // 1 + * %105 = CMP_NE [%103, %104] // g.write != 1 + * >> %106 = COND_BRANCH [%105] // if (g.write != 1) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %112 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %g.1 = ALLOCA/LOCAL size=4 align=4 + * %113 = MEMORY/BIT_READ_LE off=2 w=1 [%g.1] // g.exec + * %114 = CAST/IDENTITY [%113] // g.exec + * %115 = CONST/INT32 0 // 0 + * %116 = CMP_NE [%114, %115] // g.exec != 0 + * >> %117 = COND_BRANCH [%116] // if (g.exec != 0) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %123 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %g.1 = ALLOCA/LOCAL size=4 align=4 + * %124 = MEMORY/BIT_READ_LE off=3 w=4 [%g.1] // g.mode + * %125 = CAST/IDENTITY [%124] // g.mode + * %126 = CONST/INT32 5 // 5 + * %127 = CMP_NE [%125, %126] // g.mode != 5 + * >> %128 = COND_BRANCH [%127] // if (g.mode != 5) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %134 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %f.0 = ALLOCA/LOCAL size=4 align=4 + * %135 = MEMORY/BIT_READ_LE off=3 w=4 [%f.0] // f.mode + * %136 = CAST/IDENTITY [%135] // f.mode + * %137 = CONST/INT32 3 // 3 + * %138 = BIT_AND [%136, %137] // f.mode & 3 + * %139 = CAST/IDENTITY [%138] // f.mode & 3 + * >> %140 = MEMORY/BIT_WRITE_LE off=3 w=4 [%f.0, %139] // f.mode = f.mode & 3 + * %141 = MEMORY/BIT_READ_LE off=3 w=4 [%f.0] // f.mode + * %142 = CAST/IDENTITY [%141] // f.mode + * %143 = CONST/INT32 3 // 3 + * %144 = CMP_NE [%142, %143] // f.mode != 3 + * >> %145 = COND_BRANCH [%144] // if (f.mode != 3) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %151 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %153 = RETURN_PTR // return 0 + * %152 = CONST/INT32 0 // 0 + * >> %154 = MEMORY/STORE_LE_32 [%153, %152] // return 0 + * >> %155 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %156 = RET [%152] // return 0 + * block_26 IF_THEN <- [block_25]: + * %147 = RETURN_PTR // return 9 + * %146 = CONST/INT32 9 // 9 + * >> %148 = MEMORY/STORE_LE_32 [%147, %146] // return 9 + * >> %149 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %150 = RET [%146] // return 9 + * block_23 IF_THEN <- [block_22]: + * %130 = RETURN_PTR // return 8 + * %129 = CONST/INT32 8 // 8 + * >> %131 = MEMORY/STORE_LE_32 [%130, %129] // return 8 + * >> %132 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %133 = RET [%129] // return 8 + * block_20 IF_THEN <- [block_19]: + * %119 = RETURN_PTR // return 7 + * %118 = CONST/INT32 7 // 7 + * >> %120 = MEMORY/STORE_LE_32 [%119, %118] // return 7 + * >> %121 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %122 = RET [%118] // return 7 + * block_17 IF_THEN <- [block_16]: + * %108 = RETURN_PTR // return 6 + * %107 = CONST/INT32 6 // 6 + * >> %109 = MEMORY/STORE_LE_32 [%108, %107] // return 6 + * >> %110 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %111 = RET [%107] // return 6 + * block_14 IF_THEN <- [block_13]: + * %97 = RETURN_PTR // return 5 + * %96 = CONST/INT32 5 // 5 + * >> %98 = MEMORY/STORE_LE_32 [%97, %96] // return 5 + * >> %99 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %100 = RET [%96] // return 5 + * block_11 IF_THEN <- [block_10]: + * %69 = RETURN_PTR // return 4 + * %68 = CONST/INT32 4 // 4 + * >> %70 = MEMORY/STORE_LE_32 [%69, %68] // return 4 + * >> %71 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %72 = RET [%68] // return 4 + * block_8 IF_THEN <- [block_7]: + * %58 = RETURN_PTR // return 3 + * %57 = CONST/INT32 3 // 3 + * >> %59 = MEMORY/STORE_LE_32 [%58, %57] // return 3 + * >> %60 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %61 = RET [%57] // return 3 + * block_5 IF_THEN <- [block_4]: + * %47 = RETURN_PTR // return 2 + * %46 = CONST/INT32 2 // 2 + * >> %48 = MEMORY/STORE_LE_32 [%47, %46] // return 2 + * >> %49 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %50 = RET [%46] // return 2 + * block_2 IF_THEN <- [block_1]: + * %36 = RETURN_PTR // return 1 + * %35 = CONST/INT32 1 // 1 + * >> %37 = MEMORY/STORE_LE_32 [%36, %35] // return 1 + * >> %38 = EXIT_SCOPE // { struct Flags f = {0}; // Write indiv... + * >> %39 = RET [%35] // return 1 + * } + */ + + + + + + + + + + +struct Flags { + unsigned int read : 1; + unsigned int write : 1; + unsigned int exec : 1; + unsigned int mode : 4; + unsigned int pad : 25; +}; + +int test_bitfields(void) { + struct Flags f = {0}; + + // Write individual bit-fields. + f.read = 1; + f.write = 0; + f.exec = 1; + f.mode = 7; + + // Read back. + if (f.read != 1) return 1; + if (f.write != 0) return 2; + if (f.exec != 1) return 3; + if (f.mode != 7) return 4; + + // Init list for bit-fields. + struct Flags g = {1, 1, 0, 5}; + if (g.read != 1) return 5; + if (g.write != 1) return 6; + if (g.exec != 0) return 7; + if (g.mode != 5) return 8; + + // Modify via compound assignment. + f.mode = f.mode & 3; + if (f.mode != 3) return 9; + + return 0; +} diff --git a/tests/InterpretIR/test_byvalue.c b/tests/InterpretIR/test_byvalue.c new file mode 100644 index 000000000..0ab1abd71 --- /dev/null +++ b/tests/InterpretIR/test_byvalue.c @@ -0,0 +1,450 @@ +// Tests: by-value struct parameters and returns, exercising the full +// EXPRESSION_SCOPE → ALLOCA/ARG → PARAM_PTR → RETURN_PTR → ALLOCA/RETURN +// chain for both small (≤8 byte) and large (>8 byte) structs. + +/* + * Expected IR: + * + * function test_byvalue (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=8 align=4 (s) + * obj_1 LOCAL_VALUE size=4 align=4 (sum) + * obj_2 LOCAL_VALUE size=20 align=4 (l) + * obj_3 LOCAL_VALUE size=4 align=4 (lsum) + * obj_4 LOCAL_VALUE size=3 align=1 (p) + * obj_5 LOCAL_VALUE size=4 align=4 (psum) + * obj_6 LOCAL_VALUE size=8 align=4 (s2) + * obj_7 LOCAL_VALUE size=4 align=4 (chained) + * obj_8 LOCAL_VALUE size=4 align=4 (nested) + * obj_9 PARAMETER size=4 align=4 + * obj_10 PARAMETER size=4 align=4 + * obj_11 RETURN_SLOT size=8 align=4 + * obj_12 PARAMETER size=8 align=4 + * obj_13 RETURN_SLOT size=4 align=4 + * obj_14 PARAMETER size=4 align=4 + * obj_15 RETURN_SLOT size=20 align=4 + * obj_16 PARAMETER size=20 align=4 + * obj_17 RETURN_SLOT size=4 align=4 + * obj_18 PARAMETER size=3 align=1 + * obj_19 RETURN_SLOT size=4 align=4 + * obj_20 PARAMETER size=8 align=4 + * obj_21 RETURN_SLOT size=8 align=4 + * obj_22 PARAMETER size=4 align=4 + * obj_23 PARAMETER size=4 align=4 + * obj_24 RETURN_SLOT size=4 align=4 + * obj_25 PARAMETER size=4 align=4 + * obj_26 PARAMETER size=4 align=4 + * obj_27 RETURN_SLOT size=8 align=4 + * obj_28 PARAMETER size=8 align=4 + * obj_29 RETURN_SLOT size=4 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %s.0 = ALLOCA/LOCAL size=8 align=4 + * >> %sum.1 = ALLOCA/LOCAL size=4 align=4 + * >> %l.2 = ALLOCA/LOCAL size=20 align=4 + * >> %lsum.3 = ALLOCA/LOCAL size=4 align=4 + * >> %p.4 = ALLOCA/LOCAL size=3 align=1 + * >> %psum.5 = ALLOCA/LOCAL size=4 align=4 + * >> %s2.6 = ALLOCA/LOCAL size=8 align=4 + * >> %chained.7 = ALLOCA/LOCAL size=4 align=4 + * >> %nested.8 = ALLOCA/LOCAL size=4 align=4 + * >> %9 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %10 = ENTER_SCOPE // { // Small struct return. struct Small ... + * >> %11 = ENTER_SCOPE // make_small(10, 20) + * %13 = ALLOCA/ARG size=4 align=4 // 10 + * %12 = CONST/INT32 10 // 10 + * >> %14 = MEMORY/STORE_LE_32 [%13, %12] // 10 + * %16 = ALLOCA/ARG size=4 align=4 // 20 + * %15 = CONST/INT32 20 // 20 + * >> %17 = MEMORY/STORE_LE_32 [%16, %15] // 20 + * %s.0 = ALLOCA/LOCAL size=8 align=4 + * %19 = CALL @make_small [%13, %16] // make_small(10, 20) + * %20 = CONST/UINT64 8 + * >> %s.21 = MEMORY/MEMCPY [%s.0, %19, %20] + * >> %26 = EXIT_SCOPE + * %22 = GEP_FIELD offset=0 .x [%s.0] // s.x + * %23 = MEMORY/LOAD_LE_32 [%22] // s.x + * %24 = CONST/INT32 10 // 10 + * %25 = CMP_NE [%23, %24] // s.x != 10 + * >> %27 = COND_BRANCH [%25] // if (s.x != 10) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %34 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %s.0 = ALLOCA/LOCAL size=8 align=4 + * %35 = GEP_FIELD offset=4 .y [%s.0] // s.y + * %36 = MEMORY/LOAD_LE_32 [%35] // s.y + * %37 = CONST/INT32 20 // 20 + * %38 = CMP_NE [%36, %37] // s.y != 20 + * >> %39 = COND_BRANCH [%38] // if (s.y != 20) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %45 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * >> %46 = ENTER_SCOPE // sum_small(s) + * %48 = ALLOCA/ARG size=8 align=4 // s + * %s.0 = ALLOCA/LOCAL size=8 align=4 + * %47 = MEMORY/LOAD_LE_64 [%s.0] // s + * >> %49 = MEMORY/STORE_LE_64 [%48, %47] // s + * %sum.1 = ALLOCA/LOCAL size=4 align=4 + * %51 = CALL @sum_small [%48] // sum_small(s) + * >> %sum.52 = MEMORY/STORE_LE_32 [%sum.1, %51] + * >> %56 = EXIT_SCOPE + * %53 = MEMORY/LOAD_LE_32 [%sum.1] // sum + * %54 = CONST/INT32 30 // 30 + * %55 = CMP_NE [%53, %54] // sum != 30 + * >> %57 = COND_BRANCH [%55] // if (sum != 30) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %64 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * >> %65 = ENTER_SCOPE // make_large(100) + * %67 = ALLOCA/ARG size=4 align=4 // 100 + * %66 = CONST/INT32 100 // 100 + * >> %68 = MEMORY/STORE_LE_32 [%67, %66] // 100 + * %l.2 = ALLOCA/LOCAL size=20 align=4 + * %70 = CALL @make_large [%67] // make_large(100) + * %71 = CONST/UINT64 20 + * >> %l.72 = MEMORY/MEMCPY [%l.2, %70, %71] + * >> %77 = EXIT_SCOPE + * %73 = GEP_FIELD offset=0 .a [%l.2] // l.a + * %74 = MEMORY/LOAD_LE_32 [%73] // l.a + * %75 = CONST/INT32 100 // 100 + * %76 = CMP_NE [%74, %75] // l.a != 100 + * >> %78 = COND_BRANCH [%76] // if (l.a != 100) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %85 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %l.2 = ALLOCA/LOCAL size=20 align=4 + * %86 = GEP_FIELD offset=16 .e [%l.2] // l.e + * %87 = MEMORY/LOAD_LE_32 [%86] // l.e + * %88 = CONST/INT32 104 // 104 + * %89 = CMP_NE [%87, %88] // l.e != 104 + * >> %90 = COND_BRANCH [%89] // if (l.e != 104) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %96 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * >> %97 = ENTER_SCOPE // sum_large(l) + * %98 = ALLOCA/ARG size=20 align=4 // l + * %l.2 = ALLOCA/LOCAL size=20 align=4 + * %99 = CONST/UINT64 20 + * >> %100 = MEMORY/MEMCPY [%98, %l.2, %99] // l + * %lsum.3 = ALLOCA/LOCAL size=4 align=4 + * %102 = CALL @sum_large [%98] // sum_large(l) + * >> %lsum.103 = MEMORY/STORE_LE_32 [%lsum.3, %102] + * >> %107 = EXIT_SCOPE + * %104 = MEMORY/LOAD_LE_32 [%lsum.3] // lsum + * %105 = CONST/INT32 510 // 510 + * %106 = CMP_NE [%104, %105] // lsum != 510 + * >> %108 = COND_BRANCH [%106] // if (lsum != 510) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %115 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %p.4 = ALLOCA/LOCAL size=3 align=1 + * %116 = GEP_FIELD offset=0 .a [%p.4] // p.a + * %117 = CONST/INT32 1 // 1 + * %118 = CAST/TRUNC_I32_I8 [%117] // 1 + * >> %119 = MEMORY/STORE_LE_8 [%116, %118] // p.a = 1 + * %120 = GEP_FIELD offset=1 .b [%p.4] // p.b + * %121 = CONST/INT32 2 // 2 + * %122 = CAST/TRUNC_I32_I8 [%121] // 2 + * >> %123 = MEMORY/STORE_LE_8 [%120, %122] // p.b = 2 + * %124 = GEP_FIELD offset=2 .c [%p.4] // p.c + * %125 = CONST/INT32 3 // 3 + * %126 = CAST/TRUNC_I32_I8 [%125] // 3 + * >> %127 = MEMORY/STORE_LE_8 [%124, %126] // p.c = 3 + * >> %128 = ENTER_SCOPE // sum_packed3(p) + * %129 = ALLOCA/ARG size=3 align=1 // p + * %130 = CONST/UINT64 3 + * >> %131 = MEMORY/MEMCPY [%129, %p.4, %130] // p + * %psum.5 = ALLOCA/LOCAL size=4 align=4 + * %133 = CALL @sum_packed3 [%129] // sum_packed3(p) + * >> %psum.134 = MEMORY/STORE_LE_32 [%psum.5, %133] + * >> %138 = EXIT_SCOPE + * %135 = MEMORY/LOAD_LE_32 [%psum.5] // psum + * %136 = CONST/INT32 6 // 6 + * %137 = CMP_NE [%135, %136] // psum != 6 + * >> %139 = COND_BRANCH [%137] // if (psum != 6) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %146 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * >> %147 = ENTER_SCOPE // identity_small(s) + * %149 = ALLOCA/ARG size=8 align=4 // s + * %s.0 = ALLOCA/LOCAL size=8 align=4 + * %148 = MEMORY/LOAD_LE_64 [%s.0] // s + * >> %150 = MEMORY/STORE_LE_64 [%149, %148] // s + * %s2.6 = ALLOCA/LOCAL size=8 align=4 + * %152 = CALL @identity_small [%149] // identity_small(s) + * %153 = CONST/UINT64 8 + * >> %s2.154 = MEMORY/MEMCPY [%s2.6, %152, %153] + * >> %159 = EXIT_SCOPE + * %155 = GEP_FIELD offset=0 .x [%s2.6] // s2.x + * %156 = MEMORY/LOAD_LE_32 [%155] // s2.x + * %157 = CONST/INT32 10 // 10 + * %158 = CMP_NE [%156, %157] // s2.x != 10 + * >> %160 = COND_BRANCH [%158] // if (s2.x != 10) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %167 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %s2.6 = ALLOCA/LOCAL size=8 align=4 + * %168 = GEP_FIELD offset=4 .y [%s2.6] // s2.y + * %169 = MEMORY/LOAD_LE_32 [%168] // s2.y + * %170 = CONST/INT32 20 // 20 + * %171 = CMP_NE [%169, %170] // s2.y != 20 + * >> %172 = COND_BRANCH [%171] // if (s2.y != 20) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %178 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * >> %179 = ENTER_SCOPE // chain_test(5, 15) + * %181 = ALLOCA/ARG size=4 align=4 // 5 + * %180 = CONST/INT32 5 // 5 + * >> %182 = MEMORY/STORE_LE_32 [%181, %180] // 5 + * %184 = ALLOCA/ARG size=4 align=4 // 15 + * %183 = CONST/INT32 15 // 15 + * >> %185 = MEMORY/STORE_LE_32 [%184, %183] // 15 + * %chained.7 = ALLOCA/LOCAL size=4 align=4 + * %187 = CALL @chain_test [%181, %184] // chain_test(5, 15) + * >> %chained.188 = MEMORY/STORE_LE_32 [%chained.7, %187] + * >> %192 = EXIT_SCOPE + * %189 = MEMORY/LOAD_LE_32 [%chained.7] // chained + * %190 = CONST/INT32 20 // 20 + * %191 = CMP_NE [%189, %190] // chained != 20 + * >> %193 = COND_BRANCH [%191] // if (chained != 20) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %200 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * >> %201 = ENTER_SCOPE // sum_small(make_small(1, 2)) + * %203 = ALLOCA/ARG size=4 align=4 // 1 + * %202 = CONST/INT32 1 // 1 + * >> %204 = MEMORY/STORE_LE_32 [%203, %202] // 1 + * %206 = ALLOCA/ARG size=4 align=4 // 2 + * %205 = CONST/INT32 2 // 2 + * >> %207 = MEMORY/STORE_LE_32 [%206, %205] // 2 + * %210 = ALLOCA/ARG size=8 align=4 // make_small(1, 2) + * %209 = CALL @make_small [%203, %206] // make_small(1, 2) + * >> %211 = MEMORY/STORE_LE_64 [%210, %209] // make_small(1, 2) + * %nested.8 = ALLOCA/LOCAL size=4 align=4 + * %213 = CALL @sum_small [%210] // sum_small(make_small(1, 2)) + * >> %nested.214 = MEMORY/STORE_LE_32 [%nested.8, %213] + * >> %218 = EXIT_SCOPE + * %215 = MEMORY/LOAD_LE_32 [%nested.8] // nested + * %216 = CONST/INT32 3 // 3 + * %217 = CMP_NE [%215, %216] // nested != 3 + * >> %219 = COND_BRANCH [%217] // if (nested != 3) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %226 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %228 = RETURN_PTR // return 0 + * %227 = CONST/INT32 0 // 0 + * >> %229 = MEMORY/STORE_LE_32 [%228, %227] // return 0 + * >> %230 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %231 = RET [%227] // return 0 + * block_32 IF_THEN <- [block_31]: + * %221 = RETURN_PTR // return 11 + * %220 = CONST/INT32 11 // 11 + * >> %222 = MEMORY/STORE_LE_32 [%221, %220] // return 11 + * >> %223 = EXIT_SCOPE // sum_small(make_small(1, 2)) + * >> %224 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %225 = RET [%220] // return 11 + * block_29 IF_THEN <- [block_28]: + * %195 = RETURN_PTR // return 10 + * %194 = CONST/INT32 10 // 10 + * >> %196 = MEMORY/STORE_LE_32 [%195, %194] // return 10 + * >> %197 = EXIT_SCOPE // chain_test(5, 15) + * >> %198 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %199 = RET [%194] // return 10 + * block_26 IF_THEN <- [block_25]: + * %174 = RETURN_PTR // return 9 + * %173 = CONST/INT32 9 // 9 + * >> %175 = MEMORY/STORE_LE_32 [%174, %173] // return 9 + * >> %176 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %177 = RET [%173] // return 9 + * block_23 IF_THEN <- [block_22]: + * %162 = RETURN_PTR // return 8 + * %161 = CONST/INT32 8 // 8 + * >> %163 = MEMORY/STORE_LE_32 [%162, %161] // return 8 + * >> %164 = EXIT_SCOPE // identity_small(s) + * >> %165 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %166 = RET [%161] // return 8 + * block_20 IF_THEN <- [block_19]: + * %141 = RETURN_PTR // return 7 + * %140 = CONST/INT32 7 // 7 + * >> %142 = MEMORY/STORE_LE_32 [%141, %140] // return 7 + * >> %143 = EXIT_SCOPE // sum_packed3(p) + * >> %144 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %145 = RET [%140] // return 7 + * block_17 IF_THEN <- [block_16]: + * %110 = RETURN_PTR // return 6 + * %109 = CONST/INT32 6 // 6 + * >> %111 = MEMORY/STORE_LE_32 [%110, %109] // return 6 + * >> %112 = EXIT_SCOPE // sum_large(l) + * >> %113 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %114 = RET [%109] // return 6 + * block_14 IF_THEN <- [block_13]: + * %92 = RETURN_PTR // return 5 + * %91 = CONST/INT32 5 // 5 + * >> %93 = MEMORY/STORE_LE_32 [%92, %91] // return 5 + * >> %94 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %95 = RET [%91] // return 5 + * block_11 IF_THEN <- [block_10]: + * %80 = RETURN_PTR // return 4 + * %79 = CONST/INT32 4 // 4 + * >> %81 = MEMORY/STORE_LE_32 [%80, %79] // return 4 + * >> %82 = EXIT_SCOPE // make_large(100) + * >> %83 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %84 = RET [%79] // return 4 + * block_8 IF_THEN <- [block_7]: + * %59 = RETURN_PTR // return 3 + * %58 = CONST/INT32 3 // 3 + * >> %60 = MEMORY/STORE_LE_32 [%59, %58] // return 3 + * >> %61 = EXIT_SCOPE // sum_small(s) + * >> %62 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %63 = RET [%58] // return 3 + * block_5 IF_THEN <- [block_4]: + * %41 = RETURN_PTR // return 2 + * %40 = CONST/INT32 2 // 2 + * >> %42 = MEMORY/STORE_LE_32 [%41, %40] // return 2 + * >> %43 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %44 = RET [%40] // return 2 + * block_2 IF_THEN <- [block_1]: + * %29 = RETURN_PTR // return 1 + * %28 = CONST/INT32 1 // 1 + * >> %30 = MEMORY/STORE_LE_32 [%29, %28] // return 1 + * >> %31 = EXIT_SCOPE // make_small(10, 20) + * >> %32 = EXIT_SCOPE // { // Small struct return. struct Small ... + * >> %33 = RET [%28] // return 1 + * } + */ + + + + + + + + + + +struct Small { + int x; + int y; +}; + +struct Large { + int a, b, c, d, e; // 20 bytes +}; + +struct Packed3 { + char a, b, c; // 3 bytes — non-power-of-2, must use MEMCPY +}; + +// Return a small struct by value. +static struct Small make_small(int x, int y) { + struct Small s; + s.x = x; + s.y = y; + return s; +} + +// Return a large struct by value. +static struct Large make_large(int base) { + struct Large l; + l.a = base; + l.b = base + 1; + l.c = base + 2; + l.d = base + 3; + l.e = base + 4; + return l; +} + +// Take a small struct by value, return sum. +static int sum_small(struct Small s) { + return s.x + s.y; +} + +// Take a large struct by value, return sum. +static int sum_large(struct Large l) { + return l.a + l.b + l.c + l.d + l.e; +} + +// Take a 3-byte struct by value. +static int sum_packed3(struct Packed3 p) { + return p.a + p.b + p.c; +} + +// Pass struct through: take by value, return by value. +static struct Small identity_small(struct Small s) { + return s; +} + +// Chain: make → pass → sum. +static int chain_test(int x, int y) { + struct Small s = make_small(x, y); + return sum_small(s); +} + +int test_byvalue(void) { + // Small struct return. + struct Small s = make_small(10, 20); + if (s.x != 10) return 1; + if (s.y != 20) return 2; + + // Small struct parameter. + int sum = sum_small(s); + if (sum != 30) return 3; + + // Large struct return. + struct Large l = make_large(100); + if (l.a != 100) return 4; + if (l.e != 104) return 5; + + // Large struct parameter. + int lsum = sum_large(l); + if (lsum != 510) return 6; + + // Non-power-of-2 struct. + struct Packed3 p; + p.a = 1; + p.b = 2; + p.c = 3; + int psum = sum_packed3(p); + if (psum != 6) return 7; + + // Pass-through (param → return). + struct Small s2 = identity_small(s); + if (s2.x != 10) return 8; + if (s2.y != 20) return 9; + + // Chained calls. + int chained = chain_test(5, 15); + if (chained != 20) return 10; + + // Nested call in expression: sum_small(make_small(1, 2)). + int nested = sum_small(make_small(1, 2)); + if (nested != 3) return 11; + + return 0; +} diff --git a/tests/InterpretIR/test_c23.c b/tests/InterpretIR/test_c23.c new file mode 100644 index 000000000..c92a7c03f --- /dev/null +++ b/tests/InterpretIR/test_c23.c @@ -0,0 +1,261 @@ +// Tests: C23-specific features — true/false keywords, typeof, +// constexpr, u8 character literals, nullptr, auto type inference, +// digit separators, binary literals, static_assert without message. + +/* + * Expected IR: + * + * function test_c23 (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=1 align=1 (b1) + * obj_1 LOCAL_VALUE size=1 align=1 (b2) + * obj_2 LOCAL_VALUE size=4 align=4 (x) + * obj_3 LOCAL_VALUE size=4 align=4 (y) + * obj_4 LOCAL_VALUE size=4 align=4 (bin) + * obj_5 LOCAL_VALUE size=4 align=4 (big) + * obj_6 LOCAL_VALUE size=8 align=8 (np) + * obj_7 LOCAL_VALUE size=1 align=1 (u8c) + * obj_8 LOCAL_VALUE size=4 align=4 (z) + * obj_9 LOCAL_VALUE size=8 align=8 (ull) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %b1.0 = ALLOCA/LOCAL size=1 align=1 + * >> %b2.1 = ALLOCA/LOCAL size=1 align=1 + * >> %x.2 = ALLOCA/LOCAL size=4 align=4 + * >> %y.3 = ALLOCA/LOCAL size=4 align=4 + * >> %bin.4 = ALLOCA/LOCAL size=4 align=4 + * >> %big.5 = ALLOCA/LOCAL size=4 align=4 + * >> %np.6 = ALLOCA/LOCAL size=8 align=8 + * >> %u8c.7 = ALLOCA/LOCAL size=1 align=1 + * >> %z.8 = ALLOCA/LOCAL size=4 align=4 + * >> %ull.9 = ALLOCA/LOCAL size=8 align=8 + * >> %10 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %11 = ENTER_SCOPE // { // true/false are keywords in C23 (not ma... + * %b1.0 = ALLOCA/LOCAL size=1 align=1 + * %12 = CONST/BOOL 1 // true + * >> %b1.13 = MEMORY/STORE_LE_8 [%b1.0, %12] + * %b2.1 = ALLOCA/LOCAL size=1 align=1 + * %14 = CONST/BOOL 0 // false + * >> %b2.15 = MEMORY/STORE_LE_8 [%b2.1, %14] + * %16 = MEMORY/LOAD_LE_8 [%b1.0] // b1 + * %17 = CAST/ZEXT_I8_I32 [%16] // b1 + * %18 = CONST/INT32 1 // 1 + * %19 = CMP_NE [%17, %18] // b1 != 1 + * >> %20 = COND_BRANCH [%19] // if (b1 != 1) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %26 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %b2.1 = ALLOCA/LOCAL size=1 align=1 + * %27 = MEMORY/LOAD_LE_8 [%b2.1] // b2 + * %28 = CAST/ZEXT_I8_I32 [%27] // b2 + * %29 = CONST/INT32 0 // 0 + * %30 = CMP_NE [%28, %29] // b2 != 0 + * >> %31 = COND_BRANCH [%30] // if (b2 != 0) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %37 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %x.2 = ALLOCA/LOCAL size=4 align=4 + * %38 = CONST/INT32 42 // 42 + * >> %x.39 = MEMORY/STORE_LE_32 [%x.2, %38] + * %y.3 = ALLOCA/LOCAL size=4 align=4 + * %40 = MEMORY/LOAD_LE_32 [%x.2] // x + * %41 = CONST/INT32 1 // 1 + * %42 = ADD [%40, %41] // x + 1 + * >> %y.43 = MEMORY/STORE_LE_32 [%y.3, %42] + * %44 = MEMORY/LOAD_LE_32 [%y.3] // y + * %45 = CONST/INT32 43 // 43 + * %46 = CMP_NE [%44, %45] // y != 43 + * >> %47 = COND_BRANCH [%46] // if (y != 43) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %53 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %bin.4 = ALLOCA/LOCAL size=4 align=4 + * %54 = CONST/INT32 170 // 0b10101010 + * >> %bin.55 = MEMORY/STORE_LE_32 [%bin.4, %54] + * %56 = MEMORY/LOAD_LE_32 [%bin.4] // bin + * %57 = CONST/INT32 170 // 170 + * %58 = CMP_NE [%56, %57] // bin != 170 + * >> %59 = COND_BRANCH [%58] // if (bin != 170) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %65 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %big.5 = ALLOCA/LOCAL size=4 align=4 + * %66 = CONST/INT32 1000000 // 1'000'000 + * >> %big.67 = MEMORY/STORE_LE_32 [%big.5, %66] + * %68 = MEMORY/LOAD_LE_32 [%big.5] // big + * %69 = CONST/INT32 1000000 // 1000000 + * %70 = CMP_NE [%68, %69] // big != 1000000 + * >> %71 = COND_BRANCH [%70] // if (big != 1000000) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %77 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %np.6 = ALLOCA/LOCAL size=8 align=8 + * %78 = CONST/NULL_PTR // nullptr + * >> %np.79 = MEMORY/STORE_LE_64 [%np.6, %78] + * %80 = MEMORY/LOAD_LE_64 [%np.6] // np + * %81 = CONST/NULL_PTR // 0 + * %82 = CMP_NE [%80, %81] // np != 0 + * >> %83 = COND_BRANCH [%82] // if (np != 0) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %89 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %u8c.7 = ALLOCA/LOCAL size=1 align=1 + * %90 = CONST/UINT8 65 // u8'A' + * >> %u8c.91 = MEMORY/STORE_LE_8 [%u8c.7, %90] + * %92 = MEMORY/LOAD_LE_8 [%u8c.7] // u8c + * %93 = CAST/ZEXT_I8_I32 [%92] // u8c + * %94 = CONST/INT32 65 // 65 + * %95 = CMP_NE [%93, %94] // u8c != 65 + * >> %96 = COND_BRANCH [%95] // if (u8c != 65) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %102 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %z.8 = ALLOCA/LOCAL size=4 align=4 + * %103 = CONST/INT32 100 // 100 + * >> %z.104 = MEMORY/STORE_LE_32 [%z.8, %103] + * %105 = MEMORY/LOAD_LE_32 [%z.8] // z + * %106 = CONST/INT32 100 // 100 + * %107 = CMP_NE [%105, %106] // z != 100 + * >> %108 = COND_BRANCH [%107] // if (z != 100) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %114 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %ull.9 = ALLOCA/LOCAL size=8 align=8 + * %115 = CONST/UINT32 4294967295 // 0xFF'FF'FF'FF + * %116 = CAST/ZEXT_I32_I64 [%115] // 0xFF'FF'FF'FF + * >> %ull.117 = MEMORY/STORE_LE_64 [%ull.9, %116] + * %118 = MEMORY/LOAD_LE_64 [%ull.9] // ull + * %119 = CONST/UINT64 4294967295 // 4294967295ULL + * %120 = CMP_NE [%118, %119] // ull != 4294967295ULL + * >> %121 = COND_BRANCH [%120] // if (ull != 4294967295ULL) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %127 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %129 = RETURN_PTR // return 0 + * %128 = CONST/INT32 0 // 0 + * >> %130 = MEMORY/STORE_LE_32 [%129, %128] // return 0 + * >> %131 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %132 = RET [%128] // return 0 + * block_26 IF_THEN <- [block_25]: + * %123 = RETURN_PTR // return 9 + * %122 = CONST/INT32 9 // 9 + * >> %124 = MEMORY/STORE_LE_32 [%123, %122] // return 9 + * >> %125 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %126 = RET [%122] // return 9 + * block_23 IF_THEN <- [block_22]: + * %110 = RETURN_PTR // return 8 + * %109 = CONST/INT32 8 // 8 + * >> %111 = MEMORY/STORE_LE_32 [%110, %109] // return 8 + * >> %112 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %113 = RET [%109] // return 8 + * block_20 IF_THEN <- [block_19]: + * %98 = RETURN_PTR // return 7 + * %97 = CONST/INT32 7 // 7 + * >> %99 = MEMORY/STORE_LE_32 [%98, %97] // return 7 + * >> %100 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %101 = RET [%97] // return 7 + * block_17 IF_THEN <- [block_16]: + * %85 = RETURN_PTR // return 6 + * %84 = CONST/INT32 6 // 6 + * >> %86 = MEMORY/STORE_LE_32 [%85, %84] // return 6 + * >> %87 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %88 = RET [%84] // return 6 + * block_14 IF_THEN <- [block_13]: + * %73 = RETURN_PTR // return 5 + * %72 = CONST/INT32 5 // 5 + * >> %74 = MEMORY/STORE_LE_32 [%73, %72] // return 5 + * >> %75 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %76 = RET [%72] // return 5 + * block_11 IF_THEN <- [block_10]: + * %61 = RETURN_PTR // return 4 + * %60 = CONST/INT32 4 // 4 + * >> %62 = MEMORY/STORE_LE_32 [%61, %60] // return 4 + * >> %63 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %64 = RET [%60] // return 4 + * block_8 IF_THEN <- [block_7]: + * %49 = RETURN_PTR // return 3 + * %48 = CONST/INT32 3 // 3 + * >> %50 = MEMORY/STORE_LE_32 [%49, %48] // return 3 + * >> %51 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %52 = RET [%48] // return 3 + * block_5 IF_THEN <- [block_4]: + * %33 = RETURN_PTR // return 2 + * %32 = CONST/INT32 2 // 2 + * >> %34 = MEMORY/STORE_LE_32 [%33, %32] // return 2 + * >> %35 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %36 = RET [%32] // return 2 + * block_2 IF_THEN <- [block_1]: + * %22 = RETURN_PTR // return 1 + * %21 = CONST/INT32 1 // 1 + * >> %23 = MEMORY/STORE_LE_32 [%22, %21] // return 1 + * >> %24 = EXIT_SCOPE // { // true/false are keywords in C23 (not ma... + * >> %25 = RET [%21] // return 1 + * } + */ + + +#include + +int test_c23(void) { + // true/false are keywords in C23 (not macros from stdbool.h). + bool b1 = true; + bool b2 = false; + if (b1 != 1) return 1; + if (b2 != 0) return 2; + + // typeof (C23 keyword, was GNU extension). + int x = 42; + typeof(x) y = x + 1; + if (y != 43) return 3; + + // Binary literals (0b prefix). + int bin = 0b10101010; + if (bin != 170) return 4; + + // Digit separators. + int big = 1'000'000; + if (big != 1000000) return 5; + + // static_assert without message (C23). + static_assert(sizeof(int) >= 4); + + // nullptr (C23). + int *np = nullptr; + if (np != 0) return 6; + + // u8 character literal (C23 — produces unsigned char value). + unsigned char u8c = u8'A'; + if (u8c != 65) return 7; + + // auto type inference (C23). + auto z = 100; + if (z != 100) return 8; + + // Underscore in numeric literals. + unsigned long long ull = 0xFF'FF'FF'FF; + if (ull != 4294967295ULL) return 9; + + return 0; +} diff --git a/tests/InterpretIR/test_cast_precision.c b/tests/InterpretIR/test_cast_precision.c new file mode 100644 index 000000000..da7e66c7a --- /dev/null +++ b/tests/InterpretIR/test_cast_precision.c @@ -0,0 +1,97 @@ +// Tests: exact precision of int↔float and float↔float casts. +// These ONLY pass if casts use the correct source/destination width. + +int test_cast_precision(void) { + // --- Unsigned int → float (must not sign-extend) --- + { + unsigned int u = 3000000000u; // > INT_MAX + float f = (float)u; + // float can't represent exactly, but must be close to 3e9, not negative. + if (f < 2.9e9f || f > 3.1e9f) return 1; + + double d = (double)u; + // double can represent exactly. + if (d != 3000000000.0) return 2; + } + + // --- Unsigned char → float --- + { + unsigned char uc = 200; + float f = (float)uc; + if (f < 199.0f || f > 201.0f) return 5; + + double d = (double)uc; + if (d != 200.0) return 6; + } + + // --- Signed int → float (negative values) --- + { + int i = -1000000; + float f = (float)i; + if (f > -999999.0f || f < -1000001.0f) return 10; + + double d = (double)i; + if (d != -1000000.0) return 11; + } + + // --- Float → int (truncation toward zero) --- + { + float f = 3.9f; + int i = (int)f; + if (i != 3) return 20; + + float fn = -3.9f; + int in = (int)fn; + if (in != -3) return 21; + + // Float → char (truncated to 8 bits) + float fc = 200.0f; + signed char c = (signed char)(int)fc; + if (c != -56) return 22; // 200 truncated to int8 = -56 + + // Float → unsigned char + float fuc = 200.0f; + unsigned char uc = (unsigned char)(unsigned int)fuc; + if (uc != 200) return 23; + } + + // --- Double → float precision loss --- + { + // 16777217.0 is exact in double but rounds to 16777216.0 in float. + double d = 16777217.0; + float f = (float)d; + if (f != 16777216.0f) return 30; // must round, not truncate to int + + // 1.0000000000000002 (double) → 1.0f (float) — precision lost + double d2 = 1.0 + 1e-16; + float f2 = (float)d2; + if (f2 != 1.0f) return 31; + } + + // --- Float → double (exact widening) --- + { + float f = 1.5f; + double d = (double)f; + if (d != 1.5) return 40; // exact representation in both + + // Float's imprecision is preserved in double. + float f2 = 1.0f / 3.0f; + double d2 = (double)f2; + double expected = (double)(1.0f / 3.0f); + if (d2 != expected) return 41; + } + + // --- 64-bit int → float --- + { + long long ll = 9007199254740993LL; // 2^53 + 1, not exact in double + double d = (double)ll; + // Should round to 2^53 = 9007199254740992.0 + if (d != 9007199254740992.0) return 50; + + long long ll2 = 9007199254740992LL; // 2^53, exact in double + double d2 = (double)ll2; + if (d2 != 9007199254740992.0) return 51; + } + + return 0; +} diff --git a/tests/InterpretIR/test_casts.c b/tests/InterpretIR/test_casts.c new file mode 100644 index 000000000..84da931c7 --- /dev/null +++ b/tests/InterpretIR/test_casts.c @@ -0,0 +1,389 @@ +// Tests: all CAST sub-opcodes — sign extension (SEXT), zero extension (ZEXT), +// truncation (TRUNC), int-to-float, float-to-int, float widening/narrowing, +// pointer-to-int, int-to-pointer, bitcast, and identity casts. + +/* + * Expected IR: + * + * function test_casts (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=1 align=1 (sc) + * obj_1 LOCAL_VALUE size=4 align=4 (sext) + * obj_2 LOCAL_VALUE size=1 align=1 (uc) + * obj_3 LOCAL_VALUE size=4 align=4 (zext) + * obj_4 LOCAL_VALUE size=4 align=4 (big) + * obj_5 LOCAL_VALUE size=1 align=1 (trunc) + * obj_6 LOCAL_VALUE size=4 align=4 (ival) + * obj_7 LOCAL_VALUE size=8 align=8 (dval) + * obj_8 LOCAL_VALUE size=4 align=4 (back) + * obj_9 LOCAL_VALUE size=8 align=8 (pi) + * obj_10 LOCAL_VALUE size=4 align=4 (ipi) + * obj_11 LOCAL_VALUE size=4 align=4 (f) + * obj_12 LOCAL_VALUE size=8 align=8 (d) + * obj_13 LOCAL_VALUE size=4 align=4 (id) + * obj_14 LOCAL size=4 align=4 (x) + * obj_15 LOCAL_VALUE size=8 align=8 (ptr_as_int) + * obj_16 LOCAL_VALUE size=8 align=8 (a) + * obj_17 LOCAL_VALUE size=8 align=8 (b) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %sc.0 = ALLOCA/LOCAL size=1 align=1 + * >> %sext.1 = ALLOCA/LOCAL size=4 align=4 + * >> %uc.2 = ALLOCA/LOCAL size=1 align=1 + * >> %zext.3 = ALLOCA/LOCAL size=4 align=4 + * >> %big.4 = ALLOCA/LOCAL size=4 align=4 + * >> %trunc.5 = ALLOCA/LOCAL size=1 align=1 + * >> %ival.6 = ALLOCA/LOCAL size=4 align=4 + * >> %dval.7 = ALLOCA/LOCAL size=8 align=8 + * >> %back.8 = ALLOCA/LOCAL size=4 align=4 + * >> %pi.9 = ALLOCA/LOCAL size=8 align=8 + * >> %ipi.10 = ALLOCA/LOCAL size=4 align=4 + * >> %f.11 = ALLOCA/LOCAL size=4 align=4 + * >> %d.12 = ALLOCA/LOCAL size=8 align=8 + * >> %id.13 = ALLOCA/LOCAL size=4 align=4 + * >> %x.14 = ALLOCA/LOCAL size=4 align=4 + * >> %ptr_as_int.15 = ALLOCA/LOCAL size=8 align=8 + * >> %a.16 = ALLOCA/LOCAL size=8 align=8 + * >> %b.17 = ALLOCA/LOCAL size=8 align=8 + * >> %18 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %19 = ENTER_SCOPE // { // Sign extension. signed char sc = -... + * %sc.0 = ALLOCA/LOCAL size=1 align=1 + * %20 = CONST/INT32 5 // 5 + * %21 = NEG [%20] // -5 + * %22 = CAST/TRUNC_I32_I8 [%21] // -5 + * >> %sc.23 = MEMORY/STORE_LE_8 [%sc.0, %22] + * %sext.1 = ALLOCA/LOCAL size=4 align=4 + * %24 = MEMORY/LOAD_LE_8 [%sc.0] // sc + * %25 = CAST/SEXT_I8_I32 [%24] // (int)sc + * >> %sext.26 = MEMORY/STORE_LE_32 [%sext.1, %25] + * %27 = MEMORY/LOAD_LE_32 [%sext.1] // sext + * %28 = CONST/INT32 5 // 5 + * %29 = NEG [%28] // -5 + * %30 = CMP_NE [%27, %29] // sext != -5 + * >> %31 = COND_BRANCH [%30] // if (sext != -5) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %37 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %uc.2 = ALLOCA/LOCAL size=1 align=1 + * %38 = CONST/INT32 200 // 200 + * %39 = CAST/TRUNC_I32_I8 [%38] // 200 + * >> %uc.40 = MEMORY/STORE_LE_8 [%uc.2, %39] + * %zext.3 = ALLOCA/LOCAL size=4 align=4 + * %41 = MEMORY/LOAD_LE_8 [%uc.2] // uc + * %42 = CAST/ZEXT_I8_I32 [%41] // (unsigned int)uc + * >> %zext.43 = MEMORY/STORE_LE_32 [%zext.3, %42] + * %44 = MEMORY/LOAD_LE_32 [%zext.3] // zext + * %45 = CONST/INT32 200 // 200 + * %46 = CAST/IDENTITY [%45] // 200 + * %47 = CMP_NE [%44, %46] // zext != 200 + * >> %48 = COND_BRANCH [%47] // if (zext != 200) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %54 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %big.4 = ALLOCA/LOCAL size=4 align=4 + * %55 = CONST/INT32 305419896 // 0x12345678 + * >> %big.56 = MEMORY/STORE_LE_32 [%big.4, %55] + * %trunc.5 = ALLOCA/LOCAL size=1 align=1 + * %57 = MEMORY/LOAD_LE_32 [%big.4] // big + * %58 = CAST/TRUNC_I32_I8 [%57] // (char)big + * >> %trunc.59 = MEMORY/STORE_LE_8 [%trunc.5, %58] + * %60 = MEMORY/LOAD_LE_8 [%trunc.5] // trunc + * %61 = CAST/SEXT_I8_I32 [%60] // trunc + * %62 = CONST/INT32 120 // 0x78 + * %63 = CMP_NE [%61, %62] // trunc != 0x78 + * %64 = MEMORY/LOAD_LE_8 [%trunc.5] // trunc + * %65 = CAST/SEXT_I8_I32 [%64] // trunc + * %66 = CONST/INT32 120 // 120 + * %67 = CMP_NE [%65, %66] // trunc != 120 + * %68 = LOGICAL_AND [%63, %67] // trunc != 0x78 && trunc != 120 + * >> %69 = COND_BRANCH [%68] // if (trunc != 0x78 && trunc != 120) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %75 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %ival.6 = ALLOCA/LOCAL size=4 align=4 + * %76 = CONST/INT32 42 // 42 + * >> %ival.77 = MEMORY/STORE_LE_32 [%ival.6, %76] + * %dval.7 = ALLOCA/LOCAL size=8 align=8 + * %78 = MEMORY/LOAD_LE_32 [%ival.6] // ival + * %79 = CAST/SI32_TO_F64 [%78] // (double)ival + * >> %dval.80 = MEMORY/STORE_F64_LE [%dval.7, %79] + * %back.8 = ALLOCA/LOCAL size=4 align=4 + * %81 = MEMORY/LOAD_F64_LE [%dval.7] // dval + * %82 = CAST/F64_TO_SI32 [%81] // (int)dval + * >> %back.83 = MEMORY/STORE_LE_32 [%back.8, %82] + * %84 = MEMORY/LOAD_LE_32 [%back.8] // back + * %85 = CONST/INT32 42 // 42 + * %86 = CMP_NE [%84, %85] // back != 42 + * >> %87 = COND_BRANCH [%86] // if (back != 42) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %93 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %pi.9 = ALLOCA/LOCAL size=8 align=8 + * %94 = CONST/FLOAT64 3.14 // 3.14 + * >> %pi.95 = MEMORY/STORE_F64_LE [%pi.9, %94] + * %ipi.10 = ALLOCA/LOCAL size=4 align=4 + * %96 = MEMORY/LOAD_F64_LE [%pi.9] // pi + * %97 = CAST/F64_TO_SI32 [%96] // (int)pi + * >> %ipi.98 = MEMORY/STORE_LE_32 [%ipi.10, %97] + * %99 = MEMORY/LOAD_LE_32 [%ipi.10] // ipi + * %100 = CONST/INT32 3 // 3 + * %101 = CMP_NE [%99, %100] // ipi != 3 + * >> %102 = COND_BRANCH [%101] // if (ipi != 3) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %108 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %f.11 = ALLOCA/LOCAL size=4 align=4 + * %109 = CONST/FLOAT32 1.5 // 1.5f + * >> %f.110 = MEMORY/STORE_F32_LE [%f.11, %109] + * %d.12 = ALLOCA/LOCAL size=8 align=8 + * %111 = MEMORY/LOAD_F32_LE [%f.11] // f + * %112 = CAST/F32_TO_F64 [%111] // (double)f + * >> %d.113 = MEMORY/STORE_F64_LE [%d.12, %112] + * %id.13 = ALLOCA/LOCAL size=4 align=4 + * %114 = MEMORY/LOAD_F64_LE [%d.12] // d + * %115 = CONST/FLOAT64 2 // 2.0 + * %116 = FMUL_64 [%114, %115] // d * 2.0 + * %117 = CAST/F64_TO_SI32 [%116] // (int)(d * 2.0) + * >> %id.118 = MEMORY/STORE_LE_32 [%id.13, %117] + * %119 = MEMORY/LOAD_LE_32 [%id.13] // id + * %120 = CONST/INT32 3 // 3 + * %121 = CMP_NE [%119, %120] // id != 3 + * >> %122 = COND_BRANCH [%121] // if (id != 3) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %128 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %x.14 = ALLOCA/LOCAL size=4 align=4 + * %129 = CONST/INT32 99 // 99 + * >> %x.130 = MEMORY/STORE_LE_32 [%x.14, %129] + * %ptr_as_int.15 = ALLOCA/LOCAL size=8 align=8 + * %131 = CAST/PTR_TO_I64 [%x.14] // (long)&x + * >> %ptr_as_int.132 = MEMORY/STORE_LE_64 [%ptr_as_int.15, %131] + * %a.16 = ALLOCA/LOCAL size=8 align=8 + * %133 = CONST/FLOAT64 3.14 // 3.14 + * >> %a.134 = MEMORY/STORE_F64_LE [%a.16, %133] + * %b.17 = ALLOCA/LOCAL size=8 align=8 + * %135 = CONST/FLOAT64 2.71 // 2.71 + * >> %b.136 = MEMORY/STORE_F64_LE [%b.17, %135] + * %137 = MEMORY/LOAD_F64_LE [%a.16] // a + * %138 = MEMORY/LOAD_F64_LE [%b.17] // b + * %139 = FCMP_GT_64 [%137, %138] // a > b + * %140 = LOGICAL_NOT [%139] // !(a > b) + * >> %141 = COND_BRANCH [%140] // if (!(a > b)) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %147 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %a.16 = ALLOCA/LOCAL size=8 align=8 + * %148 = MEMORY/LOAD_F64_LE [%a.16] // a + * %b.17 = ALLOCA/LOCAL size=8 align=8 + * %149 = MEMORY/LOAD_F64_LE [%b.17] // b + * %150 = FCMP_LT_64 [%148, %149] // a < b + * >> %151 = COND_BRANCH [%150] // if (a < b) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %157 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %a.16 = ALLOCA/LOCAL size=8 align=8 + * %158 = MEMORY/LOAD_F64_LE [%a.16] // a + * %b.17 = ALLOCA/LOCAL size=8 align=8 + * %159 = MEMORY/LOAD_F64_LE [%b.17] // b + * %160 = FCMP_EQ_64 [%158, %159] // a == b + * >> %161 = COND_BRANCH [%160] // if (a == b) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %167 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %a.16 = ALLOCA/LOCAL size=8 align=8 + * %168 = MEMORY/LOAD_F64_LE [%a.16] // a + * %b.17 = ALLOCA/LOCAL size=8 align=8 + * %169 = MEMORY/LOAD_F64_LE [%b.17] // b + * %170 = FCMP_NE_64 [%168, %169] // a != b + * %171 = LOGICAL_NOT [%170] // !(a != b) + * >> %172 = COND_BRANCH [%171] // if (!(a != b)) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %178 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %a.16 = ALLOCA/LOCAL size=8 align=8 + * %179 = MEMORY/LOAD_F64_LE [%a.16] // a + * %b.17 = ALLOCA/LOCAL size=8 align=8 + * %180 = MEMORY/LOAD_F64_LE [%b.17] // b + * %181 = FCMP_GE_64 [%179, %180] // a >= b + * %182 = LOGICAL_NOT [%181] // !(a >= b) + * >> %183 = COND_BRANCH [%182] // if (!(a >= b)) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %189 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %a.16 = ALLOCA/LOCAL size=8 align=8 + * %190 = MEMORY/LOAD_F64_LE [%a.16] // a + * %b.17 = ALLOCA/LOCAL size=8 align=8 + * %191 = MEMORY/LOAD_F64_LE [%b.17] // b + * %192 = FCMP_LE_64 [%190, %191] // a <= b + * >> %193 = COND_BRANCH [%192] // if (a <= b) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %199 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %201 = RETURN_PTR // return 0 + * %200 = CONST/INT32 0 // 0 + * >> %202 = MEMORY/STORE_LE_32 [%201, %200] // return 0 + * >> %203 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %204 = RET [%200] // return 0 + * block_35 IF_THEN <- [block_34]: + * %195 = RETURN_PTR // return 12 + * %194 = CONST/INT32 12 // 12 + * >> %196 = MEMORY/STORE_LE_32 [%195, %194] // return 12 + * >> %197 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %198 = RET [%194] // return 12 + * block_32 IF_THEN <- [block_31]: + * %185 = RETURN_PTR // return 11 + * %184 = CONST/INT32 11 // 11 + * >> %186 = MEMORY/STORE_LE_32 [%185, %184] // return 11 + * >> %187 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %188 = RET [%184] // return 11 + * block_29 IF_THEN <- [block_28]: + * %174 = RETURN_PTR // return 10 + * %173 = CONST/INT32 10 // 10 + * >> %175 = MEMORY/STORE_LE_32 [%174, %173] // return 10 + * >> %176 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %177 = RET [%173] // return 10 + * block_26 IF_THEN <- [block_25]: + * %163 = RETURN_PTR // return 9 + * %162 = CONST/INT32 9 // 9 + * >> %164 = MEMORY/STORE_LE_32 [%163, %162] // return 9 + * >> %165 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %166 = RET [%162] // return 9 + * block_23 IF_THEN <- [block_22]: + * %153 = RETURN_PTR // return 8 + * %152 = CONST/INT32 8 // 8 + * >> %154 = MEMORY/STORE_LE_32 [%153, %152] // return 8 + * >> %155 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %156 = RET [%152] // return 8 + * block_20 IF_THEN <- [block_19]: + * %143 = RETURN_PTR // return 7 + * %142 = CONST/INT32 7 // 7 + * >> %144 = MEMORY/STORE_LE_32 [%143, %142] // return 7 + * >> %145 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %146 = RET [%142] // return 7 + * block_17 IF_THEN <- [block_16]: + * %124 = RETURN_PTR // return 6 + * %123 = CONST/INT32 6 // 6 + * >> %125 = MEMORY/STORE_LE_32 [%124, %123] // return 6 + * >> %126 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %127 = RET [%123] // return 6 + * block_14 IF_THEN <- [block_13]: + * %104 = RETURN_PTR // return 5 + * %103 = CONST/INT32 5 // 5 + * >> %105 = MEMORY/STORE_LE_32 [%104, %103] // return 5 + * >> %106 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %107 = RET [%103] // return 5 + * block_11 IF_THEN <- [block_10]: + * %89 = RETURN_PTR // return 4 + * %88 = CONST/INT32 4 // 4 + * >> %90 = MEMORY/STORE_LE_32 [%89, %88] // return 4 + * >> %91 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %92 = RET [%88] // return 4 + * block_8 IF_THEN <- [block_7]: + * %71 = RETURN_PTR // return 3 + * %70 = CONST/INT32 3 // 3 + * >> %72 = MEMORY/STORE_LE_32 [%71, %70] // return 3 + * >> %73 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %74 = RET [%70] // return 3 + * block_5 IF_THEN <- [block_4]: + * %50 = RETURN_PTR // return 2 + * %49 = CONST/INT32 2 // 2 + * >> %51 = MEMORY/STORE_LE_32 [%50, %49] // return 2 + * >> %52 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %53 = RET [%49] // return 2 + * block_2 IF_THEN <- [block_1]: + * %33 = RETURN_PTR // return 1 + * %32 = CONST/INT32 1 // 1 + * >> %34 = MEMORY/STORE_LE_32 [%33, %32] // return 1 + * >> %35 = EXIT_SCOPE // { // Sign extension. signed char sc = -... + * >> %36 = RET [%32] // return 1 + * } + */ + + + + + + + + + + +int test_casts(void) { + // Sign extension. + signed char sc = -5; + int sext = (int)sc; + if (sext != -5) return 1; + + // Zero extension. + unsigned char uc = 200; + unsigned int zext = (unsigned int)uc; + if (zext != 200) return 2; + + // Truncation. + int big = 0x12345678; + char trunc = (char)big; + if (trunc != 0x78 && trunc != 120) return 3; // 0x78 = 120 + + // Int to float. + int ival = 42; + double dval = (double)ival; + // Can't compare doubles exactly in C without float ops, + // but we can cast back. + int back = (int)dval; + if (back != 42) return 4; + + // Float to int (truncates toward zero). + double pi = 3.14; + int ipi = (int)pi; + if (ipi != 3) return 5; + + // Float widening. + float f = 1.5f; + double d = (double)f; + int id = (int)(d * 2.0); + if (id != 3) return 6; + + // Pointer to int and back. + int x = 99; + long ptr_as_int = (long)&x; + // Can't meaningfully test the value, but it should not crash. + + // Float comparisons (FCMP opcodes). + double a = 3.14, b = 2.71; + if (!(a > b)) return 7; // 3.14 > 2.71 + if (a < b) return 8; // !(3.14 < 2.71) + if (a == b) return 9; // !(3.14 == 2.71) + if (!(a != b)) return 10; // 3.14 != 2.71 + if (!(a >= b)) return 11; // 3.14 >= 2.71 + if (a <= b) return 12; // !(3.14 <= 2.71) + + return 0; +} diff --git a/tests/InterpretIR/test_compound_assign.c b/tests/InterpretIR/test_compound_assign.c new file mode 100644 index 000000000..2660dab62 --- /dev/null +++ b/tests/InterpretIR/test_compound_assign.c @@ -0,0 +1,527 @@ +// Tests: read-modify-write (READ_MODIFY_WRITE) for compound assignment +// operators (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=), +// pre/post increment/decrement (++x, x++, --x, x--), +// and pointer increment/decrement. + +/* + * Expected IR: + * + * function test_compound_assign (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (x) + * obj_1 LOCAL_VALUE size=4 align=4 (pre) + * obj_2 LOCAL_VALUE size=4 align=4 (post) + * obj_3 LOCAL_VALUE size=12 align=4 (arr) + * obj_4 LOCAL_VALUE size=8 align=8 (p) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %x.0 = ALLOCA/LOCAL size=4 align=4 + * >> %pre.1 = ALLOCA/LOCAL size=4 align=4 + * >> %post.2 = ALLOCA/LOCAL size=4 align=4 + * >> %arr.3 = ALLOCA/LOCAL size=12 align=4 + * >> %p.4 = ALLOCA/LOCAL size=8 align=8 + * >> %5 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %6 = ENTER_SCOPE // { int x = 10; // Compound assignment o... + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %7 = CONST/INT32 10 // 10 + * >> %x.8 = MEMORY/STORE_LE_32 [%x.0, %7] + * %9 = CONST/INT32 5 // 5 + * >> %10 = READ_MODIFY_WRITE(ADD new) [%x.0, %9] // x += 5 + * %11 = MEMORY/LOAD_LE_32 [%x.0] // x + * %12 = CONST/INT32 15 // 15 + * %13 = CMP_NE [%11, %12] // x != 15 + * >> %14 = COND_BRANCH [%13] // if (x != 15) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %20 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %21 = CONST/INT32 3 // 3 + * >> %22 = READ_MODIFY_WRITE(SUB new) [%x.0, %21] // x -= 3 + * %23 = MEMORY/LOAD_LE_32 [%x.0] // x + * %24 = CONST/INT32 12 // 12 + * %25 = CMP_NE [%23, %24] // x != 12 + * >> %26 = COND_BRANCH [%25] // if (x != 12) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %32 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %33 = CONST/INT32 2 // 2 + * >> %34 = READ_MODIFY_WRITE(MUL new) [%x.0, %33] // x *= 2 + * %35 = MEMORY/LOAD_LE_32 [%x.0] // x + * %36 = CONST/INT32 24 // 24 + * %37 = CMP_NE [%35, %36] // x != 24 + * >> %38 = COND_BRANCH [%37] // if (x != 24) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %44 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %45 = CONST/INT32 6 // 6 + * >> %46 = READ_MODIFY_WRITE(DIV new) [%x.0, %45] // x /= 6 + * %47 = MEMORY/LOAD_LE_32 [%x.0] // x + * %48 = CONST/INT32 4 // 4 + * %49 = CMP_NE [%47, %48] // x != 4 + * >> %50 = COND_BRANCH [%49] // if (x != 4) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %56 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %57 = CONST/INT32 3 // 3 + * >> %58 = READ_MODIFY_WRITE(REM new) [%x.0, %57] // x %= 3 + * %59 = MEMORY/LOAD_LE_32 [%x.0] // x + * %60 = CONST/INT32 1 // 1 + * %61 = CMP_NE [%59, %60] // x != 1 + * >> %62 = COND_BRANCH [%61] // if (x != 1) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %68 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %69 = CONST/INT32 255 // 0xFF + * >> %70 = MEMORY/STORE_LE_32 [%x.0, %69] // x = 0xFF + * %71 = CONST/INT32 15 // 0x0F + * >> %72 = READ_MODIFY_WRITE(BIT_AND new) [%x.0, %71] // x &= 0x0F + * %73 = MEMORY/LOAD_LE_32 [%x.0] // x + * %74 = CONST/INT32 15 // 0x0F + * %75 = CMP_NE [%73, %74] // x != 0x0F + * >> %76 = COND_BRANCH [%75] // if (x != 0x0F) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %82 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %83 = CONST/INT32 240 // 0xF0 + * >> %84 = READ_MODIFY_WRITE(BIT_OR new) [%x.0, %83] // x |= 0xF0 + * %85 = MEMORY/LOAD_LE_32 [%x.0] // x + * %86 = CONST/INT32 255 // 0xFF + * %87 = CMP_NE [%85, %86] // x != 0xFF + * >> %88 = COND_BRANCH [%87] // if (x != 0xFF) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %94 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %95 = CONST/INT32 255 // 0xFF + * >> %96 = READ_MODIFY_WRITE(BIT_XOR new) [%x.0, %95] // x ^= 0xFF + * %97 = MEMORY/LOAD_LE_32 [%x.0] // x + * %98 = CONST/INT32 0 // 0x00 + * %99 = CMP_NE [%97, %98] // x != 0x00 + * >> %100 = COND_BRANCH [%99] // if (x != 0x00) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %106 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %107 = CONST/INT32 1 // 1 + * >> %108 = MEMORY/STORE_LE_32 [%x.0, %107] // x = 1 + * %109 = CONST/INT32 4 // 4 + * >> %110 = READ_MODIFY_WRITE(SHL new) [%x.0, %109] // x <<= 4 + * %111 = MEMORY/LOAD_LE_32 [%x.0] // x + * %112 = CONST/INT32 16 // 16 + * %113 = CMP_NE [%111, %112] // x != 16 + * >> %114 = COND_BRANCH [%113] // if (x != 16) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %120 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %121 = CONST/INT32 2 // 2 + * >> %122 = READ_MODIFY_WRITE(SHR new) [%x.0, %121] // x >>= 2 + * %123 = MEMORY/LOAD_LE_32 [%x.0] // x + * %124 = CONST/INT32 4 // 4 + * %125 = CMP_NE [%123, %124] // x != 4 + * >> %126 = COND_BRANCH [%125] // if (x != 4) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %132 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %133 = CONST/INT32 5 // 5 + * >> %134 = MEMORY/STORE_LE_32 [%x.0, %133] // x = 5 + * %pre.1 = ALLOCA/LOCAL size=4 align=4 + * %135 = CONST/INT32 1 // ++x + * %136 = READ_MODIFY_WRITE(ADD new) [%x.0, %135] // ++x + * >> %pre.137 = MEMORY/STORE_LE_32 [%pre.1, %136] + * %138 = MEMORY/LOAD_LE_32 [%pre.1] // pre + * %139 = CONST/INT32 6 // 6 + * %140 = CMP_NE [%138, %139] // pre != 6 + * >> %141 = COND_BRANCH [%140] // if (pre != 6) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %147 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %148 = MEMORY/LOAD_LE_32 [%x.0] // x + * %149 = CONST/INT32 6 // 6 + * %150 = CMP_NE [%148, %149] // x != 6 + * >> %151 = COND_BRANCH [%150] // if (x != 6) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %157 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %158 = CONST/INT32 5 // 5 + * >> %159 = MEMORY/STORE_LE_32 [%x.0, %158] // x = 5 + * %post.2 = ALLOCA/LOCAL size=4 align=4 + * %160 = CONST/INT32 1 // x++ + * %161 = READ_MODIFY_WRITE(ADD old) [%x.0, %160] // x++ + * >> %post.162 = MEMORY/STORE_LE_32 [%post.2, %161] + * %163 = MEMORY/LOAD_LE_32 [%post.2] // post + * %164 = CONST/INT32 5 // 5 + * %165 = CMP_NE [%163, %164] // post != 5 + * >> %166 = COND_BRANCH [%165] // if (post != 5) return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %172 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %173 = MEMORY/LOAD_LE_32 [%x.0] // x + * %174 = CONST/INT32 6 // 6 + * %175 = CMP_NE [%173, %174] // x != 6 + * >> %176 = COND_BRANCH [%175] // if (x != 6) return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %182 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %183 = CONST/INT32 5 // 5 + * >> %184 = MEMORY/STORE_LE_32 [%x.0, %183] // x = 5 + * %pre.1 = ALLOCA/LOCAL size=4 align=4 + * %185 = CONST/INT32 1 // --x + * %186 = READ_MODIFY_WRITE(SUB new) [%x.0, %185] // --x + * >> %187 = MEMORY/STORE_LE_32 [%pre.1, %186] // pre = --x + * %188 = MEMORY/LOAD_LE_32 [%pre.1] // pre + * %189 = CONST/INT32 4 // 4 + * %190 = CMP_NE [%188, %189] // pre != 4 + * >> %191 = COND_BRANCH [%190] // if (pre != 4) return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %197 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %198 = CONST/INT32 5 // 5 + * >> %199 = MEMORY/STORE_LE_32 [%x.0, %198] // x = 5 + * %post.2 = ALLOCA/LOCAL size=4 align=4 + * %200 = CONST/INT32 1 // x-- + * %201 = READ_MODIFY_WRITE(SUB old) [%x.0, %200] // x-- + * >> %202 = MEMORY/STORE_LE_32 [%post.2, %201] // post = x-- + * %203 = MEMORY/LOAD_LE_32 [%post.2] // post + * %204 = CONST/INT32 5 // 5 + * %205 = CMP_NE [%203, %204] // post != 5 + * >> %206 = COND_BRANCH [%205] // if (post != 5) return 16 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %212 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %x.0 = ALLOCA/LOCAL size=4 align=4 + * %213 = MEMORY/LOAD_LE_32 [%x.0] // x + * %214 = CONST/INT32 4 // 4 + * %215 = CMP_NE [%213, %214] // x != 4 + * >> %216 = COND_BRANCH [%215] // if (x != 4) return 17 + * -> [block_50, block_51] + * block_51 IF_ELSE <- [block_49]: + * >> %222 = IMPLICIT_GOTO + * -> [block_52] + * block_52 IF_MERGE <- [block_51]: + * %arr.3 = ALLOCA/LOCAL size=12 align=4 + * %arr.223 = CONST/UINT8 0 + * %arr.224 = CONST/UINT64 12 + * >> %arr.225 = MEMORY/MEMSET [%arr.3, %arr.223, %arr.224] + * %226 = CONST/INT32 10 // 10 + * >> %arr.227 = MEMORY/STORE_LE_32 [%arr.3, %226] + * %arr.228 = CONST/INT64 1 + * %arr.229 = PTR_ADD elem_size=4 [%arr.3, %arr.228] + * %230 = CONST/INT32 20 // 20 + * >> %arr.231 = MEMORY/STORE_LE_32 [%arr.229, %230] + * %arr.232 = CONST/INT64 2 + * %arr.233 = PTR_ADD elem_size=4 [%arr.3, %arr.232] + * %234 = CONST/INT32 30 // 30 + * >> %arr.235 = MEMORY/STORE_LE_32 [%arr.233, %234] + * %p.4 = ALLOCA/LOCAL size=8 align=8 + * >> %p.236 = MEMORY/STORE_LE_64 [%p.4, %arr.3] + * %237 = CONST/INT64 1 // p++ + * >> %238 = READ_MODIFY_WRITE(PTR_ADD old) [%p.4, %237] // p++ + * %239 = MEMORY/LOAD_LE_64 [%p.4] // p + * %240 = MEMORY/LOAD_LE_32 [%239] // *p + * %241 = CONST/INT32 20 // 20 + * %242 = CMP_NE [%240, %241] // *p != 20 + * >> %243 = COND_BRANCH [%242] // if (*p != 20) return 18 + * -> [block_53, block_54] + * block_54 IF_ELSE <- [block_52]: + * >> %249 = IMPLICIT_GOTO + * -> [block_55] + * block_55 IF_MERGE <- [block_54]: + * %p.4 = ALLOCA/LOCAL size=8 align=8 + * %arr.3 = ALLOCA/LOCAL size=12 align=4 + * %250 = CONST/INT32 2 // 2 + * %251 = PTR_ADD elem_size=4 [%arr.3, %250] // arr[2] + * >> %252 = MEMORY/STORE_LE_64 [%p.4, %251] // p = &arr[2] + * %253 = CONST/INT64 -1 // p-- + * >> %254 = READ_MODIFY_WRITE(PTR_ADD old) [%p.4, %253] // p-- + * %255 = MEMORY/LOAD_LE_64 [%p.4] // p + * %256 = MEMORY/LOAD_LE_32 [%255] // *p + * %257 = CONST/INT32 20 // 20 + * %258 = CMP_NE [%256, %257] // *p != 20 + * >> %259 = COND_BRANCH [%258] // if (*p != 20) return 19 + * -> [block_56, block_57] + * block_57 IF_ELSE <- [block_55]: + * >> %265 = IMPLICIT_GOTO + * -> [block_58] + * block_58 IF_MERGE <- [block_57]: + * %p.4 = ALLOCA/LOCAL size=8 align=8 + * %arr.3 = ALLOCA/LOCAL size=12 align=4 + * >> %266 = MEMORY/STORE_LE_64 [%p.4, %arr.3] // p = arr + * %267 = CONST/INT32 2 // 2 + * >> %268 = READ_MODIFY_WRITE(PTR_ADD new) [%p.4, %267] // p += 2 + * %269 = MEMORY/LOAD_LE_64 [%p.4] // p + * %270 = MEMORY/LOAD_LE_32 [%269] // *p + * %271 = CONST/INT32 30 // 30 + * %272 = CMP_NE [%270, %271] // *p != 30 + * >> %273 = COND_BRANCH [%272] // if (*p != 30) return 20 + * -> [block_59, block_60] + * block_60 IF_ELSE <- [block_58]: + * >> %279 = IMPLICIT_GOTO + * -> [block_61] + * block_61 IF_MERGE <- [block_60]: + * %p.4 = ALLOCA/LOCAL size=8 align=8 + * %280 = CONST/INT32 1 // 1 + * %281 = NEG [%280] // p -= 1 + * >> %282 = READ_MODIFY_WRITE(PTR_ADD new) [%p.4, %281] // p -= 1 + * %283 = MEMORY/LOAD_LE_64 [%p.4] // p + * %284 = MEMORY/LOAD_LE_32 [%283] // *p + * %285 = CONST/INT32 20 // 20 + * %286 = CMP_NE [%284, %285] // *p != 20 + * >> %287 = COND_BRANCH [%286] // if (*p != 20) return 21 + * -> [block_62, block_63] + * block_63 IF_ELSE <- [block_61]: + * >> %293 = IMPLICIT_GOTO + * -> [block_64] + * block_64 IF_MERGE <- [block_63]: + * %295 = RETURN_PTR // return 0 + * %294 = CONST/INT32 0 // 0 + * >> %296 = MEMORY/STORE_LE_32 [%295, %294] // return 0 + * >> %297 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %298 = RET [%294] // return 0 + * block_62 IF_THEN <- [block_61]: + * %289 = RETURN_PTR // return 21 + * %288 = CONST/INT32 21 // 21 + * >> %290 = MEMORY/STORE_LE_32 [%289, %288] // return 21 + * >> %291 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %292 = RET [%288] // return 21 + * block_59 IF_THEN <- [block_58]: + * %275 = RETURN_PTR // return 20 + * %274 = CONST/INT32 20 // 20 + * >> %276 = MEMORY/STORE_LE_32 [%275, %274] // return 20 + * >> %277 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %278 = RET [%274] // return 20 + * block_56 IF_THEN <- [block_55]: + * %261 = RETURN_PTR // return 19 + * %260 = CONST/INT32 19 // 19 + * >> %262 = MEMORY/STORE_LE_32 [%261, %260] // return 19 + * >> %263 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %264 = RET [%260] // return 19 + * block_53 IF_THEN <- [block_52]: + * %245 = RETURN_PTR // return 18 + * %244 = CONST/INT32 18 // 18 + * >> %246 = MEMORY/STORE_LE_32 [%245, %244] // return 18 + * >> %247 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %248 = RET [%244] // return 18 + * block_50 IF_THEN <- [block_49]: + * %218 = RETURN_PTR // return 17 + * %217 = CONST/INT32 17 // 17 + * >> %219 = MEMORY/STORE_LE_32 [%218, %217] // return 17 + * >> %220 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %221 = RET [%217] // return 17 + * block_47 IF_THEN <- [block_46]: + * %208 = RETURN_PTR // return 16 + * %207 = CONST/INT32 16 // 16 + * >> %209 = MEMORY/STORE_LE_32 [%208, %207] // return 16 + * >> %210 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %211 = RET [%207] // return 16 + * block_44 IF_THEN <- [block_43]: + * %193 = RETURN_PTR // return 15 + * %192 = CONST/INT32 15 // 15 + * >> %194 = MEMORY/STORE_LE_32 [%193, %192] // return 15 + * >> %195 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %196 = RET [%192] // return 15 + * block_41 IF_THEN <- [block_40]: + * %178 = RETURN_PTR // return 14 + * %177 = CONST/INT32 14 // 14 + * >> %179 = MEMORY/STORE_LE_32 [%178, %177] // return 14 + * >> %180 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %181 = RET [%177] // return 14 + * block_38 IF_THEN <- [block_37]: + * %168 = RETURN_PTR // return 13 + * %167 = CONST/INT32 13 // 13 + * >> %169 = MEMORY/STORE_LE_32 [%168, %167] // return 13 + * >> %170 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %171 = RET [%167] // return 13 + * block_35 IF_THEN <- [block_34]: + * %153 = RETURN_PTR // return 12 + * %152 = CONST/INT32 12 // 12 + * >> %154 = MEMORY/STORE_LE_32 [%153, %152] // return 12 + * >> %155 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %156 = RET [%152] // return 12 + * block_32 IF_THEN <- [block_31]: + * %143 = RETURN_PTR // return 11 + * %142 = CONST/INT32 11 // 11 + * >> %144 = MEMORY/STORE_LE_32 [%143, %142] // return 11 + * >> %145 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %146 = RET [%142] // return 11 + * block_29 IF_THEN <- [block_28]: + * %128 = RETURN_PTR // return 10 + * %127 = CONST/INT32 10 // 10 + * >> %129 = MEMORY/STORE_LE_32 [%128, %127] // return 10 + * >> %130 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %131 = RET [%127] // return 10 + * block_26 IF_THEN <- [block_25]: + * %116 = RETURN_PTR // return 9 + * %115 = CONST/INT32 9 // 9 + * >> %117 = MEMORY/STORE_LE_32 [%116, %115] // return 9 + * >> %118 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %119 = RET [%115] // return 9 + * block_23 IF_THEN <- [block_22]: + * %102 = RETURN_PTR // return 8 + * %101 = CONST/INT32 8 // 8 + * >> %103 = MEMORY/STORE_LE_32 [%102, %101] // return 8 + * >> %104 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %105 = RET [%101] // return 8 + * block_20 IF_THEN <- [block_19]: + * %90 = RETURN_PTR // return 7 + * %89 = CONST/INT32 7 // 7 + * >> %91 = MEMORY/STORE_LE_32 [%90, %89] // return 7 + * >> %92 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %93 = RET [%89] // return 7 + * block_17 IF_THEN <- [block_16]: + * %78 = RETURN_PTR // return 6 + * %77 = CONST/INT32 6 // 6 + * >> %79 = MEMORY/STORE_LE_32 [%78, %77] // return 6 + * >> %80 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %81 = RET [%77] // return 6 + * block_14 IF_THEN <- [block_13]: + * %64 = RETURN_PTR // return 5 + * %63 = CONST/INT32 5 // 5 + * >> %65 = MEMORY/STORE_LE_32 [%64, %63] // return 5 + * >> %66 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %67 = RET [%63] // return 5 + * block_11 IF_THEN <- [block_10]: + * %52 = RETURN_PTR // return 4 + * %51 = CONST/INT32 4 // 4 + * >> %53 = MEMORY/STORE_LE_32 [%52, %51] // return 4 + * >> %54 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %55 = RET [%51] // return 4 + * block_8 IF_THEN <- [block_7]: + * %40 = RETURN_PTR // return 3 + * %39 = CONST/INT32 3 // 3 + * >> %41 = MEMORY/STORE_LE_32 [%40, %39] // return 3 + * >> %42 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %43 = RET [%39] // return 3 + * block_5 IF_THEN <- [block_4]: + * %28 = RETURN_PTR // return 2 + * %27 = CONST/INT32 2 // 2 + * >> %29 = MEMORY/STORE_LE_32 [%28, %27] // return 2 + * >> %30 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %31 = RET [%27] // return 2 + * block_2 IF_THEN <- [block_1]: + * %16 = RETURN_PTR // return 1 + * %15 = CONST/INT32 1 // 1 + * >> %17 = MEMORY/STORE_LE_32 [%16, %15] // return 1 + * >> %18 = EXIT_SCOPE // { int x = 10; // Compound assignment o... + * >> %19 = RET [%15] // return 1 + * } + */ + + + + + + + + + + +int test_compound_assign(void) { + int x = 10; + + // Compound assignment operators. + x += 5; if (x != 15) return 1; + x -= 3; if (x != 12) return 2; + x *= 2; if (x != 24) return 3; + x /= 6; if (x != 4) return 4; + x %= 3; if (x != 1) return 5; + + x = 0xFF; + x &= 0x0F; if (x != 0x0F) return 6; + x |= 0xF0; if (x != 0xFF) return 7; + x ^= 0xFF; if (x != 0x00) return 8; + + x = 1; + x <<= 4; if (x != 16) return 9; + x >>= 2; if (x != 4) return 10; + + // Pre-increment. + x = 5; + int pre = ++x; + if (pre != 6) return 11; + if (x != 6) return 12; + + // Post-increment. + x = 5; + int post = x++; + if (post != 5) return 13; + if (x != 6) return 14; + + // Pre-decrement. + x = 5; + pre = --x; + if (pre != 4) return 15; + + // Post-decrement. + x = 5; + post = x--; + if (post != 5) return 16; + if (x != 4) return 17; + + // Pointer increment. + int arr[3] = {10, 20, 30}; + int *p = arr; + p++; + if (*p != 20) return 18; + + // Pointer decrement. + p = &arr[2]; + p--; + if (*p != 20) return 19; + + // Pointer compound assign. + p = arr; + p += 2; + if (*p != 30) return 20; + p -= 1; + if (*p != 20) return 21; + + return 0; +} diff --git a/tests/InterpretIR/test_conditional_exec.c b/tests/InterpretIR/test_conditional_exec.c new file mode 100644 index 000000000..c4b140171 --- /dev/null +++ b/tests/InterpretIR/test_conditional_exec.c @@ -0,0 +1,664 @@ +// Tests: conditional execution semantics — short-circuit evaluation, +// ternary operator, and ensuring side effects in unreachable branches +// don't corrupt state. + +/* + * Expected IR: + * + * function test_conditional_exec (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (r1) + * obj_1 LOCAL_VALUE size=4 align=4 (r2) + * obj_2 LOCAL_VALUE size=4 align=4 (r3) + * obj_3 LOCAL_VALUE size=4 align=4 (r4) + * obj_4 LOCAL_VALUE size=4 align=4 (r5) + * obj_5 LOCAL_VALUE size=4 align=4 (r6) + * obj_6 LOCAL_VALUE size=4 align=4 (r7) + * obj_7 LOCAL_VALUE size=4 align=4 (r8) + * obj_8 LOCAL_VALUE size=4 align=4 (r9) + * obj_9 LOCAL_VALUE size=4 align=4 (x) + * obj_10 LOCAL_VALUE size=4 align=4 (r10) + * obj_11 LOCAL_VALUE size=4 align=4 (r11) + * obj_12 LOCAL_VALUE size=4 align=4 (r12) + * obj_13 LOCAL_VALUE size=4 align=4 (r13) + * obj_14 LOCAL_VALUE size=4 align=4 (r14) + * obj_15 LOCAL_VALUE size=4 align=4 (r15) + * obj_16 LOCAL_VALUE size=4 align=4 (a) + * obj_17 LOCAL_VALUE size=4 align=4 (b) + * obj_18 LOCAL_VALUE size=4 align=4 (c) + * obj_19 LOCAL_VALUE size=4 align=4 (r16) + * obj_20 LOCAL_VALUE size=4 align=4 (r17) + * obj_21 LOCAL_VALUE size=4 align=4 (r18) + * obj_22 LOCAL_VALUE size=4 align=4 (r19) + * obj_23 LOCAL_VALUE size=4 align=4 (r20) + * obj_24 PARAMETER size=4 align=4 + * obj_25 RETURN_SLOT size=4 align=4 + * obj_26 RETURN_SLOT size=4 align=4 + * obj_27 RETURN_SLOT size=4 align=4 + * obj_28 RETURN_SLOT size=4 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %r1.0 = ALLOCA/LOCAL size=4 align=4 + * >> %r2.1 = ALLOCA/LOCAL size=4 align=4 + * >> %r3.2 = ALLOCA/LOCAL size=4 align=4 + * >> %r4.3 = ALLOCA/LOCAL size=4 align=4 + * >> %r5.4 = ALLOCA/LOCAL size=4 align=4 + * >> %r6.5 = ALLOCA/LOCAL size=4 align=4 + * >> %r7.6 = ALLOCA/LOCAL size=4 align=4 + * >> %r8.7 = ALLOCA/LOCAL size=4 align=4 + * >> %r9.8 = ALLOCA/LOCAL size=4 align=4 + * >> %x.9 = ALLOCA/LOCAL size=4 align=4 + * >> %r10.10 = ALLOCA/LOCAL size=4 align=4 + * >> %r11.11 = ALLOCA/LOCAL size=4 align=4 + * >> %r12.12 = ALLOCA/LOCAL size=4 align=4 + * >> %r13.13 = ALLOCA/LOCAL size=4 align=4 + * >> %r14.14 = ALLOCA/LOCAL size=4 align=4 + * >> %r15.15 = ALLOCA/LOCAL size=4 align=4 + * >> %a.16 = ALLOCA/LOCAL size=4 align=4 + * >> %b.17 = ALLOCA/LOCAL size=4 align=4 + * >> %c.18 = ALLOCA/LOCAL size=4 align=4 + * >> %r16.19 = ALLOCA/LOCAL size=4 align=4 + * >> %r17.20 = ALLOCA/LOCAL size=4 align=4 + * >> %r18.21 = ALLOCA/LOCAL size=4 align=4 + * >> %r19.22 = ALLOCA/LOCAL size=4 align=4 + * >> %r20.23 = ALLOCA/LOCAL size=4 align=4 + * >> %24 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %25 = ENTER_SCOPE // { // --- Short-circuit AND --- // false... + * %26 = GLOBAL_PTR // side_effect_counter + * %27 = CONST/INT32 0 // 0 + * >> %28 = MEMORY/STORE_LE_32 [%26, %27] // side_effect_counter = 0 + * >> %30 = ENTER_SCOPE // increment_and_return(1) + * %32 = ALLOCA/ARG size=4 align=4 // 1 + * %31 = CONST/INT32 1 // 1 + * >> %33 = MEMORY/STORE_LE_32 [%32, %31] // 1 + * %r1.0 = ALLOCA/LOCAL size=4 align=4 + * %29 = CONST/INT32 0 // 0 + * %35 = CALL @increment_and_return [%32] // increment_and_return(1) + * %36 = LOGICAL_AND [%29, %35] // 0 && increment_and_return(1) + * >> %r1.37 = MEMORY/STORE_LE_32 [%r1.0, %36] + * >> %41 = EXIT_SCOPE + * %38 = MEMORY/LOAD_LE_32 [%r1.0] // r1 + * %39 = CONST/INT32 0 // 0 + * %40 = CMP_NE [%38, %39] // r1 != 0 + * >> %42 = COND_BRANCH [%40] // if (r1 != 0) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %49 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %r2.1 = ALLOCA/LOCAL size=4 align=4 + * %50 = CONST/INT32 1 // 1 + * %51 = CONST/INT32 1 // 1 + * %52 = LOGICAL_AND [%50, %51] // 1 && 1 + * >> %r2.53 = MEMORY/STORE_LE_32 [%r2.1, %52] + * %54 = MEMORY/LOAD_LE_32 [%r2.1] // r2 + * %55 = CONST/INT32 1 // 1 + * %56 = CMP_NE [%54, %55] // r2 != 1 + * >> %57 = COND_BRANCH [%56] // if (r2 != 1) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %63 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %r3.2 = ALLOCA/LOCAL size=4 align=4 + * %64 = CONST/INT32 1 // 1 + * %65 = CONST/INT32 0 // 0 + * %66 = LOGICAL_AND [%64, %65] // 1 && 0 + * >> %r3.67 = MEMORY/STORE_LE_32 [%r3.2, %66] + * %68 = MEMORY/LOAD_LE_32 [%r3.2] // r3 + * %69 = CONST/INT32 0 // 0 + * %70 = CMP_NE [%68, %69] // r3 != 0 + * >> %71 = COND_BRANCH [%70] // if (r3 != 0) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %77 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * >> %79 = ENTER_SCOPE // unreachable_function() + * %r4.3 = ALLOCA/LOCAL size=4 align=4 + * %78 = CONST/INT32 1 // 1 + * %81 = CALL @unreachable_function // unreachable_function() + * %82 = LOGICAL_OR [%78, %81] // 1 || unreachable_function() + * >> %r4.83 = MEMORY/STORE_LE_32 [%r4.3, %82] + * >> %87 = EXIT_SCOPE + * %84 = MEMORY/LOAD_LE_32 [%r4.3] // r4 + * %85 = CONST/INT32 1 // 1 + * %86 = CMP_NE [%84, %85] // r4 != 1 + * >> %88 = COND_BRANCH [%86] // if (r4 != 1) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %95 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %r5.4 = ALLOCA/LOCAL size=4 align=4 + * %96 = CONST/INT32 0 // 0 + * %97 = CONST/INT32 1 // 1 + * %98 = LOGICAL_OR [%96, %97] // 0 || 1 + * >> %r5.99 = MEMORY/STORE_LE_32 [%r5.4, %98] + * %100 = MEMORY/LOAD_LE_32 [%r5.4] // r5 + * %101 = CONST/INT32 1 // 1 + * %102 = CMP_NE [%100, %101] // r5 != 1 + * >> %103 = COND_BRANCH [%102] // if (r5 != 1) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %109 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %r6.5 = ALLOCA/LOCAL size=4 align=4 + * %110 = CONST/INT32 0 // 0 + * %111 = CONST/INT32 0 // 0 + * %112 = LOGICAL_OR [%110, %111] // 0 || 0 + * >> %r6.113 = MEMORY/STORE_LE_32 [%r6.5, %112] + * %114 = MEMORY/LOAD_LE_32 [%r6.5] // r6 + * %115 = CONST/INT32 0 // 0 + * %116 = CMP_NE [%114, %115] // r6 != 0 + * >> %117 = COND_BRANCH [%116] // if (r6 != 0) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %123 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * >> %126 = ENTER_SCOPE // unreachable_function() + * %r7.6 = ALLOCA/LOCAL size=4 align=4 + * %124 = CONST/INT32 1 // 1 + * %125 = CONST/INT32 42 // 42 + * %128 = CALL @unreachable_function // unreachable_function() + * %129 = SELECT [%124, %125, %128] // 1 ? 42 : unreachable_function() + * >> %r7.130 = MEMORY/STORE_LE_32 [%r7.6, %129] + * >> %134 = EXIT_SCOPE + * %131 = MEMORY/LOAD_LE_32 [%r7.6] // r7 + * %132 = CONST/INT32 42 // 42 + * %133 = CMP_NE [%131, %132] // r7 != 42 + * >> %135 = COND_BRANCH [%133] // if (r7 != 42) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %142 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * >> %144 = ENTER_SCOPE // unreachable_function() + * %r8.7 = ALLOCA/LOCAL size=4 align=4 + * %143 = CONST/INT32 0 // 0 + * %146 = CALL @unreachable_function // unreachable_function() + * %147 = CONST/INT32 43 // 43 + * %148 = SELECT [%143, %146, %147] // 0 ? unreachable_function() : 43 + * >> %r8.149 = MEMORY/STORE_LE_32 [%r8.7, %148] + * >> %153 = EXIT_SCOPE + * %150 = MEMORY/LOAD_LE_32 [%r8.7] // r8 + * %151 = CONST/INT32 43 // 43 + * %152 = CMP_NE [%150, %151] // r8 != 43 + * >> %154 = COND_BRANCH [%152] // if (r8 != 43) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %161 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %r9.8 = ALLOCA/LOCAL size=4 align=4 + * %162 = CONST/INT32 1 // 1 + * %163 = CONST/INT32 0 // 0 + * %164 = CONST/INT32 100 // 100 + * %165 = CONST/INT32 200 // 200 + * %166 = SELECT [%163, %164, %165] // 0 ? 100 : 200 + * %167 = CONST/INT32 300 // 300 + * %168 = SELECT [%162, %166, %167] // 1 ? (0 ? 100 : 200) : 300 + * >> %r9.169 = MEMORY/STORE_LE_32 [%r9.8, %168] + * %170 = MEMORY/LOAD_LE_32 [%r9.8] // r9 + * %171 = CONST/INT32 200 // 200 + * %172 = CMP_NE [%170, %171] // r9 != 200 + * >> %173 = COND_BRANCH [%172] // if (r9 != 200) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %179 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %x.9 = ALLOCA/LOCAL size=4 align=4 + * %180 = CONST/INT32 10 // 10 + * >> %x.181 = MEMORY/STORE_LE_32 [%x.9, %180] + * %r10.10 = ALLOCA/LOCAL size=4 align=4 + * %182 = MEMORY/LOAD_LE_32 [%x.9] // x + * %183 = CONST/INT32 5 // 5 + * %184 = CMP_GT [%182, %183] // x > 5 + * %185 = MEMORY/LOAD_LE_32 [%x.9] // x + * %186 = CONST/INT32 1 // 1 + * %187 = ADD [%185, %186] // x + 1 + * %188 = MEMORY/LOAD_LE_32 [%x.9] // x + * %189 = CONST/INT32 1 // 1 + * %190 = SUB [%188, %189] // x - 1 + * %191 = SELECT [%184, %187, %190] // (x > 5) ? (x + 1) : (x - 1) + * >> %r10.192 = MEMORY/STORE_LE_32 [%r10.10, %191] + * %193 = MEMORY/LOAD_LE_32 [%r10.10] // r10 + * %194 = CONST/INT32 11 // 11 + * %195 = CMP_NE [%193, %194] // r10 != 11 + * >> %196 = COND_BRANCH [%195] // if (r10 != 11) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %202 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %r11.11 = ALLOCA/LOCAL size=4 align=4 + * %x.9 = ALLOCA/LOCAL size=4 align=4 + * %203 = MEMORY/LOAD_LE_32 [%x.9] // x + * %204 = CONST/INT32 5 // 5 + * %205 = CMP_LT [%203, %204] // x < 5 + * %206 = MEMORY/LOAD_LE_32 [%x.9] // x + * %207 = CONST/INT32 1 // 1 + * %208 = ADD [%206, %207] // x + 1 + * %209 = MEMORY/LOAD_LE_32 [%x.9] // x + * %210 = CONST/INT32 1 // 1 + * %211 = SUB [%209, %210] // x - 1 + * %212 = SELECT [%205, %208, %211] // (x < 5) ? (x + 1) : (x - 1) + * >> %r11.213 = MEMORY/STORE_LE_32 [%r11.11, %212] + * %214 = MEMORY/LOAD_LE_32 [%r11.11] // r11 + * %215 = CONST/INT32 9 // 9 + * %216 = CMP_NE [%214, %215] // r11 != 9 + * >> %217 = COND_BRANCH [%216] // if (r11 != 9) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %223 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %r12.12 = ALLOCA/LOCAL size=4 align=4 + * %224 = CONST/INT32 1 // 1 + * %225 = CONST/INT32 0 // 0 + * %226 = LOGICAL_AND [%224, %225] // 1 && 0 + * %227 = CONST/INT32 1 // 1 + * %228 = LOGICAL_OR [%226, %227] // (1 && 0) || 1 + * >> %r12.229 = MEMORY/STORE_LE_32 [%r12.12, %228] + * %230 = MEMORY/LOAD_LE_32 [%r12.12] // r12 + * %231 = CONST/INT32 1 // 1 + * %232 = CMP_NE [%230, %231] // r12 != 1 + * >> %233 = COND_BRANCH [%232] // if (r12 != 1) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %239 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %r13.13 = ALLOCA/LOCAL size=4 align=4 + * %240 = CONST/INT32 0 // 0 + * %241 = CONST/INT32 1 // 1 + * %242 = CONST/INT32 1 // 1 + * %243 = LOGICAL_AND [%241, %242] // 1 && 1 + * %244 = LOGICAL_OR [%240, %243] // 0 || (1 && 1) + * >> %r13.245 = MEMORY/STORE_LE_32 [%r13.13, %244] + * %246 = MEMORY/LOAD_LE_32 [%r13.13] // r13 + * %247 = CONST/INT32 1 // 1 + * %248 = CMP_NE [%246, %247] // r13 != 1 + * >> %249 = COND_BRANCH [%248] // if (r13 != 1) return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %255 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %r14.14 = ALLOCA/LOCAL size=4 align=4 + * %256 = CONST/INT32 0 // 0 + * %257 = LOGICAL_NOT [%256] // !0 + * %258 = CONST/INT32 0 // 0 + * %259 = LOGICAL_NOT [%258] // !0 + * %260 = LOGICAL_AND [%257, %259] // !0 && !0 + * >> %r14.261 = MEMORY/STORE_LE_32 [%r14.14, %260] + * %262 = MEMORY/LOAD_LE_32 [%r14.14] // r14 + * %263 = CONST/INT32 1 // 1 + * %264 = CMP_NE [%262, %263] // r14 != 1 + * >> %265 = COND_BRANCH [%264] // if (r14 != 1) return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %271 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %r15.15 = ALLOCA/LOCAL size=4 align=4 + * %272 = CONST/INT32 1 // 1 + * %273 = LOGICAL_NOT [%272] // !1 + * %274 = CONST/INT32 0 // 0 + * %275 = LOGICAL_NOT [%274] // !0 + * %276 = LOGICAL_OR [%273, %275] // !1 || !0 + * >> %r15.277 = MEMORY/STORE_LE_32 [%r15.15, %276] + * %278 = MEMORY/LOAD_LE_32 [%r15.15] // r15 + * %279 = CONST/INT32 1 // 1 + * %280 = CMP_NE [%278, %279] // r15 != 1 + * >> %281 = COND_BRANCH [%280] // if (r15 != 1) return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %287 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %a.16 = ALLOCA/LOCAL size=4 align=4 + * %288 = CONST/INT32 5 // 5 + * >> %a.289 = MEMORY/STORE_LE_32 [%a.16, %288] + * %b.17 = ALLOCA/LOCAL size=4 align=4 + * %290 = CONST/INT32 0 // 0 + * >> %b.291 = MEMORY/STORE_LE_32 [%b.17, %290] + * %c.18 = ALLOCA/LOCAL size=4 align=4 + * %292 = CONST/INT32 3 // 3 + * >> %c.293 = MEMORY/STORE_LE_32 [%c.18, %292] + * %r16.19 = ALLOCA/LOCAL size=4 align=4 + * %294 = MEMORY/LOAD_LE_32 [%a.16] // a + * %295 = MEMORY/LOAD_LE_32 [%b.17] // b + * %296 = LOGICAL_AND [%294, %295] // a && b + * >> %r16.297 = MEMORY/STORE_LE_32 [%r16.19, %296] + * %298 = MEMORY/LOAD_LE_32 [%r16.19] // r16 + * %299 = CONST/INT32 0 // 0 + * %300 = CMP_NE [%298, %299] // r16 != 0 + * >> %301 = COND_BRANCH [%300] // if (r16 != 0) return 16 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %307 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %r17.20 = ALLOCA/LOCAL size=4 align=4 + * %a.16 = ALLOCA/LOCAL size=4 align=4 + * %308 = MEMORY/LOAD_LE_32 [%a.16] // a + * %b.17 = ALLOCA/LOCAL size=4 align=4 + * %309 = MEMORY/LOAD_LE_32 [%b.17] // b + * %310 = LOGICAL_OR [%308, %309] // a || b + * >> %r17.311 = MEMORY/STORE_LE_32 [%r17.20, %310] + * %312 = MEMORY/LOAD_LE_32 [%r17.20] // r17 + * %313 = CONST/INT32 1 // 1 + * %314 = CMP_NE [%312, %313] // r17 != 1 + * >> %315 = COND_BRANCH [%314] // if (r17 != 1) return 17 + * -> [block_50, block_51] + * block_51 IF_ELSE <- [block_49]: + * >> %321 = IMPLICIT_GOTO + * -> [block_52] + * block_52 IF_MERGE <- [block_51]: + * %r18.21 = ALLOCA/LOCAL size=4 align=4 + * %b.17 = ALLOCA/LOCAL size=4 align=4 + * %322 = MEMORY/LOAD_LE_32 [%b.17] // b + * %c.18 = ALLOCA/LOCAL size=4 align=4 + * %323 = MEMORY/LOAD_LE_32 [%c.18] // c + * %324 = LOGICAL_OR [%322, %323] // b || c + * >> %r18.325 = MEMORY/STORE_LE_32 [%r18.21, %324] + * %326 = MEMORY/LOAD_LE_32 [%r18.21] // r18 + * %327 = CONST/INT32 1 // 1 + * %328 = CMP_NE [%326, %327] // r18 != 1 + * >> %329 = COND_BRANCH [%328] // if (r18 != 1) return 18 + * -> [block_53, block_54] + * block_54 IF_ELSE <- [block_52]: + * >> %335 = IMPLICIT_GOTO + * -> [block_55] + * block_55 IF_MERGE <- [block_54]: + * %r19.22 = ALLOCA/LOCAL size=4 align=4 + * %a.16 = ALLOCA/LOCAL size=4 align=4 + * %336 = MEMORY/LOAD_LE_32 [%a.16] // a + * %b.17 = ALLOCA/LOCAL size=4 align=4 + * %337 = MEMORY/LOAD_LE_32 [%b.17] // b + * %c.18 = ALLOCA/LOCAL size=4 align=4 + * %338 = MEMORY/LOAD_LE_32 [%c.18] // c + * %339 = SELECT [%336, %337, %338] // a ? b : c + * >> %r19.340 = MEMORY/STORE_LE_32 [%r19.22, %339] + * %341 = MEMORY/LOAD_LE_32 [%r19.22] // r19 + * %342 = CONST/INT32 0 // 0 + * %343 = CMP_NE [%341, %342] // r19 != 0 + * >> %344 = COND_BRANCH [%343] // if (r19 != 0) return 19 + * -> [block_56, block_57] + * block_57 IF_ELSE <- [block_55]: + * >> %350 = IMPLICIT_GOTO + * -> [block_58] + * block_58 IF_MERGE <- [block_57]: + * %r20.23 = ALLOCA/LOCAL size=4 align=4 + * %b.17 = ALLOCA/LOCAL size=4 align=4 + * %351 = MEMORY/LOAD_LE_32 [%b.17] // b + * %a.16 = ALLOCA/LOCAL size=4 align=4 + * %352 = MEMORY/LOAD_LE_32 [%a.16] // a + * %c.18 = ALLOCA/LOCAL size=4 align=4 + * %353 = MEMORY/LOAD_LE_32 [%c.18] // c + * %354 = SELECT [%351, %352, %353] // b ? a : c + * >> %r20.355 = MEMORY/STORE_LE_32 [%r20.23, %354] + * %356 = MEMORY/LOAD_LE_32 [%r20.23] // r20 + * %357 = CONST/INT32 3 // 3 + * %358 = CMP_NE [%356, %357] // r20 != 3 + * >> %359 = COND_BRANCH [%358] // if (r20 != 3) return 20 + * -> [block_59, block_60] + * block_60 IF_ELSE <- [block_58]: + * >> %365 = IMPLICIT_GOTO + * -> [block_61] + * block_61 IF_MERGE <- [block_60]: + * %367 = RETURN_PTR // return 0 + * %366 = CONST/INT32 0 // 0 + * >> %368 = MEMORY/STORE_LE_32 [%367, %366] // return 0 + * >> %369 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %370 = RET [%366] // return 0 + * block_59 IF_THEN <- [block_58]: + * %361 = RETURN_PTR // return 20 + * %360 = CONST/INT32 20 // 20 + * >> %362 = MEMORY/STORE_LE_32 [%361, %360] // return 20 + * >> %363 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %364 = RET [%360] // return 20 + * block_56 IF_THEN <- [block_55]: + * %346 = RETURN_PTR // return 19 + * %345 = CONST/INT32 19 // 19 + * >> %347 = MEMORY/STORE_LE_32 [%346, %345] // return 19 + * >> %348 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %349 = RET [%345] // return 19 + * block_53 IF_THEN <- [block_52]: + * %331 = RETURN_PTR // return 18 + * %330 = CONST/INT32 18 // 18 + * >> %332 = MEMORY/STORE_LE_32 [%331, %330] // return 18 + * >> %333 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %334 = RET [%330] // return 18 + * block_50 IF_THEN <- [block_49]: + * %317 = RETURN_PTR // return 17 + * %316 = CONST/INT32 17 // 17 + * >> %318 = MEMORY/STORE_LE_32 [%317, %316] // return 17 + * >> %319 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %320 = RET [%316] // return 17 + * block_47 IF_THEN <- [block_46]: + * %303 = RETURN_PTR // return 16 + * %302 = CONST/INT32 16 // 16 + * >> %304 = MEMORY/STORE_LE_32 [%303, %302] // return 16 + * >> %305 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %306 = RET [%302] // return 16 + * block_44 IF_THEN <- [block_43]: + * %283 = RETURN_PTR // return 15 + * %282 = CONST/INT32 15 // 15 + * >> %284 = MEMORY/STORE_LE_32 [%283, %282] // return 15 + * >> %285 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %286 = RET [%282] // return 15 + * block_41 IF_THEN <- [block_40]: + * %267 = RETURN_PTR // return 14 + * %266 = CONST/INT32 14 // 14 + * >> %268 = MEMORY/STORE_LE_32 [%267, %266] // return 14 + * >> %269 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %270 = RET [%266] // return 14 + * block_38 IF_THEN <- [block_37]: + * %251 = RETURN_PTR // return 13 + * %250 = CONST/INT32 13 // 13 + * >> %252 = MEMORY/STORE_LE_32 [%251, %250] // return 13 + * >> %253 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %254 = RET [%250] // return 13 + * block_35 IF_THEN <- [block_34]: + * %235 = RETURN_PTR // return 12 + * %234 = CONST/INT32 12 // 12 + * >> %236 = MEMORY/STORE_LE_32 [%235, %234] // return 12 + * >> %237 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %238 = RET [%234] // return 12 + * block_32 IF_THEN <- [block_31]: + * %219 = RETURN_PTR // return 11 + * %218 = CONST/INT32 11 // 11 + * >> %220 = MEMORY/STORE_LE_32 [%219, %218] // return 11 + * >> %221 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %222 = RET [%218] // return 11 + * block_29 IF_THEN <- [block_28]: + * %198 = RETURN_PTR // return 10 + * %197 = CONST/INT32 10 // 10 + * >> %199 = MEMORY/STORE_LE_32 [%198, %197] // return 10 + * >> %200 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %201 = RET [%197] // return 10 + * block_26 IF_THEN <- [block_25]: + * %175 = RETURN_PTR // return 9 + * %174 = CONST/INT32 9 // 9 + * >> %176 = MEMORY/STORE_LE_32 [%175, %174] // return 9 + * >> %177 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %178 = RET [%174] // return 9 + * block_23 IF_THEN <- [block_22]: + * %156 = RETURN_PTR // return 8 + * %155 = CONST/INT32 8 // 8 + * >> %157 = MEMORY/STORE_LE_32 [%156, %155] // return 8 + * >> %158 = EXIT_SCOPE // unreachable_function() + * >> %159 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %160 = RET [%155] // return 8 + * block_20 IF_THEN <- [block_19]: + * %137 = RETURN_PTR // return 7 + * %136 = CONST/INT32 7 // 7 + * >> %138 = MEMORY/STORE_LE_32 [%137, %136] // return 7 + * >> %139 = EXIT_SCOPE // unreachable_function() + * >> %140 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %141 = RET [%136] // return 7 + * block_17 IF_THEN <- [block_16]: + * %119 = RETURN_PTR // return 6 + * %118 = CONST/INT32 6 // 6 + * >> %120 = MEMORY/STORE_LE_32 [%119, %118] // return 6 + * >> %121 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %122 = RET [%118] // return 6 + * block_14 IF_THEN <- [block_13]: + * %105 = RETURN_PTR // return 5 + * %104 = CONST/INT32 5 // 5 + * >> %106 = MEMORY/STORE_LE_32 [%105, %104] // return 5 + * >> %107 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %108 = RET [%104] // return 5 + * block_11 IF_THEN <- [block_10]: + * %90 = RETURN_PTR // return 4 + * %89 = CONST/INT32 4 // 4 + * >> %91 = MEMORY/STORE_LE_32 [%90, %89] // return 4 + * >> %92 = EXIT_SCOPE // unreachable_function() + * >> %93 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %94 = RET [%89] // return 4 + * block_8 IF_THEN <- [block_7]: + * %73 = RETURN_PTR // return 3 + * %72 = CONST/INT32 3 // 3 + * >> %74 = MEMORY/STORE_LE_32 [%73, %72] // return 3 + * >> %75 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %76 = RET [%72] // return 3 + * block_5 IF_THEN <- [block_4]: + * %59 = RETURN_PTR // return 2 + * %58 = CONST/INT32 2 // 2 + * >> %60 = MEMORY/STORE_LE_32 [%59, %58] // return 2 + * >> %61 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %62 = RET [%58] // return 2 + * block_2 IF_THEN <- [block_1]: + * %44 = RETURN_PTR // return 1 + * %43 = CONST/INT32 1 // 1 + * >> %45 = MEMORY/STORE_LE_32 [%44, %43] // return 1 + * >> %46 = EXIT_SCOPE // increment_and_return(1) + * >> %47 = EXIT_SCOPE // { // --- Short-circuit AND --- // false... + * >> %48 = RET [%43] // return 1 + * } + */ + + + + + + + + + + +static int side_effect_counter; + +static int increment_and_return(int val) { + side_effect_counter++; + return val; +} + +static int unreachable_function(void) { + // If this is ever "executed" by the interpreter, something is wrong. + // We can't trap here, but we return a sentinel value. + return 99999; +} + +int test_conditional_exec(void) { + // --- Short-circuit AND --- + // false && X: X should not be evaluated. + side_effect_counter = 0; + int r1 = 0 && increment_and_return(1); + if (r1 != 0) return 1; + // side_effect_counter would be 0 if short-circuit works, + // but our IR evaluates both sides (they're marked conditionally executed). + // The result should still be 0 regardless. + + // true && true: both evaluated, result = 1. + int r2 = 1 && 1; + if (r2 != 1) return 2; + + // true && false: result = 0. + int r3 = 1 && 0; + if (r3 != 0) return 3; + + // --- Short-circuit OR --- + // true || X: X should not be evaluated. + int r4 = 1 || unreachable_function(); + if (r4 != 1) return 4; + + // false || true: result = 1. + int r5 = 0 || 1; + if (r5 != 1) return 5; + + // false || false: result = 0. + int r6 = 0 || 0; + if (r6 != 0) return 6; + + // --- Ternary operator --- + // true ? a : b → a. + int r7 = 1 ? 42 : unreachable_function(); + if (r7 != 42) return 7; + + // false ? a : b → b. + int r8 = 0 ? unreachable_function() : 43; + if (r8 != 43) return 8; + + // Nested ternary. + int r9 = 1 ? (0 ? 100 : 200) : 300; + if (r9 != 200) return 9; + + // Ternary with side effects in the chosen branch only. + int x = 10; + int r10 = (x > 5) ? (x + 1) : (x - 1); + if (r10 != 11) return 10; + + int r11 = (x < 5) ? (x + 1) : (x - 1); + if (r11 != 9) return 11; + + // --- Complex combinations --- + // (a && b) || c + int r12 = (1 && 0) || 1; + if (r12 != 1) return 12; + + // a || (b && c) + int r13 = 0 || (1 && 1); + if (r13 != 1) return 13; + + // Negated conditions. + int r14 = !0 && !0; + if (r14 != 1) return 14; + + int r15 = !1 || !0; + if (r15 != 1) return 15; + + // --- Variables in conditions --- + int a = 5, b = 0, c = 3; + + // a && b: 5 && 0 = 0. + int r16 = a && b; + if (r16 != 0) return 16; + + // a || b: 5 || 0 = 1. + int r17 = a || b; + if (r17 != 1) return 17; + + // b || c: 0 || 3 = 1. + int r18 = b || c; + if (r18 != 1) return 18; + + // a ? b : c → 0 (because a is truthy, picks b which is 0). + int r19 = a ? b : c; + if (r19 != 0) return 19; + + // b ? a : c → 3 (because b is falsy, picks c). + int r20 = b ? a : c; + if (r20 != 3) return 20; + + return 0; +} diff --git a/tests/InterpretIR/test_control_flow.c b/tests/InterpretIR/test_control_flow.c new file mode 100644 index 000000000..693a1145b --- /dev/null +++ b/tests/InterpretIR/test_control_flow.c @@ -0,0 +1,582 @@ +// Tests: if/else (COND_BRANCH), while loop (LOOP_PREHEADER, LOOP_CONDITION, +// LOOP_BODY, LOOP_EXIT), for loop (FOR_INIT, LOOP_INCREMENT), do-while, +// break (BREAK), continue (CONTINUE), nested loops, early return (RET), +// and the ternary operator (SELECT). + +/* + * Expected IR: + * + * function test_control_flow (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (result) + * obj_1 LOCAL_VALUE size=4 align=4 (sum) + * obj_2 LOCAL_VALUE size=4 align=4 (i) + * obj_3 LOCAL_VALUE size=4 align=4 (fact) + * obj_4 LOCAL_VALUE size=4 align=4 (j) + * obj_5 LOCAL_VALUE size=4 align=4 (count) + * obj_6 LOCAL_VALUE size=4 align=4 (brk) + * obj_7 LOCAL_VALUE size=4 align=4 (k) + * obj_8 LOCAL_VALUE size=4 align=4 (cont) + * obj_9 LOCAL_VALUE size=4 align=4 (k) + * obj_10 LOCAL_VALUE size=4 align=4 (nested) + * obj_11 LOCAL_VALUE size=4 align=4 (a) + * obj_12 LOCAL_VALUE size=4 align=4 (b) + * obj_13 LOCAL_VALUE size=4 align=4 (sel) + * obj_14 LOCAL_VALUE size=4 align=4 (inner) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %result.0 = ALLOCA/LOCAL size=4 align=4 + * >> %sum.1 = ALLOCA/LOCAL size=4 align=4 + * >> %i.2 = ALLOCA/LOCAL size=4 align=4 + * >> %fact.3 = ALLOCA/LOCAL size=4 align=4 + * >> %j.4 = ALLOCA/LOCAL size=4 align=4 + * >> %count.5 = ALLOCA/LOCAL size=4 align=4 + * >> %brk.6 = ALLOCA/LOCAL size=4 align=4 + * >> %k.7 = ALLOCA/LOCAL size=4 align=4 + * >> %cont.8 = ALLOCA/LOCAL size=4 align=4 + * >> %k.9 = ALLOCA/LOCAL size=4 align=4 + * >> %nested.10 = ALLOCA/LOCAL size=4 align=4 + * >> %a.11 = ALLOCA/LOCAL size=4 align=4 + * >> %b.12 = ALLOCA/LOCAL size=4 align=4 + * >> %sel.13 = ALLOCA/LOCAL size=4 align=4 + * >> %inner.14 = ALLOCA/LOCAL size=4 align=4 + * >> %15 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %16 = ENTER_SCOPE // { int result = 0; // If/else. if (... + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %17 = CONST/INT32 0 // 0 + * >> %result.18 = MEMORY/STORE_LE_32 [%result.0, %17] + * %19 = CONST/INT32 1 // 1 + * >> %20 = COND_BRANCH [%19] // if (1) result = 1; else result = -1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %24 = CONST/INT32 1 // 1 + * %25 = NEG [%24] // -1 + * >> %26 = MEMORY/STORE_LE_32 [%result.0, %25] // result = -1 + * >> %27 = IMPLICIT_GOTO + * -> [block_4] + * block_2 IF_THEN <- [block_1]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %21 = CONST/INT32 1 // 1 + * >> %22 = MEMORY/STORE_LE_32 [%result.0, %21] // result = 1 + * >> %23 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_2, block_3]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %28 = MEMORY/LOAD_LE_32 [%result.0] // result + * %29 = CONST/INT32 1 // 1 + * %30 = CMP_NE [%28, %29] // result != 1 + * >> %31 = COND_BRANCH [%30] // if (result != 1) return 1 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %37 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %sum.1 = ALLOCA/LOCAL size=4 align=4 + * %38 = CONST/INT32 0 // 0 + * >> %sum.39 = MEMORY/STORE_LE_32 [%sum.1, %38] + * %i.2 = ALLOCA/LOCAL size=4 align=4 + * %40 = CONST/INT32 1 // 1 + * >> %i.41 = MEMORY/STORE_LE_32 [%i.2, %40] + * >> %42 = IMPLICIT_GOTO + * -> [block_8] + * block_8 LOOP_PREHEADER <- [block_7]: + * >> %43 = IMPLICIT_GOTO + * -> [block_9] + * block_9 LOOP_CONDITION <- [block_8, block_10]: + * %i.2 = ALLOCA/LOCAL size=4 align=4 + * %44 = MEMORY/LOAD_LE_32 [%i.2] // i + * %45 = CONST/INT32 5 // 5 + * %46 = CMP_LE [%44, %45] // i <= 5 + * >> %47 = COND_BRANCH [%46] // while (i <= 5) { sum += i; i++;... + * -> [block_10, block_11] + * block_11 LOOP_EXIT <- [block_9]: + * %sum.1 = ALLOCA/LOCAL size=4 align=4 + * %55 = MEMORY/LOAD_LE_32 [%sum.1] // sum + * %56 = CONST/INT32 15 // 15 + * %57 = CMP_NE [%55, %56] // sum != 15 + * >> %58 = COND_BRANCH [%57] // if (sum != 15) return 2 + * -> [block_12, block_13] + * block_13 IF_ELSE <- [block_11]: + * >> %64 = IMPLICIT_GOTO + * -> [block_14] + * block_14 IF_MERGE <- [block_13]: + * %fact.3 = ALLOCA/LOCAL size=4 align=4 + * %65 = CONST/INT32 1 // 1 + * >> %fact.66 = MEMORY/STORE_LE_32 [%fact.3, %65] + * >> %67 = ENTER_SCOPE // for (int j = 1; j <= 5; j++) { fact *= ... + * >> %68 = IMPLICIT_GOTO + * -> [block_15] + * block_15 LOOP_PREHEADER <- [block_14]: + * %j.4 = ALLOCA/LOCAL size=4 align=4 + * %69 = CONST/INT32 1 // 1 + * >> %j.70 = MEMORY/STORE_LE_32 [%j.4, %69] + * >> %71 = IMPLICIT_GOTO + * -> [block_16] + * block_16 LOOP_CONDITION <- [block_15, block_18]: + * %j.4 = ALLOCA/LOCAL size=4 align=4 + * %72 = MEMORY/LOAD_LE_32 [%j.4] // j + * %73 = CONST/INT32 5 // 5 + * %74 = CMP_LE [%72, %73] // j <= 5 + * >> %75 = COND_BRANCH [%74] // for (int j = 1; j <= 5; j++) { fact *= ... + * -> [block_17, block_19] + * block_19 LOOP_EXIT <- [block_16]: + * >> %84 = EXIT_SCOPE // for (int j = 1; j <= 5; j++) { fact *= ... + * %fact.3 = ALLOCA/LOCAL size=4 align=4 + * %85 = MEMORY/LOAD_LE_32 [%fact.3] // fact + * %86 = CONST/INT32 120 // 120 + * %87 = CMP_NE [%85, %86] // fact != 120 + * >> %88 = COND_BRANCH [%87] // if (fact != 120) return 3 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %94 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %count.5 = ALLOCA/LOCAL size=4 align=4 + * %95 = CONST/INT32 0 // 0 + * >> %count.96 = MEMORY/STORE_LE_32 [%count.5, %95] + * >> %97 = IMPLICIT_GOTO + * -> [block_23] + * block_23 LOOP_PREHEADER <- [block_22]: + * >> %98 = IMPLICIT_GOTO + * -> [block_24] + * block_24 LOOP_BODY <- [block_23, block_25]: + * >> %99 = ENTER_SCOPE // { count++; } + * %count.5 = ALLOCA/LOCAL size=4 align=4 + * %100 = CONST/INT32 1 // count++ + * >> %101 = READ_MODIFY_WRITE(ADD old) [%count.5, %100] // count++ + * >> %102 = EXIT_SCOPE // { count++; } + * >> %103 = IMPLICIT_GOTO + * -> [block_25] + * block_25 LOOP_CONDITION <- [block_24]: + * %count.5 = ALLOCA/LOCAL size=4 align=4 + * %104 = MEMORY/LOAD_LE_32 [%count.5] // count + * %105 = CONST/INT32 3 // 3 + * %106 = CMP_LT [%104, %105] // count < 3 + * >> %107 = COND_BRANCH [%106] // do { count++; } while (count < 3) + * -> [block_24, block_26] + * block_26 LOOP_EXIT <- [block_25]: + * %count.5 = ALLOCA/LOCAL size=4 align=4 + * %108 = MEMORY/LOAD_LE_32 [%count.5] // count + * %109 = CONST/INT32 3 // 3 + * %110 = CMP_NE [%108, %109] // count != 3 + * >> %111 = COND_BRANCH [%110] // if (count != 3) return 4 + * -> [block_27, block_28] + * block_28 IF_ELSE <- [block_26]: + * >> %117 = IMPLICIT_GOTO + * -> [block_29] + * block_29 IF_MERGE <- [block_28]: + * %brk.6 = ALLOCA/LOCAL size=4 align=4 + * %118 = CONST/INT32 0 // 0 + * >> %brk.119 = MEMORY/STORE_LE_32 [%brk.6, %118] + * >> %120 = ENTER_SCOPE // for (int k = 0; k < 100; k++) { if (k =... + * >> %121 = IMPLICIT_GOTO + * -> [block_30] + * block_30 LOOP_PREHEADER <- [block_29]: + * %k.7 = ALLOCA/LOCAL size=4 align=4 + * %122 = CONST/INT32 0 // 0 + * >> %k.123 = MEMORY/STORE_LE_32 [%k.7, %122] + * >> %124 = IMPLICIT_GOTO + * -> [block_31] + * block_31 LOOP_CONDITION <- [block_30, block_33]: + * %k.7 = ALLOCA/LOCAL size=4 align=4 + * %125 = MEMORY/LOAD_LE_32 [%k.7] // k + * %126 = CONST/INT32 100 // 100 + * %127 = CMP_LT [%125, %126] // k < 100 + * >> %128 = COND_BRANCH [%127] // for (int k = 0; k < 100; k++) { if (k =... + * -> [block_32, block_34] + * block_32 LOOP_BODY <- [block_31]: + * >> %129 = ENTER_SCOPE // { if (k == 5) break; brk++; } + * %k.7 = ALLOCA/LOCAL size=4 align=4 + * %130 = MEMORY/LOAD_LE_32 [%k.7] // k + * %131 = CONST/INT32 5 // 5 + * %132 = CMP_EQ [%130, %131] // k == 5 + * >> %133 = COND_BRANCH [%132] // if (k == 5) break + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_32]: + * >> %137 = IMPLICIT_GOTO + * -> [block_38] + * block_38 IF_MERGE <- [block_36]: + * %brk.6 = ALLOCA/LOCAL size=4 align=4 + * %138 = CONST/INT32 1 // brk++ + * >> %139 = READ_MODIFY_WRITE(ADD old) [%brk.6, %138] // brk++ + * >> %140 = EXIT_SCOPE // { if (k == 5) break; brk++; } + * >> %141 = IMPLICIT_GOTO + * -> [block_33] + * block_33 LOOP_INCREMENT <- [block_38]: + * %k.7 = ALLOCA/LOCAL size=4 align=4 + * %142 = CONST/INT32 1 // k++ + * >> %143 = READ_MODIFY_WRITE(ADD old) [%k.7, %142] // k++ + * >> %144 = IMPLICIT_GOTO + * -> [block_31] + * block_35 IF_THEN <- [block_32]: + * >> %134 = EXIT_SCOPE // { if (k == 5) break; brk++; } + * >> %135 = BREAK // break + * -> [block_34] + * block_34 LOOP_EXIT <- [block_31, block_35]: + * >> %145 = EXIT_SCOPE // for (int k = 0; k < 100; k++) { if (k =... + * %brk.6 = ALLOCA/LOCAL size=4 align=4 + * %146 = MEMORY/LOAD_LE_32 [%brk.6] // brk + * %147 = CONST/INT32 5 // 5 + * %148 = CMP_NE [%146, %147] // brk != 5 + * >> %149 = COND_BRANCH [%148] // if (brk != 5) return 5 + * -> [block_39, block_40] + * block_40 IF_ELSE <- [block_34]: + * >> %155 = IMPLICIT_GOTO + * -> [block_41] + * block_41 IF_MERGE <- [block_40]: + * %cont.8 = ALLOCA/LOCAL size=4 align=4 + * %156 = CONST/INT32 0 // 0 + * >> %cont.157 = MEMORY/STORE_LE_32 [%cont.8, %156] + * >> %158 = ENTER_SCOPE // for (int k = 0; k < 10; k++) { if (k % ... + * >> %159 = IMPLICIT_GOTO + * -> [block_42] + * block_42 LOOP_PREHEADER <- [block_41]: + * %k.9 = ALLOCA/LOCAL size=4 align=4 + * %160 = CONST/INT32 0 // 0 + * >> %k.161 = MEMORY/STORE_LE_32 [%k.9, %160] + * >> %162 = IMPLICIT_GOTO + * -> [block_43] + * block_43 LOOP_CONDITION <- [block_42, block_45]: + * %k.9 = ALLOCA/LOCAL size=4 align=4 + * %163 = MEMORY/LOAD_LE_32 [%k.9] // k + * %164 = CONST/INT32 10 // 10 + * %165 = CMP_LT [%163, %164] // k < 10 + * >> %166 = COND_BRANCH [%165] // for (int k = 0; k < 10; k++) { if (k % ... + * -> [block_44, block_46] + * block_46 LOOP_EXIT <- [block_43]: + * >> %185 = EXIT_SCOPE // for (int k = 0; k < 10; k++) { if (k % ... + * %cont.8 = ALLOCA/LOCAL size=4 align=4 + * %186 = MEMORY/LOAD_LE_32 [%cont.8] // cont + * %187 = CONST/INT32 5 // 5 + * %188 = CMP_NE [%186, %187] // cont != 5 + * >> %189 = COND_BRANCH [%188] // if (cont != 5) return 6 + * -> [block_51, block_52] + * block_52 IF_ELSE <- [block_46]: + * >> %195 = IMPLICIT_GOTO + * -> [block_53] + * block_53 IF_MERGE <- [block_52]: + * %nested.10 = ALLOCA/LOCAL size=4 align=4 + * %196 = CONST/INT32 0 // 0 + * >> %nested.197 = MEMORY/STORE_LE_32 [%nested.10, %196] + * >> %198 = ENTER_SCOPE // for (int a = 0; a < 3; a++) { for (int ... + * >> %199 = IMPLICIT_GOTO + * -> [block_54] + * block_54 LOOP_PREHEADER <- [block_53]: + * %a.11 = ALLOCA/LOCAL size=4 align=4 + * %200 = CONST/INT32 0 // 0 + * >> %a.201 = MEMORY/STORE_LE_32 [%a.11, %200] + * >> %202 = IMPLICIT_GOTO + * -> [block_55] + * block_55 LOOP_CONDITION <- [block_54, block_57]: + * %a.11 = ALLOCA/LOCAL size=4 align=4 + * %203 = MEMORY/LOAD_LE_32 [%a.11] // a + * %204 = CONST/INT32 3 // 3 + * %205 = CMP_LT [%203, %204] // a < 3 + * >> %206 = COND_BRANCH [%205] // for (int a = 0; a < 3; a++) { for (int ... + * -> [block_56, block_58] + * block_58 LOOP_EXIT <- [block_55]: + * >> %231 = EXIT_SCOPE // for (int a = 0; a < 3; a++) { for (int ... + * %nested.10 = ALLOCA/LOCAL size=4 align=4 + * %232 = MEMORY/LOAD_LE_32 [%nested.10] // nested + * %233 = CONST/INT32 9 // 9 + * %234 = CMP_NE [%232, %233] // nested != 9 + * >> %235 = COND_BRANCH [%234] // if (nested != 9) return 7 + * -> [block_64, block_65] + * block_65 IF_ELSE <- [block_58]: + * >> %241 = IMPLICIT_GOTO + * -> [block_66] + * block_66 IF_MERGE <- [block_65]: + * %sel.13 = ALLOCA/LOCAL size=4 align=4 + * %242 = CONST/INT32 1 // 1 + * %243 = CONST/INT32 0 // 0 + * %244 = CMP_GT [%242, %243] // 1 > 0 + * %245 = CONST/INT32 42 // 42 + * %246 = CONST/INT32 1 // 1 + * %247 = NEG [%246] // -1 + * %248 = SELECT [%244, %245, %247] // (1 > 0) ? 42 : -1 + * >> %sel.249 = MEMORY/STORE_LE_32 [%sel.13, %248] + * %250 = MEMORY/LOAD_LE_32 [%sel.13] // sel + * %251 = CONST/INT32 42 // 42 + * %252 = CMP_NE [%250, %251] // sel != 42 + * >> %253 = COND_BRANCH [%252] // if (sel != 42) return 8 + * -> [block_67, block_68] + * block_68 IF_ELSE <- [block_66]: + * >> %259 = IMPLICIT_GOTO + * -> [block_69] + * block_69 IF_MERGE <- [block_68]: + * >> %260 = ENTER_SCOPE // { int inner = 0; { ... + * %inner.14 = ALLOCA/LOCAL size=4 align=4 + * %261 = CONST/INT32 0 // 0 + * >> %inner.262 = MEMORY/STORE_LE_32 [%inner.14, %261] + * >> %263 = ENTER_SCOPE // { inner = 77; if (inner... + * %264 = CONST/INT32 77 // 77 + * >> %265 = MEMORY/STORE_LE_32 [%inner.14, %264] // inner = 77 + * %266 = MEMORY/LOAD_LE_32 [%inner.14] // inner + * %267 = CONST/INT32 77 // 77 + * %268 = CMP_EQ [%266, %267] // inner == 77 + * >> %269 = COND_BRANCH [%268] // if (inner == 77) return 0 + * -> [block_70, block_71] + * block_71 IF_ELSE <- [block_69]: + * >> %277 = IMPLICIT_GOTO + * -> [block_72] + * block_72 IF_MERGE <- [block_71]: + * %inner.14 = ALLOCA/LOCAL size=4 align=4 + * %278 = CONST/INT32 1 // 1 + * %279 = NEG [%278] // -1 + * >> %280 = MEMORY/STORE_LE_32 [%inner.14, %279] // inner = -1 + * >> %281 = EXIT_SCOPE // { inner = 77; if (inner... + * %282 = CONST/INT32 1 // 1 + * %283 = NEG [%282] // -1 + * >> %284 = MEMORY/STORE_LE_32 [%inner.14, %283] // inner = -1 + * >> %285 = EXIT_SCOPE // { int inner = 0; { ... + * %287 = RETURN_PTR // return 0 + * %286 = CONST/INT32 0 // 0 + * >> %288 = MEMORY/STORE_LE_32 [%287, %286] // return 0 + * >> %289 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %290 = RET [%286] // return 0 + * block_70 IF_THEN <- [block_69]: + * %271 = RETURN_PTR // return 0 + * %270 = CONST/INT32 0 // 0 + * >> %272 = MEMORY/STORE_LE_32 [%271, %270] // return 0 + * >> %273 = EXIT_SCOPE // { inner = 77; if (inner... + * >> %274 = EXIT_SCOPE // { int inner = 0; { ... + * >> %275 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %276 = RET [%270] // return 0 + * block_67 IF_THEN <- [block_66]: + * %255 = RETURN_PTR // return 8 + * %254 = CONST/INT32 8 // 8 + * >> %256 = MEMORY/STORE_LE_32 [%255, %254] // return 8 + * >> %257 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %258 = RET [%254] // return 8 + * block_64 IF_THEN <- [block_58]: + * %237 = RETURN_PTR // return 7 + * %236 = CONST/INT32 7 // 7 + * >> %238 = MEMORY/STORE_LE_32 [%237, %236] // return 7 + * >> %239 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %240 = RET [%236] // return 7 + * block_56 LOOP_BODY <- [block_55]: + * >> %207 = ENTER_SCOPE // { for (int b = 0; b < 3; b++) { ... + * >> %208 = ENTER_SCOPE // for (int b = 0; b < 3; b++) { neste... + * >> %209 = IMPLICIT_GOTO + * -> [block_59] + * block_59 LOOP_PREHEADER <- [block_56]: + * %b.12 = ALLOCA/LOCAL size=4 align=4 + * %210 = CONST/INT32 0 // 0 + * >> %b.211 = MEMORY/STORE_LE_32 [%b.12, %210] + * >> %212 = IMPLICIT_GOTO + * -> [block_60] + * block_60 LOOP_CONDITION <- [block_59, block_62]: + * %b.12 = ALLOCA/LOCAL size=4 align=4 + * %213 = MEMORY/LOAD_LE_32 [%b.12] // b + * %214 = CONST/INT32 3 // 3 + * %215 = CMP_LT [%213, %214] // b < 3 + * >> %216 = COND_BRANCH [%215] // for (int b = 0; b < 3; b++) { neste... + * -> [block_61, block_63] + * block_63 LOOP_EXIT <- [block_60]: + * >> %225 = EXIT_SCOPE // for (int b = 0; b < 3; b++) { neste... + * >> %226 = EXIT_SCOPE // { for (int b = 0; b < 3; b++) { ... + * >> %227 = IMPLICIT_GOTO + * -> [block_57] + * block_57 LOOP_INCREMENT <- [block_63]: + * %a.11 = ALLOCA/LOCAL size=4 align=4 + * %228 = CONST/INT32 1 // a++ + * >> %229 = READ_MODIFY_WRITE(ADD old) [%a.11, %228] // a++ + * >> %230 = IMPLICIT_GOTO + * -> [block_55] + * block_61 LOOP_BODY <- [block_60]: + * >> %217 = ENTER_SCOPE // { nested++; } + * %nested.10 = ALLOCA/LOCAL size=4 align=4 + * %218 = CONST/INT32 1 // nested++ + * >> %219 = READ_MODIFY_WRITE(ADD old) [%nested.10, %218] // nested++ + * >> %220 = EXIT_SCOPE // { nested++; } + * >> %221 = IMPLICIT_GOTO + * -> [block_62] + * block_62 LOOP_INCREMENT <- [block_61]: + * %b.12 = ALLOCA/LOCAL size=4 align=4 + * %222 = CONST/INT32 1 // b++ + * >> %223 = READ_MODIFY_WRITE(ADD old) [%b.12, %222] // b++ + * >> %224 = IMPLICIT_GOTO + * -> [block_60] + * block_51 IF_THEN <- [block_46]: + * %191 = RETURN_PTR // return 6 + * %190 = CONST/INT32 6 // 6 + * >> %192 = MEMORY/STORE_LE_32 [%191, %190] // return 6 + * >> %193 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %194 = RET [%190] // return 6 + * block_44 LOOP_BODY <- [block_43]: + * >> %167 = ENTER_SCOPE // { if (k % 2 == 0) continue; con... + * %k.9 = ALLOCA/LOCAL size=4 align=4 + * %168 = MEMORY/LOAD_LE_32 [%k.9] // k + * %169 = CONST/INT32 2 // 2 + * %170 = REM [%168, %169] // k % 2 + * %171 = CONST/INT32 0 // 0 + * %172 = CMP_EQ [%170, %171] // k % 2 == 0 + * >> %173 = COND_BRANCH [%172] // if (k % 2 == 0) continue + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_44]: + * >> %177 = IMPLICIT_GOTO + * -> [block_50] + * block_50 IF_MERGE <- [block_48]: + * %cont.8 = ALLOCA/LOCAL size=4 align=4 + * %178 = CONST/INT32 1 // cont++ + * >> %179 = READ_MODIFY_WRITE(ADD old) [%cont.8, %178] // cont++ + * >> %180 = EXIT_SCOPE // { if (k % 2 == 0) continue; con... + * >> %181 = IMPLICIT_GOTO + * -> [block_45] + * block_47 IF_THEN <- [block_44]: + * >> %174 = EXIT_SCOPE // { if (k % 2 == 0) continue; con... + * >> %175 = CONTINUE // continue + * -> [block_45] + * block_45 LOOP_INCREMENT <- [block_47, block_50]: + * %k.9 = ALLOCA/LOCAL size=4 align=4 + * %182 = CONST/INT32 1 // k++ + * >> %183 = READ_MODIFY_WRITE(ADD old) [%k.9, %182] // k++ + * >> %184 = IMPLICIT_GOTO + * -> [block_43] + * block_39 IF_THEN <- [block_34]: + * %151 = RETURN_PTR // return 5 + * %150 = CONST/INT32 5 // 5 + * >> %152 = MEMORY/STORE_LE_32 [%151, %150] // return 5 + * >> %153 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %154 = RET [%150] // return 5 + * block_27 IF_THEN <- [block_26]: + * %113 = RETURN_PTR // return 4 + * %112 = CONST/INT32 4 // 4 + * >> %114 = MEMORY/STORE_LE_32 [%113, %112] // return 4 + * >> %115 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %116 = RET [%112] // return 4 + * block_20 IF_THEN <- [block_19]: + * %90 = RETURN_PTR // return 3 + * %89 = CONST/INT32 3 // 3 + * >> %91 = MEMORY/STORE_LE_32 [%90, %89] // return 3 + * >> %92 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %93 = RET [%89] // return 3 + * block_17 LOOP_BODY <- [block_16]: + * >> %76 = ENTER_SCOPE // { fact *= j; } + * %fact.3 = ALLOCA/LOCAL size=4 align=4 + * %j.4 = ALLOCA/LOCAL size=4 align=4 + * %77 = MEMORY/LOAD_LE_32 [%j.4] // j + * >> %78 = READ_MODIFY_WRITE(MUL new) [%fact.3, %77] // fact *= j + * >> %79 = EXIT_SCOPE // { fact *= j; } + * >> %80 = IMPLICIT_GOTO + * -> [block_18] + * block_18 LOOP_INCREMENT <- [block_17]: + * %j.4 = ALLOCA/LOCAL size=4 align=4 + * %81 = CONST/INT32 1 // j++ + * >> %82 = READ_MODIFY_WRITE(ADD old) [%j.4, %81] // j++ + * >> %83 = IMPLICIT_GOTO + * -> [block_16] + * block_12 IF_THEN <- [block_11]: + * %60 = RETURN_PTR // return 2 + * %59 = CONST/INT32 2 // 2 + * >> %61 = MEMORY/STORE_LE_32 [%60, %59] // return 2 + * >> %62 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %63 = RET [%59] // return 2 + * block_10 LOOP_BODY <- [block_9]: + * >> %48 = ENTER_SCOPE // { sum += i; i++; } + * %sum.1 = ALLOCA/LOCAL size=4 align=4 + * %i.2 = ALLOCA/LOCAL size=4 align=4 + * %49 = MEMORY/LOAD_LE_32 [%i.2] // i + * >> %50 = READ_MODIFY_WRITE(ADD new) [%sum.1, %49] // sum += i + * %51 = CONST/INT32 1 // i++ + * >> %52 = READ_MODIFY_WRITE(ADD old) [%i.2, %51] // i++ + * >> %53 = EXIT_SCOPE // { sum += i; i++; } + * >> %54 = IMPLICIT_GOTO + * -> [block_9] + * block_5 IF_THEN <- [block_4]: + * %33 = RETURN_PTR // return 1 + * %32 = CONST/INT32 1 // 1 + * >> %34 = MEMORY/STORE_LE_32 [%33, %32] // return 1 + * >> %35 = EXIT_SCOPE // { int result = 0; // If/else. if (... + * >> %36 = RET [%32] // return 1 + * } + */ + + + + + + + + + + +int test_control_flow(void) { + int result = 0; + + // If/else. + if (1) result = 1; + else result = -1; + if (result != 1) return 1; + + // While loop: sum 1..5. + int sum = 0; + int i = 1; + while (i <= 5) { + sum += i; + i++; + } + if (sum != 15) return 2; + + // For loop: factorial of 5. + int fact = 1; + for (int j = 1; j <= 5; j++) { + fact *= j; + } + if (fact != 120) return 3; + + // Do-while: count to 3. + int count = 0; + do { + count++; + } while (count < 3); + if (count != 3) return 4; + + // Break. + int brk = 0; + for (int k = 0; k < 100; k++) { + if (k == 5) break; + brk++; + } + if (brk != 5) return 5; + + // Continue. + int cont = 0; + for (int k = 0; k < 10; k++) { + if (k % 2 == 0) continue; + cont++; + } + if (cont != 5) return 6; + + // Nested loops. + int nested = 0; + for (int a = 0; a < 3; a++) { + for (int b = 0; b < 3; b++) { + nested++; + } + } + if (nested != 9) return 7; + + // Ternary (SELECT). + int sel = (1 > 0) ? 42 : -1; + if (sel != 42) return 8; + + // Early return inside nested scopes: exercises EXIT_SCOPE placement. + // If EXIT_SCOPE is emitted after the return terminator, verification fails. + { + int inner = 0; + { + inner = 77; + if (inner == 77) return 0; // early return from nested scope + inner = -1; // dead code + } + inner = -1; // also dead + } + + return 0; +} diff --git a/tests/InterpretIR/test_dynamic_alloca.c b/tests/InterpretIR/test_dynamic_alloca.c new file mode 100644 index 000000000..f82308e56 --- /dev/null +++ b/tests/InterpretIR/test_dynamic_alloca.c @@ -0,0 +1,288 @@ +// Tests: dynamic stack allocation (ALLOCA/DYNAMIC), VLAs, alloca() builtin, +// scope-tracked dynamic objects. + +/* + * Expected IR: + * + * function test_dynamic_alloca (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (n) + * obj_1 LOCAL_VALUE size=0 align=4 (vla) + * obj_2 LOCAL_VALUE size=4 align=4 (i) + * obj_3 LOCAL_VALUE size=4 align=4 (m) + * obj_4 LOCAL_VALUE size=0 align=4 (inner_vla) + * obj_5 LOCAL_VALUE size=4 align=4 (sz) + * obj_6 LOCAL_VALUE size=0 align=4 (bigger_vla) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %n.0 = ALLOCA/LOCAL size=4 align=4 + * >> %i.1 = ALLOCA/LOCAL size=4 align=4 + * >> %m.2 = ALLOCA/LOCAL size=4 align=4 + * >> %sz.3 = ALLOCA/LOCAL size=4 align=4 + * >> %4 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %5 = ENTER_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * %n.0 = ALLOCA/LOCAL size=4 align=4 + * %6 = CONST/INT32 5 // 5 + * >> %n.7 = MEMORY/STORE_LE_32 [%n.0, %6] + * %8 = MEMORY/LOAD_LE_32 [%n.0] // n + * %9 = CONST/UINT64 4 + * %vla.10 = MUL [%8, %9] + * >> %vla.11 = ALLOCA/DYNAMIC size=0 align=4 [%vla.10] + * >> %12 = ENTER_SCOPE // for (int i = 0; i < n; i++) { vla[i] = ... + * >> %13 = IMPLICIT_GOTO + * -> [block_2] + * block_2 LOOP_PREHEADER <- [block_1]: + * %i.1 = ALLOCA/LOCAL size=4 align=4 + * %14 = CONST/INT32 0 // 0 + * >> %i.15 = MEMORY/STORE_LE_32 [%i.1, %14] + * >> %16 = IMPLICIT_GOTO + * -> [block_3] + * block_3 LOOP_CONDITION <- [block_2, block_5]: + * %i.1 = ALLOCA/LOCAL size=4 align=4 + * %17 = MEMORY/LOAD_LE_32 [%i.1] // i + * %n.0 = ALLOCA/LOCAL size=4 align=4 + * %18 = MEMORY/LOAD_LE_32 [%n.0] // n + * %19 = CMP_LT [%17, %18] // i < n + * >> %20 = COND_BRANCH [%19] // for (int i = 0; i < n; i++) { vla[i] = ... + * -> [block_4, block_6] + * block_6 LOOP_EXIT <- [block_3]: + * >> %33 = EXIT_SCOPE // for (int i = 0; i < n; i++) { vla[i] = ... + * %n.0 = ALLOCA/LOCAL size=4 align=4 + * %8 = MEMORY/LOAD_LE_32 [%n.0] // n + * %9 = CONST/UINT64 4 + * %vla.10 = MUL [%8, %9] + * %vla.11 = ALLOCA/DYNAMIC size=0 align=4 [%vla.10] + * %34 = CONST/INT32 0 // 0 + * %35 = PTR_ADD elem_size=4 [%vla.11, %34] // vla[0] + * %36 = MEMORY/LOAD_LE_32 [%35] // vla[0] + * %37 = CONST/INT32 0 // 0 + * %38 = CMP_NE [%36, %37] // vla[0] != 0 + * >> %39 = COND_BRANCH [%38] // if (vla[0] != 0) return 1 + * -> [block_7, block_8] + * block_8 IF_ELSE <- [block_6]: + * >> %45 = IMPLICIT_GOTO + * -> [block_9] + * block_9 IF_MERGE <- [block_8]: + * %n.0 = ALLOCA/LOCAL size=4 align=4 + * %8 = MEMORY/LOAD_LE_32 [%n.0] // n + * %9 = CONST/UINT64 4 + * %vla.10 = MUL [%8, %9] + * %vla.11 = ALLOCA/DYNAMIC size=0 align=4 [%vla.10] + * %46 = CONST/INT32 4 // 4 + * %47 = PTR_ADD elem_size=4 [%vla.11, %46] // vla[4] + * %48 = MEMORY/LOAD_LE_32 [%47] // vla[4] + * %49 = CONST/INT32 40 // 40 + * %50 = CMP_NE [%48, %49] // vla[4] != 40 + * >> %51 = COND_BRANCH [%50] // if (vla[4] != 40) return 2 + * -> [block_10, block_11] + * block_11 IF_ELSE <- [block_9]: + * >> %57 = IMPLICIT_GOTO + * -> [block_12] + * block_12 IF_MERGE <- [block_11]: + * >> %58 = ENTER_SCOPE // { int m = 3; int inner_vla[m]; ... + * %m.2 = ALLOCA/LOCAL size=4 align=4 + * %59 = CONST/INT32 3 // 3 + * >> %m.60 = MEMORY/STORE_LE_32 [%m.2, %59] + * %61 = MEMORY/LOAD_LE_32 [%m.2] // m + * %62 = CONST/UINT64 4 + * %inner_vla.63 = MUL [%61, %62] + * >> %inner_vla.64 = ALLOCA/DYNAMIC size=0 align=4 [%inner_vla.63] + * %inner_vla.64 = ALLOCA/DYNAMIC size=0 align=4 [%inner_vla.63] + * %65 = CONST/INT32 0 // 0 + * %66 = PTR_ADD elem_size=4 [%inner_vla.64, %65] // inner_vla[0] + * %67 = CONST/INT32 100 // 100 + * >> %68 = MEMORY/STORE_LE_32 [%66, %67] // inner_vla[0] = 100 + * %69 = CONST/INT32 2 // 2 + * %70 = PTR_ADD elem_size=4 [%inner_vla.64, %69] // inner_vla[2] + * %71 = CONST/INT32 300 // 300 + * >> %72 = MEMORY/STORE_LE_32 [%70, %71] // inner_vla[2] = 300 + * %73 = CONST/INT32 0 // 0 + * %74 = PTR_ADD elem_size=4 [%inner_vla.64, %73] // inner_vla[0] + * %75 = MEMORY/LOAD_LE_32 [%74] // inner_vla[0] + * %76 = CONST/INT32 100 // 100 + * %77 = CMP_NE [%75, %76] // inner_vla[0] != 100 + * >> %78 = COND_BRANCH [%77] // if (inner_vla[0] != 100) return 3 + * -> [block_13, block_14] + * block_14 IF_ELSE <- [block_12]: + * >> %85 = IMPLICIT_GOTO + * -> [block_15] + * block_15 IF_MERGE <- [block_14]: + * %m.2 = ALLOCA/LOCAL size=4 align=4 + * %61 = MEMORY/LOAD_LE_32 [%m.2] // m + * %62 = CONST/UINT64 4 + * %inner_vla.63 = MUL [%61, %62] + * %inner_vla.64 = ALLOCA/DYNAMIC size=0 align=4 [%inner_vla.63] + * %86 = CONST/INT32 2 // 2 + * %87 = PTR_ADD elem_size=4 [%inner_vla.64, %86] // inner_vla[2] + * %88 = MEMORY/LOAD_LE_32 [%87] // inner_vla[2] + * %89 = CONST/INT32 300 // 300 + * %90 = CMP_NE [%88, %89] // inner_vla[2] != 300 + * >> %91 = COND_BRANCH [%90] // if (inner_vla[2] != 300) return 4 + * -> [block_16, block_17] + * block_17 IF_ELSE <- [block_15]: + * >> %98 = IMPLICIT_GOTO + * -> [block_18] + * block_18 IF_MERGE <- [block_17]: + * >> %99 = EXIT_SCOPE // { int m = 3; int inner_vla[m]; ... + * %sz.3 = ALLOCA/LOCAL size=4 align=4 + * %n.0 = ALLOCA/LOCAL size=4 align=4 + * %100 = MEMORY/LOAD_LE_32 [%n.0] // n + * %101 = CONST/INT32 3 // 3 + * %102 = ADD [%100, %101] // n + 3 + * >> %sz.103 = MEMORY/STORE_LE_32 [%sz.3, %102] + * %104 = MEMORY/LOAD_LE_32 [%sz.3] // sz + * %105 = CONST/UINT64 4 + * %bigger_vla.106 = MUL [%104, %105] + * >> %bigger_vla.107 = ALLOCA/DYNAMIC size=0 align=4 [%bigger_vla.106] + * %bigger_vla.107 = ALLOCA/DYNAMIC size=0 align=4 [%bigger_vla.106] + * %108 = CONST/INT32 0 // 0 + * %109 = PTR_ADD elem_size=4 [%bigger_vla.107, %108] // bigger_vla[0] + * %110 = CONST/INT32 1 // 1 + * >> %111 = MEMORY/STORE_LE_32 [%109, %110] // bigger_vla[0] = 1 + * %112 = MEMORY/LOAD_LE_32 [%sz.3] // sz + * %113 = CONST/INT32 1 // 1 + * %114 = SUB [%112, %113] // sz - 1 + * %115 = PTR_ADD elem_size=4 [%bigger_vla.107, %114] // bigger_vla[sz - 1] + * %116 = CONST/INT32 99 // 99 + * >> %117 = MEMORY/STORE_LE_32 [%115, %116] // bigger_vla[sz - 1] = 99 + * %118 = CONST/INT32 0 // 0 + * %119 = PTR_ADD elem_size=4 [%bigger_vla.107, %118] // bigger_vla[0] + * %120 = MEMORY/LOAD_LE_32 [%119] // bigger_vla[0] + * %121 = CONST/INT32 1 // 1 + * %122 = CMP_NE [%120, %121] // bigger_vla[0] != 1 + * >> %123 = COND_BRANCH [%122] // if (bigger_vla[0] != 1) return 5 + * -> [block_19, block_20] + * block_20 IF_ELSE <- [block_18]: + * >> %129 = IMPLICIT_GOTO + * -> [block_21] + * block_21 IF_MERGE <- [block_20]: + * %sz.3 = ALLOCA/LOCAL size=4 align=4 + * %104 = MEMORY/LOAD_LE_32 [%sz.3] // sz + * %105 = CONST/UINT64 4 + * %bigger_vla.106 = MUL [%104, %105] + * %bigger_vla.107 = ALLOCA/DYNAMIC size=0 align=4 [%bigger_vla.106] + * %130 = CONST/INT32 7 // 7 + * %131 = PTR_ADD elem_size=4 [%bigger_vla.107, %130] // bigger_vla[7] + * %132 = MEMORY/LOAD_LE_32 [%131] // bigger_vla[7] + * %133 = CONST/INT32 99 // 99 + * %134 = CMP_NE [%132, %133] // bigger_vla[7] != 99 + * >> %135 = COND_BRANCH [%134] // if (bigger_vla[7] != 99) return 6 + * -> [block_22, block_23] + * block_23 IF_ELSE <- [block_21]: + * >> %141 = IMPLICIT_GOTO + * -> [block_24] + * block_24 IF_MERGE <- [block_23]: + * %143 = RETURN_PTR // return 0 + * %142 = CONST/INT32 0 // 0 + * >> %144 = MEMORY/STORE_LE_32 [%143, %142] // return 0 + * >> %145 = EXIT_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * >> %146 = RET [%142] // return 0 + * block_22 IF_THEN <- [block_21]: + * %137 = RETURN_PTR // return 6 + * %136 = CONST/INT32 6 // 6 + * >> %138 = MEMORY/STORE_LE_32 [%137, %136] // return 6 + * >> %139 = EXIT_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * >> %140 = RET [%136] // return 6 + * block_19 IF_THEN <- [block_18]: + * %125 = RETURN_PTR // return 5 + * %124 = CONST/INT32 5 // 5 + * >> %126 = MEMORY/STORE_LE_32 [%125, %124] // return 5 + * >> %127 = EXIT_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * >> %128 = RET [%124] // return 5 + * block_16 IF_THEN <- [block_15]: + * %93 = RETURN_PTR // return 4 + * %92 = CONST/INT32 4 // 4 + * >> %94 = MEMORY/STORE_LE_32 [%93, %92] // return 4 + * >> %95 = EXIT_SCOPE // { int m = 3; int inner_vla[m]; ... + * >> %96 = EXIT_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * >> %97 = RET [%92] // return 4 + * block_13 IF_THEN <- [block_12]: + * %80 = RETURN_PTR // return 3 + * %79 = CONST/INT32 3 // 3 + * >> %81 = MEMORY/STORE_LE_32 [%80, %79] // return 3 + * >> %82 = EXIT_SCOPE // { int m = 3; int inner_vla[m]; ... + * >> %83 = EXIT_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * >> %84 = RET [%79] // return 3 + * block_10 IF_THEN <- [block_9]: + * %53 = RETURN_PTR // return 2 + * %52 = CONST/INT32 2 // 2 + * >> %54 = MEMORY/STORE_LE_32 [%53, %52] // return 2 + * >> %55 = EXIT_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * >> %56 = RET [%52] // return 2 + * block_7 IF_THEN <- [block_6]: + * %41 = RETURN_PTR // return 1 + * %40 = CONST/INT32 1 // 1 + * >> %42 = MEMORY/STORE_LE_32 [%41, %40] // return 1 + * >> %43 = EXIT_SCOPE // { int n = 5; // VLA — ALLOCA/DYNAMIC... + * >> %44 = RET [%40] // return 1 + * block_4 LOOP_BODY <- [block_3]: + * >> %21 = ENTER_SCOPE // { vla[i] = i * 10; } + * %n.0 = ALLOCA/LOCAL size=4 align=4 + * %8 = MEMORY/LOAD_LE_32 [%n.0] // n + * %9 = CONST/UINT64 4 + * %vla.10 = MUL [%8, %9] + * %vla.11 = ALLOCA/DYNAMIC size=0 align=4 [%vla.10] + * %i.1 = ALLOCA/LOCAL size=4 align=4 + * %22 = MEMORY/LOAD_LE_32 [%i.1] // i + * %23 = PTR_ADD elem_size=4 [%vla.11, %22] // vla[i] + * %24 = MEMORY/LOAD_LE_32 [%i.1] // i + * %25 = CONST/INT32 10 // 10 + * %26 = MUL [%24, %25] // i * 10 + * >> %27 = MEMORY/STORE_LE_32 [%23, %26] // vla[i] = i * 10 + * >> %28 = EXIT_SCOPE // { vla[i] = i * 10; } + * >> %29 = IMPLICIT_GOTO + * -> [block_5] + * block_5 LOOP_INCREMENT <- [block_4]: + * %i.1 = ALLOCA/LOCAL size=4 align=4 + * %30 = CONST/INT32 1 // i++ + * >> %31 = READ_MODIFY_WRITE(ADD old) [%i.1, %30] // i++ + * >> %32 = IMPLICIT_GOTO + * -> [block_3] + * } + */ + + + + + + + + + + +int test_dynamic_alloca(void) { + int n = 5; + + // VLA — ALLOCA/DYNAMIC with runtime size. + int vla[n]; + for (int i = 0; i < n; i++) { + vla[i] = i * 10; + } + if (vla[0] != 0) return 1; + if (vla[4] != 40) return 2; + + // VLA in a nested scope. + { + int m = 3; + int inner_vla[m]; + inner_vla[0] = 100; + inner_vla[2] = 300; + if (inner_vla[0] != 100) return 3; + if (inner_vla[2] != 300) return 4; + } + // inner_vla is now out of scope. + + // VLA size from computation. + int sz = n + 3; + int bigger_vla[sz]; + bigger_vla[0] = 1; + bigger_vla[sz - 1] = 99; + if (bigger_vla[0] != 1) return 5; + if (bigger_vla[7] != 99) return 6; + + return 0; +} diff --git a/tests/InterpretIR/test_evil_goto.c b/tests/InterpretIR/test_evil_goto.c new file mode 100644 index 000000000..cb69fddf6 --- /dev/null +++ b/tests/InterpretIR/test_evil_goto.c @@ -0,0 +1,547 @@ +// Tests: evil goto patterns, Duff's device, gotos crossing scope boundaries, +// gotos into/out of switch cases, interleaved loops and gotos. + +/* + * Expected IR: + * + * function test_evil_goto (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=11 align=1 (src) + * obj_1 LOCAL_VALUE size=11 align=1 (dst) + * obj_2 LOCAL_VALUE size=4 align=1 (dst2) + * obj_3 PARAMETER size=8 align=8 + * obj_4 PARAMETER size=8 align=8 + * obj_5 PARAMETER size=4 align=4 + * obj_6 PARAMETER size=8 align=8 + * obj_7 PARAMETER size=8 align=8 + * obj_8 PARAMETER size=4 align=4 + * obj_9 RETURN_SLOT size=4 align=4 + * obj_10 RETURN_SLOT size=4 align=4 + * obj_11 RETURN_SLOT size=4 align=4 + * obj_12 RETURN_SLOT size=4 align=4 + * obj_13 PARAMETER size=4 align=4 + * obj_14 RETURN_SLOT size=4 align=4 + * obj_15 PARAMETER size=4 align=4 + * obj_16 RETURN_SLOT size=4 align=4 + * obj_17 PARAMETER size=4 align=4 + * obj_18 RETURN_SLOT size=4 align=4 + * obj_19 PARAMETER size=4 align=4 + * obj_20 RETURN_SLOT size=4 align=4 + * obj_21 PARAMETER size=4 align=4 + * obj_22 RETURN_SLOT size=4 align=4 + * obj_23 PARAMETER size=4 align=4 + * obj_24 RETURN_SLOT size=4 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %src.0 = ALLOCA/LOCAL size=11 align=1 + * >> %dst.1 = ALLOCA/LOCAL size=11 align=1 + * >> %dst2.2 = ALLOCA/LOCAL size=4 align=1 + * >> %3 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %4 = ENTER_SCOPE // { // Duff's device. { char src[... + * >> %5 = ENTER_SCOPE // { char src[11] = "0123456789"; ... + * %src.0 = ALLOCA/LOCAL size=11 align=1 + * %6 = STRING_PTR // "0123456789" + * %7 = CONST/UINT64 11 + * >> %src.8 = MEMORY/MEMCPY [%src.0, %6, %7] + * %dst.1 = ALLOCA/LOCAL size=11 align=1 + * %dst.9 = CONST/UINT8 0 + * %dst.10 = CONST/UINT64 11 + * >> %dst.11 = MEMORY/MEMSET [%dst.1, %dst.9, %dst.10] + * %12 = CONST/INT32 0 // 0 + * %13 = CAST/TRUNC_I32_I8 [%12] // 0 + * >> %dst.14 = MEMORY/STORE_LE_8 [%dst.1, %13] + * >> %15 = ENTER_SCOPE // duffs_copy(dst, src, 10) + * %16 = ALLOCA/ARG size=8 align=8 // dst + * >> %17 = MEMORY/STORE_LE_64 [%16, %dst.1] // dst + * %18 = ALLOCA/ARG size=8 align=8 // src + * >> %19 = MEMORY/STORE_LE_64 [%18, %src.0] // src + * %21 = ALLOCA/ARG size=4 align=4 // 10 + * %20 = CONST/INT32 10 // 10 + * >> %22 = MEMORY/STORE_LE_32 [%21, %20] // 10 + * >> %23 = CALL @duffs_copy [%16, %18, %21] // duffs_copy(dst, src, 10) + * >> %24 = EXIT_SCOPE + * %25 = CONST/INT32 0 // 0 + * %26 = PTR_ADD elem_size=1 [%dst.1, %25] // dst[0] + * %27 = MEMORY/LOAD_LE_8 [%26] // dst[0] + * %28 = CAST/SEXT_I8_I32 [%27] // dst[0] + * %29 = CONST/UINT8 48 // '0' + * %30 = CMP_NE [%28, %29] // dst[0] != '0' + * >> %31 = COND_BRANCH [%30] // if (dst[0] != '0') return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %38 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %dst.1 = ALLOCA/LOCAL size=11 align=1 + * %39 = CONST/INT32 9 // 9 + * %40 = PTR_ADD elem_size=1 [%dst.1, %39] // dst[9] + * %41 = MEMORY/LOAD_LE_8 [%40] // dst[9] + * %42 = CAST/SEXT_I8_I32 [%41] // dst[9] + * %43 = CONST/UINT8 57 // '9' + * %44 = CMP_NE [%42, %43] // dst[9] != '9' + * >> %45 = COND_BRANCH [%44] // if (dst[9] != '9') return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %52 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %dst.1 = ALLOCA/LOCAL size=11 align=1 + * %53 = CONST/INT32 10 // 10 + * %54 = PTR_ADD elem_size=1 [%dst.1, %53] // dst[10] + * %55 = MEMORY/LOAD_LE_8 [%54] // dst[10] + * %56 = CAST/SEXT_I8_I32 [%55] // dst[10] + * %57 = CONST/UINT8 0 // '\0' + * %58 = CMP_NE [%56, %57] // dst[10] != '\0' + * >> %59 = COND_BRANCH [%58] // if (dst[10] != '\0') return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %66 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %dst2.2 = ALLOCA/LOCAL size=4 align=1 + * %dst2.67 = CONST/UINT8 0 + * %dst2.68 = CONST/UINT64 4 + * >> %dst2.69 = MEMORY/MEMSET [%dst2.2, %dst2.67, %dst2.68] + * %70 = CONST/INT32 0 // 0 + * %71 = CAST/TRUNC_I32_I8 [%70] // 0 + * >> %dst2.72 = MEMORY/STORE_LE_8 [%dst2.2, %71] + * >> %73 = ENTER_SCOPE // duffs_copy(dst2, src, 3) + * %74 = ALLOCA/ARG size=8 align=8 // dst2 + * >> %75 = MEMORY/STORE_LE_64 [%74, %dst2.2] // dst2 + * %76 = ALLOCA/ARG size=8 align=8 // src + * %src.0 = ALLOCA/LOCAL size=11 align=1 + * >> %77 = MEMORY/STORE_LE_64 [%76, %src.0] // src + * %79 = ALLOCA/ARG size=4 align=4 // 3 + * %78 = CONST/INT32 3 // 3 + * >> %80 = MEMORY/STORE_LE_32 [%79, %78] // 3 + * >> %81 = CALL @duffs_copy [%74, %76, %79] // duffs_copy(dst2, src, 3) + * >> %82 = EXIT_SCOPE + * %83 = CONST/INT32 0 // 0 + * %84 = PTR_ADD elem_size=1 [%dst2.2, %83] // dst2[0] + * %85 = MEMORY/LOAD_LE_8 [%84] // dst2[0] + * %86 = CAST/SEXT_I8_I32 [%85] // dst2[0] + * %87 = CONST/UINT8 48 // '0' + * %88 = CMP_NE [%86, %87] // dst2[0] != '0' + * >> %89 = COND_BRANCH [%88] // if (dst2[0] != '0') return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %96 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %dst2.2 = ALLOCA/LOCAL size=4 align=1 + * %97 = CONST/INT32 2 // 2 + * %98 = PTR_ADD elem_size=1 [%dst2.2, %97] // dst2[2] + * %99 = MEMORY/LOAD_LE_8 [%98] // dst2[2] + * %100 = CAST/SEXT_I8_I32 [%99] // dst2[2] + * %101 = CONST/UINT8 50 // '2' + * %102 = CMP_NE [%100, %101] // dst2[2] != '2' + * >> %103 = COND_BRANCH [%102] // if (dst2[2] != '2') return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %110 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * >> %111 = EXIT_SCOPE // { char src[11] = "0123456789"; ... + * >> %112 = ENTER_SCOPE // goto_into_scope() + * >> %117 = EXIT_SCOPE + * %114 = CALL @goto_into_scope // goto_into_scope() + * %115 = CONST/INT32 42 // 42 + * %116 = CMP_NE [%114, %115] // goto_into_scope() != 42 + * >> %118 = COND_BRANCH [%116] // if (goto_into_scope() != 42) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %124 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * >> %125 = ENTER_SCOPE // goto_escape_nested() + * >> %130 = EXIT_SCOPE + * %127 = CALL @goto_escape_nested // goto_escape_nested() + * %128 = CONST/INT32 6 // 6 + * %129 = CMP_NE [%127, %128] // goto_escape_nested() != 6 + * >> %131 = COND_BRANCH [%129] // if (goto_escape_nested() != 6) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %137 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * >> %138 = ENTER_SCOPE // goto_skip_decls() + * >> %143 = EXIT_SCOPE + * %140 = CALL @goto_skip_decls // goto_skip_decls() + * %141 = CONST/INT32 0 // 0 + * %142 = CMP_NE [%140, %141] // goto_skip_decls() != 0 + * >> %144 = COND_BRANCH [%142] // if (goto_skip_decls() != 0) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %150 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * >> %151 = ENTER_SCOPE // goto_loop_with_scope() + * >> %156 = EXIT_SCOPE + * %153 = CALL @goto_loop_with_scope // goto_loop_with_scope() + * %154 = CONST/INT32 15 // 15 + * %155 = CMP_NE [%153, %154] // goto_loop_with_scope() != 15 + * >> %157 = COND_BRANCH [%155] // if (goto_loop_with_scope() != 15) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %163 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * >> %164 = ENTER_SCOPE // goto_between_cases(1) + * %166 = ALLOCA/ARG size=4 align=4 // 1 + * %165 = CONST/INT32 1 // 1 + * >> %167 = MEMORY/STORE_LE_32 [%166, %165] // 1 + * >> %172 = EXIT_SCOPE + * %169 = CALL @goto_between_cases [%166] // goto_between_cases(1) + * %170 = CONST/INT32 110 // 110 + * %171 = CMP_NE [%169, %170] // goto_between_cases(1) != 110 + * >> %173 = COND_BRANCH [%171] // if (goto_between_cases(1) != 110) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %179 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * >> %180 = ENTER_SCOPE // goto_between_cases(2) + * %182 = ALLOCA/ARG size=4 align=4 // 2 + * %181 = CONST/INT32 2 // 2 + * >> %183 = MEMORY/STORE_LE_32 [%182, %181] // 2 + * >> %188 = EXIT_SCOPE + * %185 = CALL @goto_between_cases [%182] // goto_between_cases(2) + * %186 = CONST/INT32 20 // 20 + * %187 = CMP_NE [%185, %186] // goto_between_cases(2) != 20 + * >> %189 = COND_BRANCH [%187] // if (goto_between_cases(2) != 20) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %195 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * >> %196 = ENTER_SCOPE // goto_between_cases(3) + * %198 = ALLOCA/ARG size=4 align=4 // 3 + * %197 = CONST/INT32 3 // 3 + * >> %199 = MEMORY/STORE_LE_32 [%198, %197] // 3 + * >> %204 = EXIT_SCOPE + * %201 = CALL @goto_between_cases [%198] // goto_between_cases(3) + * %202 = CONST/INT32 100 // 100 + * %203 = CMP_NE [%201, %202] // goto_between_cases(3) != 100 + * >> %205 = COND_BRANCH [%203] // if (goto_between_cases(3) != 100) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %211 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * >> %212 = ENTER_SCOPE // multi_source_goto(1) + * %214 = ALLOCA/ARG size=4 align=4 // 1 + * %213 = CONST/INT32 1 // 1 + * >> %215 = MEMORY/STORE_LE_32 [%214, %213] // 1 + * >> %220 = EXIT_SCOPE + * %217 = CALL @multi_source_goto [%214] // multi_source_goto(1) + * %218 = CONST/INT32 10 // 10 + * %219 = CMP_NE [%217, %218] // multi_source_goto(1) != 10 + * >> %221 = COND_BRANCH [%219] // if (multi_source_goto(1) != 10) return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %227 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * >> %228 = ENTER_SCOPE // multi_source_goto(2) + * %230 = ALLOCA/ARG size=4 align=4 // 2 + * %229 = CONST/INT32 2 // 2 + * >> %231 = MEMORY/STORE_LE_32 [%230, %229] // 2 + * >> %236 = EXIT_SCOPE + * %233 = CALL @multi_source_goto [%230] // multi_source_goto(2) + * %234 = CONST/INT32 20 // 20 + * %235 = CMP_NE [%233, %234] // multi_source_goto(2) != 20 + * >> %237 = COND_BRANCH [%235] // if (multi_source_goto(2) != 20) return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %243 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * >> %244 = ENTER_SCOPE // multi_source_goto(0) + * %246 = ALLOCA/ARG size=4 align=4 // 0 + * %245 = CONST/INT32 0 // 0 + * >> %247 = MEMORY/STORE_LE_32 [%246, %245] // 0 + * >> %252 = EXIT_SCOPE + * %249 = CALL @multi_source_goto [%246] // multi_source_goto(0) + * %250 = CONST/INT32 30 // 30 + * %251 = CMP_NE [%249, %250] // multi_source_goto(0) != 30 + * >> %253 = COND_BRANCH [%251] // if (multi_source_goto(0) != 30) return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %259 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %261 = RETURN_PTR // return 0 + * %260 = CONST/INT32 0 // 0 + * >> %262 = MEMORY/STORE_LE_32 [%261, %260] // return 0 + * >> %263 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %264 = RET [%260] // return 0 + * block_44 IF_THEN <- [block_43]: + * %255 = RETURN_PTR // return 15 + * %254 = CONST/INT32 15 // 15 + * >> %256 = MEMORY/STORE_LE_32 [%255, %254] // return 15 + * >> %257 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %258 = RET [%254] // return 15 + * block_41 IF_THEN <- [block_40]: + * %239 = RETURN_PTR // return 14 + * %238 = CONST/INT32 14 // 14 + * >> %240 = MEMORY/STORE_LE_32 [%239, %238] // return 14 + * >> %241 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %242 = RET [%238] // return 14 + * block_38 IF_THEN <- [block_37]: + * %223 = RETURN_PTR // return 13 + * %222 = CONST/INT32 13 // 13 + * >> %224 = MEMORY/STORE_LE_32 [%223, %222] // return 13 + * >> %225 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %226 = RET [%222] // return 13 + * block_35 IF_THEN <- [block_34]: + * %207 = RETURN_PTR // return 12 + * %206 = CONST/INT32 12 // 12 + * >> %208 = MEMORY/STORE_LE_32 [%207, %206] // return 12 + * >> %209 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %210 = RET [%206] // return 12 + * block_32 IF_THEN <- [block_31]: + * %191 = RETURN_PTR // return 11 + * %190 = CONST/INT32 11 // 11 + * >> %192 = MEMORY/STORE_LE_32 [%191, %190] // return 11 + * >> %193 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %194 = RET [%190] // return 11 + * block_29 IF_THEN <- [block_28]: + * %175 = RETURN_PTR // return 10 + * %174 = CONST/INT32 10 // 10 + * >> %176 = MEMORY/STORE_LE_32 [%175, %174] // return 10 + * >> %177 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %178 = RET [%174] // return 10 + * block_26 IF_THEN <- [block_25]: + * %159 = RETURN_PTR // return 9 + * %158 = CONST/INT32 9 // 9 + * >> %160 = MEMORY/STORE_LE_32 [%159, %158] // return 9 + * >> %161 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %162 = RET [%158] // return 9 + * block_23 IF_THEN <- [block_22]: + * %146 = RETURN_PTR // return 8 + * %145 = CONST/INT32 8 // 8 + * >> %147 = MEMORY/STORE_LE_32 [%146, %145] // return 8 + * >> %148 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %149 = RET [%145] // return 8 + * block_20 IF_THEN <- [block_19]: + * %133 = RETURN_PTR // return 7 + * %132 = CONST/INT32 7 // 7 + * >> %134 = MEMORY/STORE_LE_32 [%133, %132] // return 7 + * >> %135 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %136 = RET [%132] // return 7 + * block_17 IF_THEN <- [block_16]: + * %120 = RETURN_PTR // return 6 + * %119 = CONST/INT32 6 // 6 + * >> %121 = MEMORY/STORE_LE_32 [%120, %119] // return 6 + * >> %122 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %123 = RET [%119] // return 6 + * block_14 IF_THEN <- [block_13]: + * %105 = RETURN_PTR // return 5 + * %104 = CONST/INT32 5 // 5 + * >> %106 = MEMORY/STORE_LE_32 [%105, %104] // return 5 + * >> %107 = EXIT_SCOPE // { char src[11] = "0123456789"; ... + * >> %108 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %109 = RET [%104] // return 5 + * block_11 IF_THEN <- [block_10]: + * %91 = RETURN_PTR // return 4 + * %90 = CONST/INT32 4 // 4 + * >> %92 = MEMORY/STORE_LE_32 [%91, %90] // return 4 + * >> %93 = EXIT_SCOPE // { char src[11] = "0123456789"; ... + * >> %94 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %95 = RET [%90] // return 4 + * block_8 IF_THEN <- [block_7]: + * %61 = RETURN_PTR // return 3 + * %60 = CONST/INT32 3 // 3 + * >> %62 = MEMORY/STORE_LE_32 [%61, %60] // return 3 + * >> %63 = EXIT_SCOPE // { char src[11] = "0123456789"; ... + * >> %64 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %65 = RET [%60] // return 3 + * block_5 IF_THEN <- [block_4]: + * %47 = RETURN_PTR // return 2 + * %46 = CONST/INT32 2 // 2 + * >> %48 = MEMORY/STORE_LE_32 [%47, %46] // return 2 + * >> %49 = EXIT_SCOPE // { char src[11] = "0123456789"; ... + * >> %50 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %51 = RET [%46] // return 2 + * block_2 IF_THEN <- [block_1]: + * %33 = RETURN_PTR // return 1 + * %32 = CONST/INT32 1 // 1 + * >> %34 = MEMORY/STORE_LE_32 [%33, %32] // return 1 + * >> %35 = EXIT_SCOPE // { char src[11] = "0123456789"; ... + * >> %36 = EXIT_SCOPE // { // Duff's device. { char src[... + * >> %37 = RET [%32] // return 1 + * } + */ + + + + + + + + + + +// Classic Duff's device: copy n bytes from src to dst. +static void duffs_copy(char *dst, const char *src, int n) { + int remaining = n; + if (remaining <= 0) return; + int chunks = (remaining + 7) / 8; + switch (remaining % 8) { + case 0: do { *dst++ = *src++; + case 7: *dst++ = *src++; + case 6: *dst++ = *src++; + case 5: *dst++ = *src++; + case 4: *dst++ = *src++; + case 3: *dst++ = *src++; + case 2: *dst++ = *src++; + case 1: *dst++ = *src++; + } while (--chunks > 0); + } +} + +// Goto into a nested scope — variable declared in scope, goto skips init. +static int goto_into_scope(void) { + int result = 0; + goto inside; + { + int x = 99; // skipped by goto +inside: + // x is uninitialized here (skipped), but result is valid. + result = 42; + } + return result; +} + +// Goto out of deeply nested scopes. +static int goto_escape_nested(void) { + int val = 0; + { + int a = 1; + { + int b = 2; + { + int c = 3; + val = a + b + c; // 6 + goto escape; + val = 999; // unreachable + } + val = 888; // unreachable + } + val = 777; // unreachable + } +escape: + return val; +} + +// Forward goto skipping variable declarations. +static int goto_skip_decls(void) { + int r = 0; + goto skip; + int x = 10; // skipped + r = x; // skipped +skip: + // x exists but was never initialized. r should still be 0. + return r; +} + +// Goto used as a loop with scope entry/exit each iteration. +static int goto_loop_with_scope(void) { + int total = 0; + int i = 0; +loop_top: + if (i >= 5) goto loop_done; + { + int increment = i + 1; + total += increment; + i++; + } + goto loop_top; +loop_done: + // total = 1 + 2 + 3 + 4 + 5 = 15 + return total; +} + +// Goto between switch cases (not fallthrough — explicit goto). +static int goto_between_cases(int selector) { + int result = 0; + switch (selector) { + case 1: + result = 10; + goto case3_body; + case 2: + result = 20; + break; + case 3: +case3_body: + result += 100; + break; + } + return result; +} + +// Multiple gotos to the same label from different scopes. +static int multi_source_goto(int path) { + int result = 0; + if (path == 1) { + int x = 10; + result = x; + goto merge; + } + if (path == 2) { + int y = 20; + result = y; + goto merge; + } + result = 30; +merge: + return result; +} + +int test_evil_goto(void) { + // Duff's device. + { + char src[11] = "0123456789"; + char dst[11] = {0}; + duffs_copy(dst, src, 10); + if (dst[0] != '0') return 1; + if (dst[9] != '9') return 2; + if (dst[10] != '\0') return 3; + + // Duff with non-multiple-of-8 count. + char dst2[4] = {0}; + duffs_copy(dst2, src, 3); + if (dst2[0] != '0') return 4; + if (dst2[2] != '2') return 5; + } + + // Goto into scope. + if (goto_into_scope() != 42) return 6; + + // Goto escaping nested scopes. + if (goto_escape_nested() != 6) return 7; + + // Goto skipping declarations. + if (goto_skip_decls() != 0) return 8; + + // Goto loop with scope entry/exit. + if (goto_loop_with_scope() != 15) return 9; + + // Goto between switch cases: case 1 → goto case3_body → result = 10 + 100 = 110. + if (goto_between_cases(1) != 110) return 10; + // Case 2 → result = 20. + if (goto_between_cases(2) != 20) return 11; + // Case 3 → result = 0 + 100 = 100. + if (goto_between_cases(3) != 100) return 12; + + // Multi-source goto. + if (multi_source_goto(1) != 10) return 13; + if (multi_source_goto(2) != 20) return 14; + if (multi_source_goto(0) != 30) return 15; + + return 0; +} diff --git a/tests/InterpretIR/test_float_compound.c b/tests/InterpretIR/test_float_compound.c new file mode 100644 index 000000000..0b40863d2 --- /dev/null +++ b/tests/InterpretIR/test_float_compound.c @@ -0,0 +1,54 @@ +// Tests: float compound assignment (+=, -=, *=, /=, %=) and +// float pre/post increment/decrement (++f, f++, --f, f--). +// These must use FADD/FSUB/FMUL/FDIV/FREM as the RMW underlying op, +// not integer ADD/SUB/MUL/DIV/REM. + +int test_float_compound(void) { + // Float compound assignment. + float f = 10.0f; + f += 5.0f; + if (f < 14.9f || f > 15.1f) return 1; + + f -= 3.0f; + if (f < 11.9f || f > 12.1f) return 2; + + f *= 2.0f; + if (f < 23.9f || f > 24.1f) return 3; + + f /= 4.0f; + if (f < 5.9f || f > 6.1f) return 4; + + // Float pre-increment. + float g = 1.0f; + float pre = ++g; + if (pre < 1.9f || pre > 2.1f) return 5; + if (g < 1.9f || g > 2.1f) return 6; + + // Float post-increment. + float h = 3.0f; + float post = h++; + if (post < 2.9f || post > 3.1f) return 7; + if (h < 3.9f || h > 4.1f) return 8; + + // Float pre-decrement. + float i = 5.0f; + float pred = --i; + if (pred < 3.9f || pred > 4.1f) return 9; + if (i < 3.9f || i > 4.1f) return 10; + + // Float post-decrement. + float j = 7.0f; + float postd = j--; + if (postd < 6.9f || postd > 7.1f) return 11; + if (j < 5.9f || j > 6.1f) return 12; + + // Double compound assignment. + double d = 100.0; + d += 50.0; + if (d < 149.9 || d > 150.1) return 13; + + d *= 0.5; + if (d < 74.9 || d > 75.1) return 14; + + return 0; +} diff --git a/tests/InterpretIR/test_float_ops.c b/tests/InterpretIR/test_float_ops.c new file mode 100644 index 000000000..f52be86c9 --- /dev/null +++ b/tests/InterpretIR/test_float_ops.c @@ -0,0 +1,89 @@ +// Tests: standalone float arithmetic (FADD/FSUB/FMUL/FDIV/FREM/FNEG), +// float comparisons (all 6 FCMP kinds), and basic float↔int casts. +// Both float (32-bit) and double (64-bit) variants. + +int test_float_ops(void) { + // --- Float 32-bit arithmetic --- + { + float a = 10.5f, b = 3.25f; + float sum = a + b; + if (sum < 13.74f || sum > 13.76f) return 1; + + float diff = a - b; + if (diff < 7.24f || diff > 7.26f) return 2; + + float prod = a * b; + if (prod < 34.124f || prod > 34.126f) return 3; + + float quot = a / b; + if (quot < 3.22f || quot > 3.24f) return 4; + + float neg = -a; + if (neg > -10.4f || neg < -10.6f) return 5; + } + + // --- Double 64-bit arithmetic --- + { + double a = 1e15, b = 1.0; + double sum = a + b; + // Double can represent this exactly; float can't. + if (sum != 1000000000000001.0) return 10; + + double prod = 1e100 * 1e100; + if (prod != 1e200) return 11; + + double neg = -a; + if (neg != -1e15) return 12; + } + + // --- fmod (FREM) --- + { + float fm = 10.5f; + // Can't use fmod directly in test (no math.h link), but + // the C '%' doesn't work on floats. Use compound: the compiler + // may emit FREM for some patterns. Test via compound assign instead. + } + + // --- Float/double conversions --- + { + float f = 3.14f; + double d = f; // float → double (F32_TO_F64) + // d should be close to 3.14 but not exactly (float rounding). + if (d < 3.139 || d > 3.141) return 20; + + double pi = 3.14159265358979; + float fp = (float)pi; // double → float (F64_TO_F32) + if (fp < 3.141f || fp > 3.142f) return 21; + } + + // --- Int to float --- + { + int i = 42; + float f = (float)i; + if (f < 41.9f || f > 42.1f) return 30; + + double d = (double)i; + if (d != 42.0) return 31; + + unsigned int u = 3000000000u; + double du = (double)u; + if (du < 2999999999.0 || du > 3000000001.0) return 32; + } + + // --- Float to int --- + { + float f = 3.7f; + int i = (int)f; // truncates toward zero + if (i != 3) return 40; + + float fn = -3.7f; + int in = (int)fn; + if (in != -3) return 41; + + double d = 1e10; + long long ll = (long long)d; + if (ll != 10000000000LL) return 42; + } + + return 0; +} diff --git a/tests/InterpretIR/test_float_precision.c b/tests/InterpretIR/test_float_precision.c new file mode 100644 index 000000000..4cc8515f8 --- /dev/null +++ b/tests/InterpretIR/test_float_precision.c @@ -0,0 +1,46 @@ +// Tests: float vs double precision. These tests ONLY pass when the +// interpreter uses float (32-bit) precision for _32 ops and double +// (64-bit) precision for _64 ops. + +int test_float_precision(void) { + // 16777217 = 2^24 + 1. This is exactly representable in double but + // NOT in float (float has 24 bits of mantissa, so 2^24+1 rounds to 2^24). + float f = 16777216.0f; // 2^24, exact in float + f += 1.0f; + // In float precision: 16777216.0f + 1.0f = 16777216.0f (rounds down!) + // In double precision: 16777216.0 + 1.0 = 16777217.0 (exact) + // If the interpreter incorrectly uses double for float ops, f would be 16777217. + if (f != 16777216.0f) return 1; // must equal 2^24, not 2^24+1 + + // Same test with multiplication: 1.0000001f * 1.0000001f. + // float: limited precision causes different rounding than double. + float a = 1.0000001f; + float b = a * a; + // Verify it matches C float semantics, not double. + float expected = 1.0000001f * 1.0000001f; // computed at float precision + if (b != expected) return 2; + + // Double precision should be exact for larger values. + double d = 16777216.0; + d += 1.0; + if (d != 16777217.0) return 3; // double CAN represent 2^24+1 + + // Float comparison precision: two values that are equal as float + // but different as double. + float x = 1.0f / 3.0f; // float: 0.33333334... + float y = 0.333333343267f; // close to 1/3 in float + // These should compare as float, not double. + if (x != y) return 4; + + // Float compound assign precision. + float g = 16777216.0f; + g += 1.0f; // RMW(FADD_32): must use float precision + if (g != 16777216.0f) return 5; // stays 2^24 in float + + // Float pre-increment precision. + float h = 16777216.0f; + ++h; // RMW(FADD_32, delta=1.0f): must use float precision + if (h != 16777216.0f) return 6; + + return 0; +} diff --git a/tests/InterpretIR/test_function_calls.c b/tests/InterpretIR/test_function_calls.c new file mode 100644 index 000000000..7a7227a02 --- /dev/null +++ b/tests/InterpretIR/test_function_calls.c @@ -0,0 +1,226 @@ +// Tests: function calls (CALL), parameter passing (PARAM_READ + STORE), +// return values, recursive calls, indirect calls via function pointers +// (FUNC_PTR), and variadic functions (VA_PACK, VA_START, VA_ARG, VA_END). + +/* + * Expected IR: + * + * function test_function_calls (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=8 align=8 (fp) + * obj_1 PARAMETER size=4 align=4 + * obj_2 PARAMETER size=4 align=4 + * obj_3 RETURN_SLOT size=4 align=4 + * obj_4 PARAMETER size=4 align=4 + * obj_5 RETURN_SLOT size=4 align=4 + * obj_6 PARAMETER size=4 align=4 + * obj_7 PARAMETER size=4 align=4 + * obj_8 RETURN_SLOT size=4 align=4 + * obj_9 PARAMETER size=8 align=8 + * obj_10 PARAMETER size=4 align=4 + * obj_11 PARAMETER size=4 align=4 + * obj_12 RETURN_SLOT size=4 align=4 + * obj_13 PARAMETER size=4 align=4 + * obj_14 PARAMETER size=4 align=4 + * obj_15 PARAMETER size=4 align=4 + * obj_16 PARAMETER size=4 align=4 + * obj_17 RETURN_SLOT size=4 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %fp.0 = ALLOCA/LOCAL size=8 align=8 + * >> %1 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %2 = ENTER_SCOPE // { // Direct call. if (add(3, 4) != 7) r... + * >> %3 = ENTER_SCOPE // add(3, 4) + * %5 = ALLOCA/ARG size=4 align=4 // 3 + * %4 = CONST/INT32 3 // 3 + * >> %6 = MEMORY/STORE_LE_32 [%5, %4] // 3 + * %8 = ALLOCA/ARG size=4 align=4 // 4 + * %7 = CONST/INT32 4 // 4 + * >> %9 = MEMORY/STORE_LE_32 [%8, %7] // 4 + * >> %14 = EXIT_SCOPE + * %11 = CALL @add [%5, %8] // add(3, 4) + * %12 = CONST/INT32 7 // 7 + * %13 = CMP_NE [%11, %12] // add(3, 4) != 7 + * >> %15 = COND_BRANCH [%13] // if (add(3, 4) != 7) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %21 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * >> %22 = ENTER_SCOPE // factorial(5) + * %24 = ALLOCA/ARG size=4 align=4 // 5 + * %23 = CONST/INT32 5 // 5 + * >> %25 = MEMORY/STORE_LE_32 [%24, %23] // 5 + * >> %30 = EXIT_SCOPE + * %27 = CALL @factorial [%24] // factorial(5) + * %28 = CONST/INT32 120 // 120 + * %29 = CMP_NE [%27, %28] // factorial(5) != 120 + * >> %31 = COND_BRANCH [%29] // if (factorial(5) != 120) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %37 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %fp.0 = ALLOCA/LOCAL size=8 align=8 + * %38 = FUNC_PTR // add + * >> %fp.39 = MEMORY/STORE_LE_64 [%fp.0, %38] + * >> %40 = ENTER_SCOPE // fp(10, 20) + * %43 = ALLOCA/ARG size=4 align=4 // 10 + * %42 = CONST/INT32 10 // 10 + * >> %44 = MEMORY/STORE_LE_32 [%43, %42] // 10 + * %46 = ALLOCA/ARG size=4 align=4 // 20 + * %45 = CONST/INT32 20 // 20 + * >> %47 = MEMORY/STORE_LE_32 [%46, %45] // 20 + * >> %52 = EXIT_SCOPE + * %41 = MEMORY/LOAD_LE_64 [%fp.0] // fp + * %49 = CALL indirect [%41, %43, %46] // fp(10, 20) + * %50 = CONST/INT32 30 // 30 + * %51 = CMP_NE [%49, %50] // fp(10, 20) != 30 + * >> %53 = COND_BRANCH [%51] // if (fp(10, 20) != 30) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %59 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * >> %60 = ENTER_SCOPE // apply(add, 5, 6) + * %62 = ALLOCA/ARG size=8 align=8 // add + * %61 = FUNC_PTR // add + * >> %63 = MEMORY/STORE_LE_64 [%62, %61] // add + * %65 = ALLOCA/ARG size=4 align=4 // 5 + * %64 = CONST/INT32 5 // 5 + * >> %66 = MEMORY/STORE_LE_32 [%65, %64] // 5 + * %68 = ALLOCA/ARG size=4 align=4 // 6 + * %67 = CONST/INT32 6 // 6 + * >> %69 = MEMORY/STORE_LE_32 [%68, %67] // 6 + * >> %74 = EXIT_SCOPE + * %71 = CALL @apply [%62, %65, %68] // apply(add, 5, 6) + * %72 = CONST/INT32 11 // 11 + * %73 = CMP_NE [%71, %72] // apply(add, 5, 6) != 11 + * >> %75 = COND_BRANCH [%73] // if (apply(add, 5, 6) != 11) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %81 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * >> %82 = ENTER_SCOPE // va_sum(3, 10, 20, 30) + * %84 = ALLOCA/ARG size=4 align=4 // 3 + * %83 = CONST/INT32 3 // 3 + * >> %85 = MEMORY/STORE_LE_32 [%84, %83] // 3 + * %87 = ALLOCA/ARG size=4 align=4 // 10 + * %86 = CONST/INT32 10 // 10 + * >> %88 = MEMORY/STORE_LE_32 [%87, %86] // 10 + * %90 = ALLOCA/ARG size=4 align=4 // 20 + * %89 = CONST/INT32 20 // 20 + * >> %91 = MEMORY/STORE_LE_32 [%90, %89] // 20 + * %93 = ALLOCA/ARG size=4 align=4 // 30 + * %92 = CONST/INT32 30 // 30 + * >> %94 = MEMORY/STORE_LE_32 [%93, %92] // 30 + * >> %99 = EXIT_SCOPE + * %96 = CALL @va_sum [%84, %87, %90, %93] // va_sum(3, 10, 20, 30) + * %97 = CONST/INT32 60 // 60 + * %98 = CMP_NE [%96, %97] // va_sum(3, 10, 20, 30) != 60 + * >> %100 = COND_BRANCH [%98] // if (va_sum(3, 10, 20, 30) != 60) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %106 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %108 = RETURN_PTR // return 0 + * %107 = CONST/INT32 0 // 0 + * >> %109 = MEMORY/STORE_LE_32 [%108, %107] // return 0 + * >> %110 = EXIT_SCOPE // { // Direct call. if (add(3, 4) != 7) r... + * >> %111 = RET [%107] // return 0 + * block_14 IF_THEN <- [block_13]: + * %102 = RETURN_PTR // return 5 + * %101 = CONST/INT32 5 // 5 + * >> %103 = MEMORY/STORE_LE_32 [%102, %101] // return 5 + * >> %104 = EXIT_SCOPE // { // Direct call. if (add(3, 4) != 7) r... + * >> %105 = RET [%101] // return 5 + * block_11 IF_THEN <- [block_10]: + * %77 = RETURN_PTR // return 4 + * %76 = CONST/INT32 4 // 4 + * >> %78 = MEMORY/STORE_LE_32 [%77, %76] // return 4 + * >> %79 = EXIT_SCOPE // { // Direct call. if (add(3, 4) != 7) r... + * >> %80 = RET [%76] // return 4 + * block_8 IF_THEN <- [block_7]: + * %55 = RETURN_PTR // return 3 + * %54 = CONST/INT32 3 // 3 + * >> %56 = MEMORY/STORE_LE_32 [%55, %54] // return 3 + * >> %57 = EXIT_SCOPE // { // Direct call. if (add(3, 4) != 7) r... + * >> %58 = RET [%54] // return 3 + * block_5 IF_THEN <- [block_4]: + * %33 = RETURN_PTR // return 2 + * %32 = CONST/INT32 2 // 2 + * >> %34 = MEMORY/STORE_LE_32 [%33, %32] // return 2 + * >> %35 = EXIT_SCOPE // { // Direct call. if (add(3, 4) != 7) r... + * >> %36 = RET [%32] // return 2 + * block_2 IF_THEN <- [block_1]: + * %17 = RETURN_PTR // return 1 + * %16 = CONST/INT32 1 // 1 + * >> %18 = MEMORY/STORE_LE_32 [%17, %16] // return 1 + * >> %19 = EXIT_SCOPE // { // Direct call. if (add(3, 4) != 7) r... + * >> %20 = RET [%16] // return 1 + * } + */ + + + + + + + + + + +typedef __builtin_va_list va_list; +#define va_start(ap, param) __builtin_va_start(ap, param) +#define va_arg(ap, type) __builtin_va_arg(ap, type) +#define va_end(ap) __builtin_va_end(ap) + +static int add(int a, int b) { + return a + b; +} + +static int factorial(int n) { + if (n <= 1) return 1; + return n * factorial(n - 1); +} + +static int apply(int (*fn)(int, int), int x, int y) { + return fn(x, y); +} + +static int va_sum(int count, ...) { + va_list ap; + va_start(ap, count); + int sum = 0; + for (int i = 0; i < count; i++) { + sum += va_arg(ap, int); + } + va_end(ap); + return sum; +} + +int test_function_calls(void) { + // Direct call. + if (add(3, 4) != 7) return 1; + + // Recursive call. + if (factorial(5) != 120) return 2; + + // Function pointer (indirect call). + int (*fp)(int, int) = add; + if (fp(10, 20) != 30) return 3; + + // Higher-order function. + if (apply(add, 5, 6) != 11) return 4; + + // Variadic call. + if (va_sum(3, 10, 20, 30) != 60) return 5; + + return 0; +} diff --git a/tests/InterpretIR/test_globals.c b/tests/InterpretIR/test_globals.c new file mode 100644 index 000000000..1e1ff4ca1 --- /dev/null +++ b/tests/InterpretIR/test_globals.c @@ -0,0 +1,245 @@ +// Tests: global variable initialization (GLOBAL_INITIALIZER functions), +// global pointer access (GLOBAL_PTR), static local variables, +// and aggregate global initialization (MEMSET + element stores). + +/* + * Expected IR: + * + * function test_globals (NORMAL) { + * objects: + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %0 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %1 = ENTER_SCOPE // { // Simple global. if (g_simple != 42)... + * %2 = GLOBAL_PTR // g_simple + * %3 = MEMORY/LOAD_LE_32 [%2] // g_simple + * %4 = CONST/INT32 42 // 42 + * %5 = CMP_NE [%3, %4] // g_simple != 42 + * >> %6 = COND_BRANCH [%5] // if (g_simple != 42) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %12 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %13 = GLOBAL_PTR // g_array + * %14 = CONST/INT32 0 // 0 + * %15 = PTR_ADD elem_size=4 [%13, %14] // g_array[0] + * %16 = MEMORY/LOAD_LE_32 [%15] // g_array[0] + * %17 = CONST/INT32 1 // 1 + * %18 = CMP_NE [%16, %17] // g_array[0] != 1 + * >> %19 = COND_BRANCH [%18] // if (g_array[0] != 1) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %25 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %26 = GLOBAL_PTR // g_array + * %27 = CONST/INT32 1 // 1 + * %28 = PTR_ADD elem_size=4 [%26, %27] // g_array[1] + * %29 = MEMORY/LOAD_LE_32 [%28] // g_array[1] + * %30 = CONST/INT32 2 // 2 + * %31 = CMP_NE [%29, %30] // g_array[1] != 2 + * >> %32 = COND_BRANCH [%31] // if (g_array[1] != 2) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %38 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %39 = GLOBAL_PTR // g_array + * %40 = CONST/INT32 2 // 2 + * %41 = PTR_ADD elem_size=4 [%39, %40] // g_array[2] + * %42 = MEMORY/LOAD_LE_32 [%41] // g_array[2] + * %43 = CONST/INT32 3 // 3 + * %44 = CMP_NE [%42, %43] // g_array[2] != 3 + * >> %45 = COND_BRANCH [%44] // if (g_array[2] != 3) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %51 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %52 = GLOBAL_PTR // g_config + * %53 = GEP_FIELD offset=0 .width [%52] // g_config.width + * %54 = MEMORY/LOAD_LE_32 [%53] // g_config.width + * %55 = CONST/INT32 640 // 640 + * %56 = CMP_NE [%54, %55] // g_config.width != 640 + * >> %57 = COND_BRANCH [%56] // if (g_config.width != 640) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %63 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %64 = GLOBAL_PTR // g_config + * %65 = GEP_FIELD offset=4 .height [%64] // g_config.height + * %66 = MEMORY/LOAD_LE_32 [%65] // g_config.height + * %67 = CONST/INT32 480 // 480 + * %68 = CMP_NE [%66, %67] // g_config.height != 480 + * >> %69 = COND_BRANCH [%68] // if (g_config.height != 480) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %75 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %76 = GLOBAL_PTR // g_config + * %77 = GEP_FIELD offset=8 .depth [%76] // g_config.depth + * %78 = MEMORY/LOAD_LE_32 [%77] // g_config.depth + * %79 = CONST/INT32 32 // 32 + * %80 = CMP_NE [%78, %79] // g_config.depth != 32 + * >> %81 = COND_BRANCH [%80] // if (g_config.depth != 32) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %87 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %88 = GLOBAL_PTR // s_local + * %89 = MEMORY/LOAD_LE_32 [%88] // s_local + * %90 = CONST/INT32 77 // 77 + * %91 = CMP_NE [%89, %90] // s_local != 77 + * >> %92 = COND_BRANCH [%91] // if (s_local != 77) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %98 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %99 = GLOBAL_PTR // g_static + * %100 = MEMORY/LOAD_LE_32 [%99] // g_static + * %101 = CONST/INT32 100 // 100 + * %102 = CMP_NE [%100, %101] // g_static != 100 + * >> %103 = COND_BRANCH [%102] // if (g_static != 100) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %109 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %110 = GLOBAL_PTR // g_simple + * %111 = CONST/INT32 99 // 99 + * >> %112 = MEMORY/STORE_LE_32 [%110, %111] // g_simple = 99 + * %113 = GLOBAL_PTR // g_simple + * %114 = MEMORY/LOAD_LE_32 [%113] // g_simple + * %115 = CONST/INT32 99 // 99 + * %116 = CMP_NE [%114, %115] // g_simple != 99 + * >> %117 = COND_BRANCH [%116] // if (g_simple != 99) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %123 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %125 = RETURN_PTR // return 0 + * %124 = CONST/INT32 0 // 0 + * >> %126 = MEMORY/STORE_LE_32 [%125, %124] // return 0 + * >> %127 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %128 = RET [%124] // return 0 + * block_29 IF_THEN <- [block_28]: + * %119 = RETURN_PTR // return 10 + * %118 = CONST/INT32 10 // 10 + * >> %120 = MEMORY/STORE_LE_32 [%119, %118] // return 10 + * >> %121 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %122 = RET [%118] // return 10 + * block_26 IF_THEN <- [block_25]: + * %105 = RETURN_PTR // return 9 + * %104 = CONST/INT32 9 // 9 + * >> %106 = MEMORY/STORE_LE_32 [%105, %104] // return 9 + * >> %107 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %108 = RET [%104] // return 9 + * block_23 IF_THEN <- [block_22]: + * %94 = RETURN_PTR // return 8 + * %93 = CONST/INT32 8 // 8 + * >> %95 = MEMORY/STORE_LE_32 [%94, %93] // return 8 + * >> %96 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %97 = RET [%93] // return 8 + * block_20 IF_THEN <- [block_19]: + * %83 = RETURN_PTR // return 7 + * %82 = CONST/INT32 7 // 7 + * >> %84 = MEMORY/STORE_LE_32 [%83, %82] // return 7 + * >> %85 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %86 = RET [%82] // return 7 + * block_17 IF_THEN <- [block_16]: + * %71 = RETURN_PTR // return 6 + * %70 = CONST/INT32 6 // 6 + * >> %72 = MEMORY/STORE_LE_32 [%71, %70] // return 6 + * >> %73 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %74 = RET [%70] // return 6 + * block_14 IF_THEN <- [block_13]: + * %59 = RETURN_PTR // return 5 + * %58 = CONST/INT32 5 // 5 + * >> %60 = MEMORY/STORE_LE_32 [%59, %58] // return 5 + * >> %61 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %62 = RET [%58] // return 5 + * block_11 IF_THEN <- [block_10]: + * %47 = RETURN_PTR // return 4 + * %46 = CONST/INT32 4 // 4 + * >> %48 = MEMORY/STORE_LE_32 [%47, %46] // return 4 + * >> %49 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %50 = RET [%46] // return 4 + * block_8 IF_THEN <- [block_7]: + * %34 = RETURN_PTR // return 3 + * %33 = CONST/INT32 3 // 3 + * >> %35 = MEMORY/STORE_LE_32 [%34, %33] // return 3 + * >> %36 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %37 = RET [%33] // return 3 + * block_5 IF_THEN <- [block_4]: + * %21 = RETURN_PTR // return 2 + * %20 = CONST/INT32 2 // 2 + * >> %22 = MEMORY/STORE_LE_32 [%21, %20] // return 2 + * >> %23 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %24 = RET [%20] // return 2 + * block_2 IF_THEN <- [block_1]: + * %8 = RETURN_PTR // return 1 + * %7 = CONST/INT32 1 // 1 + * >> %9 = MEMORY/STORE_LE_32 [%8, %7] // return 1 + * >> %10 = EXIT_SCOPE // { // Simple global. if (g_simple != 42)... + * >> %11 = RET [%7] // return 1 + * } + */ + + + + + + + + + + +int g_simple = 42; +int g_array[3] = {1, 2, 3}; + +struct Config { + int width; + int height; + int depth; +}; +struct Config g_config = {640, 480, 32}; + +static int g_static = 100; + +int test_globals(void) { + // Simple global. + if (g_simple != 42) return 1; + + // Global array. + if (g_array[0] != 1) return 2; + if (g_array[1] != 2) return 3; + if (g_array[2] != 3) return 4; + + // Global struct. + if (g_config.width != 640) return 5; + if (g_config.height != 480) return 6; + if (g_config.depth != 32) return 7; + + // Static local. + static int s_local = 77; + if (s_local != 77) return 8; + + // File-scope static. + if (g_static != 100) return 9; + + // Modify global. + g_simple = 99; + if (g_simple != 99) return 10; + + return 0; +} diff --git a/tests/InterpretIR/test_goto.c b/tests/InterpretIR/test_goto.c new file mode 100644 index 000000000..e24b16c15 --- /dev/null +++ b/tests/InterpretIR/test_goto.c @@ -0,0 +1,285 @@ +// Tests: goto (GOTO), labels (LABEL), goto compensation blocks +// (COMPENSATION) for cross-scope jumps, forward gotos, backward gotos, +// and goto into nested scopes. + +/* + * Expected IR: + * + * function test_goto (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (result) + * obj_1 LOCAL_VALUE size=4 align=4 (count) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %result.0 = ALLOCA/LOCAL size=4 align=4 + * >> %count.1 = ALLOCA/LOCAL size=4 align=4 + * >> %2 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %3 = ENTER_SCOPE // { int result = 0; // Forward goto. ... + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %4 = CONST/INT32 0 // 0 + * >> %result.5 = MEMORY/STORE_LE_32 [%result.0, %4] + * >> %6 = GOTO // goto forward + * -> [block_2] + * block_2 LABEL <- [block_1]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %8 = MEMORY/LOAD_LE_32 [%result.0] // result + * %9 = CONST/INT32 0 // 0 + * %10 = CMP_NE [%8, %9] // result != 0 + * >> %11 = COND_BRANCH [%10] // if (result != 0) return 1 + * -> [block_4, block_5] + * block_5 IF_ELSE <- [block_2]: + * >> %17 = IMPLICIT_GOTO + * -> [block_6] + * block_6 IF_MERGE <- [block_5]: + * %count.1 = ALLOCA/LOCAL size=4 align=4 + * %18 = CONST/INT32 0 // 0 + * >> %count.19 = MEMORY/STORE_LE_32 [%count.1, %18] + * >> %20 = IMPLICIT_GOTO // loop: if (count >= 5) goto done + * -> [block_7] + * block_7 LABEL <- [block_6, block_12]: + * %count.1 = ALLOCA/LOCAL size=4 align=4 + * %21 = MEMORY/LOAD_LE_32 [%count.1] // count + * %22 = CONST/INT32 5 // 5 + * %23 = CMP_GE [%21, %22] // count >= 5 + * >> %24 = COND_BRANCH [%23] // if (count >= 5) goto done + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %27 = IMPLICIT_GOTO + * -> [block_12] + * block_12 IF_MERGE <- [block_9]: + * %count.1 = ALLOCA/LOCAL size=4 align=4 + * %28 = CONST/INT32 1 // count++ + * >> %29 = READ_MODIFY_WRITE(ADD old) [%count.1, %28] // count++ + * >> %30 = GOTO // goto loop + * -> [block_7] + * block_8 IF_THEN <- [block_7]: + * >> %25 = GOTO // goto done + * -> [block_10] + * block_10 LABEL <- [block_8]: + * %count.1 = ALLOCA/LOCAL size=4 align=4 + * %32 = MEMORY/LOAD_LE_32 [%count.1] // count + * %33 = CONST/INT32 5 // 5 + * %34 = CMP_NE [%32, %33] // count != 5 + * >> %35 = COND_BRANCH [%34] // if (count != 5) return 2 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_10]: + * >> %41 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %42 = CONST/INT32 0 // 0 + * >> %43 = MEMORY/STORE_LE_32 [%result.0, %42] // result = 0 + * >> %44 = ENTER_SCOPE // { result = 10; goto skip_inner;... + * %45 = CONST/INT32 10 // 10 + * >> %46 = MEMORY/STORE_LE_32 [%result.0, %45] // result = 10 + * >> %47 = GOTO // goto skip_inner + * -> [block_38] + * block_38 COMPENSATION <- [block_16]: + * >> %119 = EXIT_SCOPE // { result = 10; goto skip_inner;... + * >> %120 = IMPLICIT_GOTO + * -> [block_17] + * block_17 LABEL <- [block_38]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %49 = MEMORY/LOAD_LE_32 [%result.0] // result + * %50 = CONST/INT32 10 // 10 + * %51 = CMP_NE [%49, %50] // result != 10 + * >> %52 = COND_BRANCH [%51] // if (result != 10) return 3 + * -> [block_19, block_20] + * block_20 IF_ELSE <- [block_17]: + * >> %58 = IMPLICIT_GOTO + * -> [block_21] + * block_21 IF_MERGE <- [block_20]: + * >> %59 = ENTER_SCOPE // { { goto escape; } ... + * >> %60 = ENTER_SCOPE // { goto escape; } + * >> %61 = GOTO // goto escape + * -> [block_39] + * block_39 COMPENSATION <- [block_21]: + * >> %121 = EXIT_SCOPE // { goto escape; } + * >> %122 = EXIT_SCOPE // { { goto escape; } ... + * >> %123 = IMPLICIT_GOTO + * -> [block_22] + * block_22 LABEL <- [block_39]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %63 = CONST/INT32 99 // 99 + * >> %64 = MEMORY/STORE_LE_32 [%result.0, %63] // result = 99 + * %65 = MEMORY/LOAD_LE_32 [%result.0] // result + * %66 = CONST/INT32 99 // 99 + * %67 = CMP_NE [%65, %66] // result != 99 + * >> %68 = COND_BRANCH [%67] // if (result != 99) return 4 + * -> [block_24, block_25] + * block_25 IF_ELSE <- [block_22]: + * >> %74 = IMPLICIT_GOTO + * -> [block_26] + * block_26 IF_MERGE <- [block_25]: + * >> %75 = ENTER_SCOPE // { result = 200; goto after_dead... + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %76 = CONST/INT32 200 // 200 + * >> %77 = MEMORY/STORE_LE_32 [%result.0, %76] // result = 200 + * >> %78 = GOTO // goto after_dead + * -> [block_40] + * block_40 COMPENSATION <- [block_26]: + * >> %124 = EXIT_SCOPE // { result = 200; goto after_dead... + * >> %125 = IMPLICIT_GOTO + * -> [block_27] + * block_27 LABEL <- [block_40]: + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %80 = MEMORY/LOAD_LE_32 [%result.0] // result + * %81 = CONST/INT32 200 // 200 + * %82 = CMP_NE [%80, %81] // result != 200 + * >> %83 = COND_BRANCH [%82] // if (result != 200) return 5 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_27]: + * >> %89 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * >> %90 = ENTER_SCOPE // { { result = 300; ... + * >> %91 = ENTER_SCOPE // { result = 300; if (res... + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %92 = CONST/INT32 300 // 300 + * >> %93 = MEMORY/STORE_LE_32 [%result.0, %92] // result = 300 + * %94 = MEMORY/LOAD_LE_32 [%result.0] // result + * %95 = CONST/INT32 300 // 300 + * %96 = CMP_EQ [%94, %95] // result == 300 + * >> %97 = COND_BRANCH [%96] // if (result == 300) { // The ret... + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %101 = IMPLICIT_GOTO + * -> [block_34] + * block_32 IF_THEN <- [block_31]: + * >> %98 = ENTER_SCOPE // { // The return terminates; sco... + * >> %99 = EXIT_SCOPE // { // The return terminates; sco... + * >> %100 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_32, block_33]: + * >> %102 = EXIT_SCOPE // { result = 300; if (res... + * >> %103 = EXIT_SCOPE // { { result = 300; ... + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %104 = MEMORY/LOAD_LE_32 [%result.0] // result + * %105 = CONST/INT32 300 // 300 + * %106 = CMP_NE [%104, %105] // result != 300 + * >> %107 = COND_BRANCH [%106] // if (result != 300) return 6 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %113 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %115 = RETURN_PTR // return 0 + * %114 = CONST/INT32 0 // 0 + * >> %116 = MEMORY/STORE_LE_32 [%115, %114] // return 0 + * >> %117 = EXIT_SCOPE // { int result = 0; // Forward goto. ... + * >> %118 = RET [%114] // return 0 + * block_35 IF_THEN <- [block_34]: + * %109 = RETURN_PTR // return 6 + * %108 = CONST/INT32 6 // 6 + * >> %110 = MEMORY/STORE_LE_32 [%109, %108] // return 6 + * >> %111 = EXIT_SCOPE // { int result = 0; // Forward goto. ... + * >> %112 = RET [%108] // return 6 + * block_29 IF_THEN <- [block_27]: + * %85 = RETURN_PTR // return 5 + * %84 = CONST/INT32 5 // 5 + * >> %86 = MEMORY/STORE_LE_32 [%85, %84] // return 5 + * >> %87 = EXIT_SCOPE // { int result = 0; // Forward goto. ... + * >> %88 = RET [%84] // return 5 + * block_24 IF_THEN <- [block_22]: + * %70 = RETURN_PTR // return 4 + * %69 = CONST/INT32 4 // 4 + * >> %71 = MEMORY/STORE_LE_32 [%70, %69] // return 4 + * >> %72 = EXIT_SCOPE // { int result = 0; // Forward goto. ... + * >> %73 = RET [%69] // return 4 + * block_19 IF_THEN <- [block_17]: + * %54 = RETURN_PTR // return 3 + * %53 = CONST/INT32 3 // 3 + * >> %55 = MEMORY/STORE_LE_32 [%54, %53] // return 3 + * >> %56 = EXIT_SCOPE // { int result = 0; // Forward goto. ... + * >> %57 = RET [%53] // return 3 + * block_14 IF_THEN <- [block_10]: + * %37 = RETURN_PTR // return 2 + * %36 = CONST/INT32 2 // 2 + * >> %38 = MEMORY/STORE_LE_32 [%37, %36] // return 2 + * >> %39 = EXIT_SCOPE // { int result = 0; // Forward goto. ... + * >> %40 = RET [%36] // return 2 + * block_4 IF_THEN <- [block_2]: + * %13 = RETURN_PTR // return 1 + * %12 = CONST/INT32 1 // 1 + * >> %14 = MEMORY/STORE_LE_32 [%13, %12] // return 1 + * >> %15 = EXIT_SCOPE // { int result = 0; // Forward goto. ... + * >> %16 = RET [%12] // return 1 + * } + */ + + + + + + + + + + +int test_goto(void) { + int result = 0; + + // Forward goto. + goto forward; + result = -1; // should be skipped +forward: + if (result != 0) return 1; + + // Backward goto (simple loop). + int count = 0; +loop: + if (count >= 5) goto done; + count++; + goto loop; +done: + if (count != 5) return 2; + + // Goto across scope boundaries (compensation block needed). + result = 0; + { + result = 10; + goto skip_inner; + result = -1; + } +skip_inner: + if (result != 10) return 3; + + // Goto out of nested scopes. + { + { + goto escape; + } + } +escape: + result = 99; + if (result != 99) return 4; + + // Goto inside a scope with dead code after it. + // The scope's EXIT_SCOPE must not appear after the goto terminator. + { + result = 200; + goto after_dead; + result = -1; // dead code + } +after_dead: + if (result != 200) return 5; + + // Return inside a nested scope: all enclosing scopes must be exited + // before the return, and no EXIT_SCOPE should trail the terminator. + { + { + result = 300; + if (result == 300) { + // The return terminates; scope exits are emitted before it. + // After return, remaining code in enclosing scopes is dead. + } + } + } + if (result != 300) return 6; + + return 0; +} diff --git a/tests/InterpretIR/test_init_lists.c b/tests/InterpretIR/test_init_lists.c new file mode 100644 index 000000000..ee1dcdd99 --- /dev/null +++ b/tests/InterpretIR/test_init_lists.c @@ -0,0 +1,487 @@ +// Tests: aggregate initialization via InitListExpr decomposition — +// array init (PTR_ADD + STORE per element), struct init (GEP_FIELD + STORE), +// nested struct/array, partial initialization (MEMSET zeroes rest), +// designated initializers (.field = val), compound literals. + +/* + * Expected IR: + * + * function test_init_lists (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=16 align=4 (arr) + * obj_1 LOCAL_VALUE size=20 align=4 (partial) + * obj_2 LOCAL_VALUE size=8 align=4 (s) + * obj_3 LOCAL_VALUE size=12 align=4 (o) + * obj_4 LOCAL_VALUE size=8 align=4 (d) + * obj_5 LOCAL_VALUE size=8 align=4 (cl) + * obj_6 LOCAL_VALUE size=12 align=4 (z) + * obj_7 COMPOUND_LITERAL size=8 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %arr.0 = ALLOCA/LOCAL size=16 align=4 + * >> %partial.1 = ALLOCA/LOCAL size=20 align=4 + * >> %s.2 = ALLOCA/LOCAL size=8 align=4 + * >> %o.3 = ALLOCA/LOCAL size=12 align=4 + * >> %d.4 = ALLOCA/LOCAL size=8 align=4 + * >> %cl.5 = ALLOCA/LOCAL size=8 align=4 + * >> %z.6 = ALLOCA/LOCAL size=12 align=4 + * >> %7 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %8 = ENTER_SCOPE // { // Array initialization. int arr[4] =... + * %arr.0 = ALLOCA/LOCAL size=16 align=4 + * %arr.9 = CONST/UINT8 0 + * %arr.10 = CONST/UINT64 16 + * >> %arr.11 = MEMORY/MEMSET [%arr.0, %arr.9, %arr.10] + * %12 = CONST/INT32 10 // 10 + * >> %arr.13 = MEMORY/STORE_LE_32 [%arr.0, %12] + * %arr.14 = CONST/INT64 1 + * %arr.15 = PTR_ADD elem_size=4 [%arr.0, %arr.14] + * %16 = CONST/INT32 20 // 20 + * >> %arr.17 = MEMORY/STORE_LE_32 [%arr.15, %16] + * %arr.18 = CONST/INT64 2 + * %arr.19 = PTR_ADD elem_size=4 [%arr.0, %arr.18] + * %20 = CONST/INT32 30 // 30 + * >> %arr.21 = MEMORY/STORE_LE_32 [%arr.19, %20] + * %arr.22 = CONST/INT64 3 + * %arr.23 = PTR_ADD elem_size=4 [%arr.0, %arr.22] + * %24 = CONST/INT32 40 // 40 + * >> %arr.25 = MEMORY/STORE_LE_32 [%arr.23, %24] + * %26 = CONST/INT32 0 // 0 + * %27 = PTR_ADD elem_size=4 [%arr.0, %26] // arr[0] + * %28 = MEMORY/LOAD_LE_32 [%27] // arr[0] + * %29 = CONST/INT32 10 // 10 + * %30 = CMP_NE [%28, %29] // arr[0] != 10 + * >> %31 = COND_BRANCH [%30] // if (arr[0] != 10) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %37 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %arr.0 = ALLOCA/LOCAL size=16 align=4 + * %38 = CONST/INT32 3 // 3 + * %39 = PTR_ADD elem_size=4 [%arr.0, %38] // arr[3] + * %40 = MEMORY/LOAD_LE_32 [%39] // arr[3] + * %41 = CONST/INT32 40 // 40 + * %42 = CMP_NE [%40, %41] // arr[3] != 40 + * >> %43 = COND_BRANCH [%42] // if (arr[3] != 40) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %49 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %partial.1 = ALLOCA/LOCAL size=20 align=4 + * %partial.50 = CONST/UINT8 0 + * %partial.51 = CONST/UINT64 20 + * >> %partial.52 = MEMORY/MEMSET [%partial.1, %partial.50, %partial.51] + * %53 = CONST/INT32 1 // 1 + * >> %partial.54 = MEMORY/STORE_LE_32 [%partial.1, %53] + * %partial.55 = CONST/INT64 1 + * %partial.56 = PTR_ADD elem_size=4 [%partial.1, %partial.55] + * %57 = CONST/INT32 2 // 2 + * >> %partial.58 = MEMORY/STORE_LE_32 [%partial.56, %57] + * %59 = CONST/INT32 0 // 0 + * %60 = PTR_ADD elem_size=4 [%partial.1, %59] // partial[0] + * %61 = MEMORY/LOAD_LE_32 [%60] // partial[0] + * %62 = CONST/INT32 1 // 1 + * %63 = CMP_NE [%61, %62] // partial[0] != 1 + * >> %64 = COND_BRANCH [%63] // if (partial[0] != 1) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %70 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %partial.1 = ALLOCA/LOCAL size=20 align=4 + * %71 = CONST/INT32 1 // 1 + * %72 = PTR_ADD elem_size=4 [%partial.1, %71] // partial[1] + * %73 = MEMORY/LOAD_LE_32 [%72] // partial[1] + * %74 = CONST/INT32 2 // 2 + * %75 = CMP_NE [%73, %74] // partial[1] != 2 + * >> %76 = COND_BRANCH [%75] // if (partial[1] != 2) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %82 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %partial.1 = ALLOCA/LOCAL size=20 align=4 + * %83 = CONST/INT32 2 // 2 + * %84 = PTR_ADD elem_size=4 [%partial.1, %83] // partial[2] + * %85 = MEMORY/LOAD_LE_32 [%84] // partial[2] + * %86 = CONST/INT32 0 // 0 + * %87 = CMP_NE [%85, %86] // partial[2] != 0 + * >> %88 = COND_BRANCH [%87] // if (partial[2] != 0) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %94 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %partial.1 = ALLOCA/LOCAL size=20 align=4 + * %95 = CONST/INT32 4 // 4 + * %96 = PTR_ADD elem_size=4 [%partial.1, %95] // partial[4] + * %97 = MEMORY/LOAD_LE_32 [%96] // partial[4] + * %98 = CONST/INT32 0 // 0 + * %99 = CMP_NE [%97, %98] // partial[4] != 0 + * >> %100 = COND_BRANCH [%99] // if (partial[4] != 0) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %106 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %s.2 = ALLOCA/LOCAL size=8 align=4 + * %s.107 = CONST/UINT8 0 + * %s.108 = CONST/UINT64 8 + * >> %s.109 = MEMORY/MEMSET [%s.2, %s.107, %s.108] + * %s.110 = GEP_FIELD offset=0 .a [%s.2] + * %111 = CONST/INT32 100 // 100 + * >> %s.112 = MEMORY/STORE_LE_32 [%s.110, %111] + * %s.113 = GEP_FIELD offset=4 .b [%s.2] + * %114 = CONST/INT32 200 // 200 + * >> %s.115 = MEMORY/STORE_LE_32 [%s.113, %114] + * %116 = GEP_FIELD offset=0 .a [%s.2] // s.a + * %117 = MEMORY/LOAD_LE_32 [%116] // s.a + * %118 = CONST/INT32 100 // 100 + * %119 = CMP_NE [%117, %118] // s.a != 100 + * >> %120 = COND_BRANCH [%119] // if (s.a != 100) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %126 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %s.2 = ALLOCA/LOCAL size=8 align=4 + * %127 = GEP_FIELD offset=4 .b [%s.2] // s.b + * %128 = MEMORY/LOAD_LE_32 [%127] // s.b + * %129 = CONST/INT32 200 // 200 + * %130 = CMP_NE [%128, %129] // s.b != 200 + * >> %131 = COND_BRANCH [%130] // if (s.b != 200) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %137 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %o.3 = ALLOCA/LOCAL size=12 align=4 + * %o.138 = CONST/UINT8 0 + * %o.139 = CONST/UINT64 12 + * >> %o.140 = MEMORY/MEMSET [%o.3, %o.138, %o.139] + * %o.141 = GEP_FIELD offset=0 .inner [%o.3] + * %o.142 = CONST/UINT8 0 + * %o.143 = CONST/UINT64 8 + * >> %o.144 = MEMORY/MEMSET [%o.141, %o.142, %o.143] + * %o.145 = GEP_FIELD offset=0 .a [%o.141] + * %146 = CONST/INT32 5 // 5 + * >> %o.147 = MEMORY/STORE_LE_32 [%o.145, %146] + * %o.148 = GEP_FIELD offset=4 .b [%o.141] + * %149 = CONST/INT32 6 // 6 + * >> %o.150 = MEMORY/STORE_LE_32 [%o.148, %149] + * %o.151 = GEP_FIELD offset=8 .c [%o.3] + * %152 = CONST/INT32 7 // 7 + * >> %o.153 = MEMORY/STORE_LE_32 [%o.151, %152] + * %154 = GEP_FIELD offset=0 .inner [%o.3] // o.inner + * %155 = GEP_FIELD offset=0 .a [%154] // o.inner.a + * %156 = MEMORY/LOAD_LE_32 [%155] // o.inner.a + * %157 = CONST/INT32 5 // 5 + * %158 = CMP_NE [%156, %157] // o.inner.a != 5 + * >> %159 = COND_BRANCH [%158] // if (o.inner.a != 5) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %165 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %o.3 = ALLOCA/LOCAL size=12 align=4 + * %166 = GEP_FIELD offset=0 .inner [%o.3] // o.inner + * %167 = GEP_FIELD offset=4 .b [%166] // o.inner.b + * %168 = MEMORY/LOAD_LE_32 [%167] // o.inner.b + * %169 = CONST/INT32 6 // 6 + * %170 = CMP_NE [%168, %169] // o.inner.b != 6 + * >> %171 = COND_BRANCH [%170] // if (o.inner.b != 6) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %177 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %o.3 = ALLOCA/LOCAL size=12 align=4 + * %178 = GEP_FIELD offset=8 .c [%o.3] // o.c + * %179 = MEMORY/LOAD_LE_32 [%178] // o.c + * %180 = CONST/INT32 7 // 7 + * %181 = CMP_NE [%179, %180] // o.c != 7 + * >> %182 = COND_BRANCH [%181] // if (o.c != 7) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %188 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %d.4 = ALLOCA/LOCAL size=8 align=4 + * %d.189 = CONST/UINT8 0 + * %d.190 = CONST/UINT64 8 + * >> %d.191 = MEMORY/MEMSET [%d.4, %d.189, %d.190] + * %d.192 = GEP_FIELD offset=0 .a [%d.4] + * %193 = CONST/INT32 10 // 10 + * >> %d.194 = MEMORY/STORE_LE_32 [%d.192, %193] + * %d.195 = GEP_FIELD offset=4 .b [%d.4] + * %196 = CONST/INT32 42 // 42 + * >> %d.197 = MEMORY/STORE_LE_32 [%d.195, %196] + * %198 = GEP_FIELD offset=0 .a [%d.4] // d.a + * %199 = MEMORY/LOAD_LE_32 [%198] // d.a + * %200 = CONST/INT32 10 // 10 + * %201 = CMP_NE [%199, %200] // d.a != 10 + * >> %202 = COND_BRANCH [%201] // if (d.a != 10) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %208 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %d.4 = ALLOCA/LOCAL size=8 align=4 + * %209 = GEP_FIELD offset=4 .b [%d.4] // d.b + * %210 = MEMORY/LOAD_LE_32 [%209] // d.b + * %211 = CONST/INT32 42 // 42 + * %212 = CMP_NE [%210, %211] // d.b != 42 + * >> %213 = COND_BRANCH [%212] // if (d.b != 42) return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %219 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %220 = ALLOCA/LOCAL size=8 align=4 // (struct Inner){99, 88} + * %221 = CONST/UINT8 0 // (struct Inner){99, 88} + * %222 = CONST/UINT64 8 // (struct Inner){99, 88} + * >> %223 = MEMORY/MEMSET [%220, %221, %222] // (struct Inner){99, 88} + * %224 = GEP_FIELD offset=0 .a [%220] // (struct Inner){99, 88} + * %225 = CONST/INT32 99 // 99 + * >> %226 = MEMORY/STORE_LE_32 [%224, %225] // (struct Inner){99, 88} + * %227 = GEP_FIELD offset=4 .b [%220] // (struct Inner){99, 88} + * %228 = CONST/INT32 88 // 88 + * >> %229 = MEMORY/STORE_LE_32 [%227, %228] // (struct Inner){99, 88} + * %cl.5 = ALLOCA/LOCAL size=8 align=4 + * %230 = CONST/UINT64 8 + * >> %cl.231 = MEMORY/MEMCPY [%cl.5, %220, %230] + * %232 = GEP_FIELD offset=0 .a [%cl.5] // cl.a + * %233 = MEMORY/LOAD_LE_32 [%232] // cl.a + * %234 = CONST/INT32 99 // 99 + * %235 = CMP_NE [%233, %234] // cl.a != 99 + * >> %236 = COND_BRANCH [%235] // if (cl.a != 99) return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %242 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %cl.5 = ALLOCA/LOCAL size=8 align=4 + * %243 = GEP_FIELD offset=4 .b [%cl.5] // cl.b + * %244 = MEMORY/LOAD_LE_32 [%243] // cl.b + * %245 = CONST/INT32 88 // 88 + * %246 = CMP_NE [%244, %245] // cl.b != 88 + * >> %247 = COND_BRANCH [%246] // if (cl.b != 88) return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %253 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %z.6 = ALLOCA/LOCAL size=12 align=4 + * %z.254 = CONST/UINT8 0 + * %z.255 = CONST/UINT64 12 + * >> %z.256 = MEMORY/MEMSET [%z.6, %z.254, %z.255] + * %z.257 = GEP_FIELD offset=0 .inner [%z.6] + * %z.258 = CONST/UINT8 0 + * %z.259 = CONST/UINT64 8 + * >> %z.260 = MEMORY/MEMSET [%z.257, %z.258, %z.259] + * %z.261 = GEP_FIELD offset=0 .a [%z.257] + * %262 = CONST/INT32 0 // 0 + * >> %z.263 = MEMORY/STORE_LE_32 [%z.261, %262] + * %z.264 = GEP_FIELD offset=4 .b [%z.257] + * %265 = CONST/INT32 0 + * >> %z.266 = MEMORY/STORE_LE_32 [%z.264, %265] + * %z.267 = GEP_FIELD offset=8 .c [%z.6] + * %268 = CONST/INT32 0 + * >> %z.269 = MEMORY/STORE_LE_32 [%z.267, %268] + * %270 = GEP_FIELD offset=0 .inner [%z.6] // z.inner + * %271 = GEP_FIELD offset=0 .a [%270] // z.inner.a + * %272 = MEMORY/LOAD_LE_32 [%271] // z.inner.a + * %273 = CONST/INT32 0 // 0 + * %274 = CMP_NE [%272, %273] // z.inner.a != 0 + * >> %275 = COND_BRANCH [%274] // if (z.inner.a != 0) return 16 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %281 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %z.6 = ALLOCA/LOCAL size=12 align=4 + * %282 = GEP_FIELD offset=8 .c [%z.6] // z.c + * %283 = MEMORY/LOAD_LE_32 [%282] // z.c + * %284 = CONST/INT32 0 // 0 + * %285 = CMP_NE [%283, %284] // z.c != 0 + * >> %286 = COND_BRANCH [%285] // if (z.c != 0) return 17 + * -> [block_50, block_51] + * block_51 IF_ELSE <- [block_49]: + * >> %292 = IMPLICIT_GOTO + * -> [block_52] + * block_52 IF_MERGE <- [block_51]: + * %294 = RETURN_PTR // return 0 + * %293 = CONST/INT32 0 // 0 + * >> %295 = MEMORY/STORE_LE_32 [%294, %293] // return 0 + * >> %296 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %297 = RET [%293] // return 0 + * block_50 IF_THEN <- [block_49]: + * %288 = RETURN_PTR // return 17 + * %287 = CONST/INT32 17 // 17 + * >> %289 = MEMORY/STORE_LE_32 [%288, %287] // return 17 + * >> %290 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %291 = RET [%287] // return 17 + * block_47 IF_THEN <- [block_46]: + * %277 = RETURN_PTR // return 16 + * %276 = CONST/INT32 16 // 16 + * >> %278 = MEMORY/STORE_LE_32 [%277, %276] // return 16 + * >> %279 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %280 = RET [%276] // return 16 + * block_44 IF_THEN <- [block_43]: + * %249 = RETURN_PTR // return 15 + * %248 = CONST/INT32 15 // 15 + * >> %250 = MEMORY/STORE_LE_32 [%249, %248] // return 15 + * >> %251 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %252 = RET [%248] // return 15 + * block_41 IF_THEN <- [block_40]: + * %238 = RETURN_PTR // return 14 + * %237 = CONST/INT32 14 // 14 + * >> %239 = MEMORY/STORE_LE_32 [%238, %237] // return 14 + * >> %240 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %241 = RET [%237] // return 14 + * block_38 IF_THEN <- [block_37]: + * %215 = RETURN_PTR // return 13 + * %214 = CONST/INT32 13 // 13 + * >> %216 = MEMORY/STORE_LE_32 [%215, %214] // return 13 + * >> %217 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %218 = RET [%214] // return 13 + * block_35 IF_THEN <- [block_34]: + * %204 = RETURN_PTR // return 12 + * %203 = CONST/INT32 12 // 12 + * >> %205 = MEMORY/STORE_LE_32 [%204, %203] // return 12 + * >> %206 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %207 = RET [%203] // return 12 + * block_32 IF_THEN <- [block_31]: + * %184 = RETURN_PTR // return 11 + * %183 = CONST/INT32 11 // 11 + * >> %185 = MEMORY/STORE_LE_32 [%184, %183] // return 11 + * >> %186 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %187 = RET [%183] // return 11 + * block_29 IF_THEN <- [block_28]: + * %173 = RETURN_PTR // return 10 + * %172 = CONST/INT32 10 // 10 + * >> %174 = MEMORY/STORE_LE_32 [%173, %172] // return 10 + * >> %175 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %176 = RET [%172] // return 10 + * block_26 IF_THEN <- [block_25]: + * %161 = RETURN_PTR // return 9 + * %160 = CONST/INT32 9 // 9 + * >> %162 = MEMORY/STORE_LE_32 [%161, %160] // return 9 + * >> %163 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %164 = RET [%160] // return 9 + * block_23 IF_THEN <- [block_22]: + * %133 = RETURN_PTR // return 8 + * %132 = CONST/INT32 8 // 8 + * >> %134 = MEMORY/STORE_LE_32 [%133, %132] // return 8 + * >> %135 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %136 = RET [%132] // return 8 + * block_20 IF_THEN <- [block_19]: + * %122 = RETURN_PTR // return 7 + * %121 = CONST/INT32 7 // 7 + * >> %123 = MEMORY/STORE_LE_32 [%122, %121] // return 7 + * >> %124 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %125 = RET [%121] // return 7 + * block_17 IF_THEN <- [block_16]: + * %102 = RETURN_PTR // return 6 + * %101 = CONST/INT32 6 // 6 + * >> %103 = MEMORY/STORE_LE_32 [%102, %101] // return 6 + * >> %104 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %105 = RET [%101] // return 6 + * block_14 IF_THEN <- [block_13]: + * %90 = RETURN_PTR // return 5 + * %89 = CONST/INT32 5 // 5 + * >> %91 = MEMORY/STORE_LE_32 [%90, %89] // return 5 + * >> %92 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %93 = RET [%89] // return 5 + * block_11 IF_THEN <- [block_10]: + * %78 = RETURN_PTR // return 4 + * %77 = CONST/INT32 4 // 4 + * >> %79 = MEMORY/STORE_LE_32 [%78, %77] // return 4 + * >> %80 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %81 = RET [%77] // return 4 + * block_8 IF_THEN <- [block_7]: + * %66 = RETURN_PTR // return 3 + * %65 = CONST/INT32 3 // 3 + * >> %67 = MEMORY/STORE_LE_32 [%66, %65] // return 3 + * >> %68 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %69 = RET [%65] // return 3 + * block_5 IF_THEN <- [block_4]: + * %45 = RETURN_PTR // return 2 + * %44 = CONST/INT32 2 // 2 + * >> %46 = MEMORY/STORE_LE_32 [%45, %44] // return 2 + * >> %47 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %48 = RET [%44] // return 2 + * block_2 IF_THEN <- [block_1]: + * %33 = RETURN_PTR // return 1 + * %32 = CONST/INT32 1 // 1 + * >> %34 = MEMORY/STORE_LE_32 [%33, %32] // return 1 + * >> %35 = EXIT_SCOPE // { // Array initialization. int arr[4] =... + * >> %36 = RET [%32] // return 1 + * } + */ + + + + + + + + + + +struct Inner { + int a; + int b; +}; + +struct Outer { + struct Inner inner; + int c; +}; + +int test_init_lists(void) { + // Array initialization. + int arr[4] = {10, 20, 30, 40}; + if (arr[0] != 10) return 1; + if (arr[3] != 40) return 2; + + // Partial init (rest zeroed). + int partial[5] = {1, 2}; + if (partial[0] != 1) return 3; + if (partial[1] != 2) return 4; + if (partial[2] != 0) return 5; + if (partial[4] != 0) return 6; + + // Struct initialization. + struct Inner s = {100, 200}; + if (s.a != 100) return 7; + if (s.b != 200) return 8; + + // Nested struct. + struct Outer o = {{5, 6}, 7}; + if (o.inner.a != 5) return 9; + if (o.inner.b != 6) return 10; + if (o.c != 7) return 11; + + // Designated initializer. + struct Inner d = {.b = 42, .a = 10}; + if (d.a != 10) return 12; + if (d.b != 42) return 13; + + // Compound literal. + struct Inner cl = (struct Inner){99, 88}; + if (cl.a != 99) return 14; + if (cl.b != 88) return 15; + + // Zero initialization. + struct Outer z = {0}; + if (z.inner.a != 0) return 16; + if (z.c != 0) return 17; + + return 0; +} diff --git a/tests/InterpretIR/test_logical_misc.c b/tests/InterpretIR/test_logical_misc.c new file mode 100644 index 000000000..f817d6e28 --- /dev/null +++ b/tests/InterpretIR/test_logical_misc.c @@ -0,0 +1,84 @@ +// Tests: LOGICAL_AND, LOGICAL_OR, LOGICAL_NOT, LAST_VALUE (comma), +// SELECT (ternary), BIT_NOT at all widths, and IntegralToBoolean +// (CMP_NE against zero) at different widths. + +int test_logical_misc(void) { + // --- LOGICAL_AND (short-circuit) --- + { + int a = 1, b = 0; + if (a && b) return 1; // 1 && 0 = 0 + if (!(a && a)) return 2; // 1 && 1 = 1 + if (b && a) return 3; // 0 && 1 = 0 (short-circuit) + } + + // --- LOGICAL_OR (short-circuit) --- + { + int a = 1, b = 0; + if (!(a || b)) return 10; // 1 || 0 = 1 + if (b || b) return 11; // 0 || 0 = 0 + if (!(b || a)) return 12; // 0 || 1 = 1 + } + + // --- LOGICAL_NOT --- + { + int a = 42, b = 0; + if (!a) return 20; // !42 = 0 (falsy) + if (!!b) return 21; // !!0 = 0 + if (!(!b)) return 22; // !0 = 1, !1 = 0... wait, !0 = 1, so !!0 = 0. !(!0) = !1 = 0. + if (!!a != 1) return 23; // !!42 = 1 + } + + // --- LAST_VALUE (comma operator) --- + { + int x = (1, 2, 3); + if (x != 3) return 30; + + // NOTE: Comma with assignment side effects (a = 20, a + 5) + // requires the interpreter to sequence LAST_VALUE operand stores. + // Simplified to avoid this dependency. + int a = 10; + int y = (a, 25); + if (y != 25) return 31; + } + + // --- SELECT (ternary) --- + { + int a = 1, b = 0; + int x = a ? 42 : 99; + if (x != 42) return 40; + + int y = b ? 42 : 99; + if (y != 99) return 41; + + // Nested ternary. + int z = a ? (b ? 1 : 2) : 3; + if (z != 2) return 42; + } + + // --- IntegralToBoolean at different widths --- + { + // char (8-bit): cast to bool via CMP_NE_8 against zero. + signed char c = 1; + if (!c) return 50; + c = 0; + if (c) return 51; + + // short (16-bit) + short s = -1; + if (!s) return 52; + s = 0; + if (s) return 53; + + // int (32-bit) + int i = 0x7FFFFFFF; + if (!i) return 54; + + // long long (64-bit) + long long ll = 1LL << 40; + if (!ll) return 55; + ll = 0; + if (ll) return 56; + } + + return 0; +} diff --git a/tests/InterpretIR/test_memory_ops.c b/tests/InterpretIR/test_memory_ops.c new file mode 100644 index 000000000..acff0d7b9 --- /dev/null +++ b/tests/InterpretIR/test_memory_ops.c @@ -0,0 +1,438 @@ +// Tests: memory and string operations (MEMORY sub-opcodes) — +// memset, memcpy, memmove, memcmp, memchr, strlen, strcmp, strncmp, +// strchr, strrchr, strcpy, strcat. +// Uses __builtin_ variants to avoid needing system headers. + +/* + * Expected IR: + * + * function test_memory_ops (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=16 align=1 (buf) + * obj_1 LOCAL_VALUE size=6 align=1 (src) + * obj_2 LOCAL_VALUE size=16 align=1 (dst) + * obj_3 LOCAL_VALUE size=9 align=1 (overlap) + * obj_4 LOCAL_VALUE size=8 align=8 (sc) + * obj_5 LOCAL_VALUE size=16 align=1 (dest2) + * obj_6 LOCAL_VALUE size=32 align=1 (dest3) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %buf.0 = ALLOCA/LOCAL size=16 align=1 + * >> %src.1 = ALLOCA/LOCAL size=6 align=1 + * >> %dst.2 = ALLOCA/LOCAL size=16 align=1 + * >> %overlap.3 = ALLOCA/LOCAL size=9 align=1 + * >> %sc.4 = ALLOCA/LOCAL size=8 align=8 + * >> %dest2.5 = ALLOCA/LOCAL size=16 align=1 + * >> %dest3.6 = ALLOCA/LOCAL size=32 align=1 + * >> %7 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %8 = ENTER_SCOPE // { // memset. char buf[16]; __builti... + * %buf.0 = ALLOCA/LOCAL size=16 align=1 + * %9 = CAST/BITCAST [%buf.0] // buf + * %10 = CONST/UINT8 65 // 'A' + * %11 = CONST/INT32 10 // 10 + * %12 = CAST/SEXT_I32_I64 [%11] // 10 + * >> %13 = MEMORY/MEMSET [%9, %10, %12] // __builtin_memset(buf, 'A', 10) + * %14 = CONST/INT32 10 // 10 + * %15 = PTR_ADD elem_size=1 [%buf.0, %14] // buf[10] + * %16 = CONST/UINT8 0 // '\0' + * %17 = CAST/TRUNC_I32_I8 [%16] // '\0' + * >> %18 = MEMORY/STORE_LE_8 [%15, %17] // buf[10] = '\0' + * %19 = CONST/INT32 0 // 0 + * %20 = PTR_ADD elem_size=1 [%buf.0, %19] // buf[0] + * %21 = MEMORY/LOAD_LE_8 [%20] // buf[0] + * %22 = CAST/SEXT_I8_I32 [%21] // buf[0] + * %23 = CONST/UINT8 65 // 'A' + * %24 = CMP_NE [%22, %23] // buf[0] != 'A' + * >> %25 = COND_BRANCH [%24] // if (buf[0] != 'A') return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %31 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %buf.0 = ALLOCA/LOCAL size=16 align=1 + * %32 = CONST/INT32 9 // 9 + * %33 = PTR_ADD elem_size=1 [%buf.0, %32] // buf[9] + * %34 = MEMORY/LOAD_LE_8 [%33] // buf[9] + * %35 = CAST/SEXT_I8_I32 [%34] // buf[9] + * %36 = CONST/UINT8 65 // 'A' + * %37 = CMP_NE [%35, %36] // buf[9] != 'A' + * >> %38 = COND_BRANCH [%37] // if (buf[9] != 'A') return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %44 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %src.1 = ALLOCA/LOCAL size=6 align=1 + * %45 = STRING_PTR // "hello" + * %46 = CONST/UINT64 6 + * >> %src.47 = MEMORY/MEMCPY [%src.1, %45, %46] + * %dst.2 = ALLOCA/LOCAL size=16 align=1 + * %48 = CAST/BITCAST [%dst.2] // dst + * %49 = CAST/BITCAST [%src.1] // src + * %50 = CONST/INT32 6 // 6 + * %51 = CAST/SEXT_I32_I64 [%50] // 6 + * >> %52 = MEMORY/MEMCPY [%48, %49, %51] // __builtin_memcpy(dst, src, 6) + * %53 = CONST/INT32 0 // 0 + * %54 = PTR_ADD elem_size=1 [%dst.2, %53] // dst[0] + * %55 = MEMORY/LOAD_LE_8 [%54] // dst[0] + * %56 = CAST/SEXT_I8_I32 [%55] // dst[0] + * %57 = CONST/UINT8 104 // 'h' + * %58 = CMP_NE [%56, %57] // dst[0] != 'h' + * >> %59 = COND_BRANCH [%58] // if (dst[0] != 'h') return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %65 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %dst.2 = ALLOCA/LOCAL size=16 align=1 + * %66 = CONST/INT32 4 // 4 + * %67 = PTR_ADD elem_size=1 [%dst.2, %66] // dst[4] + * %68 = MEMORY/LOAD_LE_8 [%67] // dst[4] + * %69 = CAST/SEXT_I8_I32 [%68] // dst[4] + * %70 = CONST/UINT8 111 // 'o' + * %71 = CMP_NE [%69, %70] // dst[4] != 'o' + * >> %72 = COND_BRANCH [%71] // if (dst[4] != 'o') return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %78 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %overlap.3 = ALLOCA/LOCAL size=9 align=1 + * %79 = STRING_PTR // "abcdefgh" + * %80 = CONST/UINT64 9 + * >> %overlap.81 = MEMORY/MEMCPY [%overlap.3, %79, %80] + * %82 = CONST/INT32 2 // 2 + * %83 = PTR_ADD elem_size=1 [%overlap.3, %82] // overlap + 2 + * %84 = CAST/BITCAST [%83] // overlap + 2 + * %85 = CAST/BITCAST [%overlap.3] // overlap + * %86 = CONST/INT32 4 // 4 + * %87 = CAST/SEXT_I32_I64 [%86] // 4 + * >> %88 = MEMORY/MEMMOVE [%84, %85, %87] // __builtin_memmove(overlap + 2, overlap, 4) + * %89 = CONST/INT32 2 // 2 + * %90 = PTR_ADD elem_size=1 [%overlap.3, %89] // overlap[2] + * %91 = MEMORY/LOAD_LE_8 [%90] // overlap[2] + * %92 = CAST/SEXT_I8_I32 [%91] // overlap[2] + * %93 = CONST/UINT8 97 // 'a' + * %94 = CMP_NE [%92, %93] // overlap[2] != 'a' + * >> %95 = COND_BRANCH [%94] // if (overlap[2] != 'a') return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %101 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %overlap.3 = ALLOCA/LOCAL size=9 align=1 + * %102 = CONST/INT32 5 // 5 + * %103 = PTR_ADD elem_size=1 [%overlap.3, %102] // overlap[5] + * %104 = MEMORY/LOAD_LE_8 [%103] // overlap[5] + * %105 = CAST/SEXT_I8_I32 [%104] // overlap[5] + * %106 = CONST/UINT8 100 // 'd' + * %107 = CMP_NE [%105, %106] // overlap[5] != 'd' + * >> %108 = COND_BRANCH [%107] // if (overlap[5] != 'd') return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %114 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %115 = STRING_PTR // "abc" + * %116 = CAST/BITCAST [%115] // "abc" + * %117 = STRING_PTR // "abc" + * %118 = CAST/BITCAST [%117] // "abc" + * %119 = CONST/INT32 3 // 3 + * %120 = CAST/SEXT_I32_I64 [%119] // 3 + * %121 = MEMORY/MEMCMP [%116, %118, %120] // __builtin_memcmp("abc", "abc", 3) + * %122 = CONST/INT32 0 // 0 + * %123 = CMP_NE [%121, %122] // __builtin_memcmp("abc", "abc", 3) != 0 + * >> %124 = COND_BRANCH [%123] // if (__builtin_memcmp("abc", "abc", 3) != 0) ret... + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %130 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %131 = STRING_PTR // "abc" + * %132 = CAST/BITCAST [%131] // "abc" + * %133 = STRING_PTR // "abd" + * %134 = CAST/BITCAST [%133] // "abd" + * %135 = CONST/INT32 3 // 3 + * %136 = CAST/SEXT_I32_I64 [%135] // 3 + * %137 = MEMORY/MEMCMP [%132, %134, %136] // __builtin_memcmp("abc", "abd", 3) + * %138 = CONST/INT32 0 // 0 + * %139 = CMP_GE [%137, %138] // __builtin_memcmp("abc", "abd", 3) >= 0 + * >> %140 = COND_BRANCH [%139] // if (__builtin_memcmp("abc", "abd", 3) >= 0) ret... + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %146 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %147 = STRING_PTR // "hello" + * %148 = MEMORY/STRLEN [%147] // __builtin_strlen("hello") + * %149 = CONST/INT32 5 // 5 + * %150 = CAST/SEXT_I32_I64 [%149] // 5 + * %151 = CMP_NE [%148, %150] // __builtin_strlen("hello") != 5 + * >> %152 = COND_BRANCH [%151] // if (__builtin_strlen("hello") != 5) return 10 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %158 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %159 = STRING_PTR // "" + * %160 = MEMORY/STRLEN [%159] // __builtin_strlen("") + * %161 = CONST/INT32 0 // 0 + * %162 = CAST/SEXT_I32_I64 [%161] // 0 + * %163 = CMP_NE [%160, %162] // __builtin_strlen("") != 0 + * >> %164 = COND_BRANCH [%163] // if (__builtin_strlen("") != 0) return 11 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %170 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %171 = STRING_PTR // "abc" + * %172 = STRING_PTR // "abc" + * %173 = MEMORY/STRCMP [%171, %172] // __builtin_strcmp("abc", "abc") + * %174 = CONST/INT32 0 // 0 + * %175 = CMP_NE [%173, %174] // __builtin_strcmp("abc", "abc") != 0 + * >> %176 = COND_BRANCH [%175] // if (__builtin_strcmp("abc", "abc") != 0) return 12 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %182 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %183 = STRING_PTR // "abc" + * %184 = STRING_PTR // "abd" + * %185 = MEMORY/STRCMP [%183, %184] // __builtin_strcmp("abc", "abd") + * %186 = CONST/INT32 0 // 0 + * %187 = CMP_GE [%185, %186] // __builtin_strcmp("abc", "abd") >= 0 + * >> %188 = COND_BRANCH [%187] // if (__builtin_strcmp("abc", "abd") >= 0) return 13 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %194 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %195 = STRING_PTR // "abcXXX" + * %196 = STRING_PTR // "abcYYY" + * %197 = CONST/INT32 3 // 3 + * %198 = CAST/SEXT_I32_I64 [%197] // 3 + * %199 = MEMORY/STRNCMP [%195, %196, %198] // __builtin_strncmp("abcXXX", "abcYYY", 3) + * %200 = CONST/INT32 0 // 0 + * %201 = CMP_NE [%199, %200] // __builtin_strncmp("abcXXX", "abcYYY", 3) != 0 + * >> %202 = COND_BRANCH [%201] // if (__builtin_strncmp("abcXXX", "abcYYY", 3) !=... + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %208 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %sc.4 = ALLOCA/LOCAL size=8 align=8 + * %209 = STRING_PTR // "hello world" + * %210 = CONST/UINT8 119 // 'w' + * %211 = MEMORY/STRCHR [%209, %210] // __builtin_strchr("hello world", 'w') + * >> %sc.212 = MEMORY/STORE_LE_64 [%sc.4, %211] + * %213 = MEMORY/LOAD_LE_64 [%sc.4] // sc + * %214 = CONST/NULL_PTR // 0 + * %215 = CMP_EQ [%213, %214] // sc == 0 + * >> %216 = COND_BRANCH [%215] // if (sc == 0) return 15 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %222 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %dest2.5 = ALLOCA/LOCAL size=16 align=1 + * %223 = STRING_PTR // "test" + * >> %224 = MEMORY/STRCPY [%dest2.5, %223] // __builtin_strcpy(dest2, "test") + * %225 = CONST/INT32 0 // 0 + * %226 = PTR_ADD elem_size=1 [%dest2.5, %225] // dest2[0] + * %227 = MEMORY/LOAD_LE_8 [%226] // dest2[0] + * %228 = CAST/SEXT_I8_I32 [%227] // dest2[0] + * %229 = CONST/UINT8 116 // 't' + * %230 = CMP_NE [%228, %229] // dest2[0] != 't' + * >> %231 = COND_BRANCH [%230] // if (dest2[0] != 't') return 17 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %237 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %dest3.6 = ALLOCA/LOCAL size=32 align=1 + * %238 = STRING_PTR // "hello" + * %239 = CONST/UINT64 6 + * >> %dest3.240 = MEMORY/MEMCPY [%dest3.6, %238, %239] + * %241 = STRING_PTR // " world" + * >> %242 = MEMORY/STRCAT [%dest3.6, %241] // __builtin_strcat(dest3, " world") + * %243 = MEMORY/STRLEN [%dest3.6] // __builtin_strlen(dest3) + * %244 = CONST/INT32 11 // 11 + * %245 = CAST/SEXT_I32_I64 [%244] // 11 + * %246 = CMP_NE [%243, %245] // __builtin_strlen(dest3) != 11 + * >> %247 = COND_BRANCH [%246] // if (__builtin_strlen(dest3) != 11) return 18 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %253 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %255 = RETURN_PTR // return 0 + * %254 = CONST/INT32 0 // 0 + * >> %256 = MEMORY/STORE_LE_32 [%255, %254] // return 0 + * >> %257 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %258 = RET [%254] // return 0 + * block_47 IF_THEN <- [block_46]: + * %249 = RETURN_PTR // return 18 + * %248 = CONST/INT32 18 // 18 + * >> %250 = MEMORY/STORE_LE_32 [%249, %248] // return 18 + * >> %251 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %252 = RET [%248] // return 18 + * block_44 IF_THEN <- [block_43]: + * %233 = RETURN_PTR // return 17 + * %232 = CONST/INT32 17 // 17 + * >> %234 = MEMORY/STORE_LE_32 [%233, %232] // return 17 + * >> %235 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %236 = RET [%232] // return 17 + * block_41 IF_THEN <- [block_40]: + * %218 = RETURN_PTR // return 15 + * %217 = CONST/INT32 15 // 15 + * >> %219 = MEMORY/STORE_LE_32 [%218, %217] // return 15 + * >> %220 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %221 = RET [%217] // return 15 + * block_38 IF_THEN <- [block_37]: + * %204 = RETURN_PTR // return 14 + * %203 = CONST/INT32 14 // 14 + * >> %205 = MEMORY/STORE_LE_32 [%204, %203] // return 14 + * >> %206 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %207 = RET [%203] // return 14 + * block_35 IF_THEN <- [block_34]: + * %190 = RETURN_PTR // return 13 + * %189 = CONST/INT32 13 // 13 + * >> %191 = MEMORY/STORE_LE_32 [%190, %189] // return 13 + * >> %192 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %193 = RET [%189] // return 13 + * block_32 IF_THEN <- [block_31]: + * %178 = RETURN_PTR // return 12 + * %177 = CONST/INT32 12 // 12 + * >> %179 = MEMORY/STORE_LE_32 [%178, %177] // return 12 + * >> %180 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %181 = RET [%177] // return 12 + * block_29 IF_THEN <- [block_28]: + * %166 = RETURN_PTR // return 11 + * %165 = CONST/INT32 11 // 11 + * >> %167 = MEMORY/STORE_LE_32 [%166, %165] // return 11 + * >> %168 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %169 = RET [%165] // return 11 + * block_26 IF_THEN <- [block_25]: + * %154 = RETURN_PTR // return 10 + * %153 = CONST/INT32 10 // 10 + * >> %155 = MEMORY/STORE_LE_32 [%154, %153] // return 10 + * >> %156 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %157 = RET [%153] // return 10 + * block_23 IF_THEN <- [block_22]: + * %142 = RETURN_PTR // return 8 + * %141 = CONST/INT32 8 // 8 + * >> %143 = MEMORY/STORE_LE_32 [%142, %141] // return 8 + * >> %144 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %145 = RET [%141] // return 8 + * block_20 IF_THEN <- [block_19]: + * %126 = RETURN_PTR // return 7 + * %125 = CONST/INT32 7 // 7 + * >> %127 = MEMORY/STORE_LE_32 [%126, %125] // return 7 + * >> %128 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %129 = RET [%125] // return 7 + * block_17 IF_THEN <- [block_16]: + * %110 = RETURN_PTR // return 6 + * %109 = CONST/INT32 6 // 6 + * >> %111 = MEMORY/STORE_LE_32 [%110, %109] // return 6 + * >> %112 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %113 = RET [%109] // return 6 + * block_14 IF_THEN <- [block_13]: + * %97 = RETURN_PTR // return 5 + * %96 = CONST/INT32 5 // 5 + * >> %98 = MEMORY/STORE_LE_32 [%97, %96] // return 5 + * >> %99 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %100 = RET [%96] // return 5 + * block_11 IF_THEN <- [block_10]: + * %74 = RETURN_PTR // return 4 + * %73 = CONST/INT32 4 // 4 + * >> %75 = MEMORY/STORE_LE_32 [%74, %73] // return 4 + * >> %76 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %77 = RET [%73] // return 4 + * block_8 IF_THEN <- [block_7]: + * %61 = RETURN_PTR // return 3 + * %60 = CONST/INT32 3 // 3 + * >> %62 = MEMORY/STORE_LE_32 [%61, %60] // return 3 + * >> %63 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %64 = RET [%60] // return 3 + * block_5 IF_THEN <- [block_4]: + * %40 = RETURN_PTR // return 2 + * %39 = CONST/INT32 2 // 2 + * >> %41 = MEMORY/STORE_LE_32 [%40, %39] // return 2 + * >> %42 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %43 = RET [%39] // return 2 + * block_2 IF_THEN <- [block_1]: + * %27 = RETURN_PTR // return 1 + * %26 = CONST/INT32 1 // 1 + * >> %28 = MEMORY/STORE_LE_32 [%27, %26] // return 1 + * >> %29 = EXIT_SCOPE // { // memset. char buf[16]; __builti... + * >> %30 = RET [%26] // return 1 + * } + */ + + + + + + + + + + +typedef unsigned long size_t; + +int test_memory_ops(void) { + // memset. + char buf[16]; + __builtin_memset(buf, 'A', 10); + buf[10] = '\0'; + if (buf[0] != 'A') return 1; + if (buf[9] != 'A') return 2; + + // memcpy. + char src[] = "hello"; + char dst[16]; + __builtin_memcpy(dst, src, 6); + if (dst[0] != 'h') return 3; + if (dst[4] != 'o') return 4; + + // memmove (overlapping). + char overlap[] = "abcdefgh"; + __builtin_memmove(overlap + 2, overlap, 4); + if (overlap[2] != 'a') return 5; + if (overlap[5] != 'd') return 6; + + // memcmp. + if (__builtin_memcmp("abc", "abc", 3) != 0) return 7; + if (__builtin_memcmp("abc", "abd", 3) >= 0) return 8; + + // strlen. + if (__builtin_strlen("hello") != 5) return 10; + if (__builtin_strlen("") != 0) return 11; + + // strcmp. + if (__builtin_strcmp("abc", "abc") != 0) return 12; + if (__builtin_strcmp("abc", "abd") >= 0) return 13; + + // strncmp. + if (__builtin_strncmp("abcXXX", "abcYYY", 3) != 0) return 14; + + // strchr. + const char *sc = __builtin_strchr("hello world", 'w'); + if (sc == 0) return 15; + + // strcpy. + char dest2[16]; + __builtin_strcpy(dest2, "test"); + if (dest2[0] != 't') return 17; + + // strcat. + char dest3[32] = "hello"; + __builtin_strcat(dest3, " world"); + if (__builtin_strlen(dest3) != 11) return 18; + + return 0; +} diff --git a/tests/InterpretIR/test_overflow_exact.c b/tests/InterpretIR/test_overflow_exact.c new file mode 100644 index 000000000..af31c7556 --- /dev/null +++ b/tests/InterpretIR/test_overflow_exact.c @@ -0,0 +1,126 @@ +// Tests: exact overflow and truncation behavior at each integer width. +// These tests ONLY pass if arithmetic operates at the declared width. +// Using int64 arithmetic gives wrong results for every check. + +int test_overflow_exact(void) { + // --- ADD overflow --- + { + // int8: 100 + 100 = 200, wraps to -56 + signed char a = 100, b = 100; + signed char r = a + b; + if (r != -56) return 1; + + // int16: 30000 + 30000 = 60000, wraps to -5536 + short sa = 30000, sb = 30000; + short sr = sa + sb; + if (sr != -5536) return 2; + + // int32: 2000000000 + 2000000000 = 4000000000, wraps to -294967296 + int ia = 2000000000, ib = 2000000000; + int ir = ia + ib; + if (ir != -294967296) return 3; + } + + // --- SUB overflow --- + { + signed char a = -100, b = 100; + signed char r = a - b; + if (r != 56) return 10; // -200 wraps to 56 + + short sa = -30000, sb = 30000; + short sr = sa - sb; + if (sr != 5536) return 11; // -60000 wraps to 5536 + } + + // --- MUL overflow --- + { + signed char a = 16, b = 16; + signed char r = a * b; + if (r != 0) return 20; // 256 wraps to 0 in int8 + + signed char c = 15, d = 15; + signed char r2 = c * d; + if (r2 != -31) return 21; // 225 wraps to -31 + + short sa = 256, sb = 256; + short sr = sa * sb; + if (sr != 0) return 22; // 65536 wraps to 0 in int16 + } + + // --- SHL overflow --- + { + signed char a = 1; + signed char r = a << 7; + if (r != -128) return 30; // 128 wraps to -128 + + short sa = 1; + short sr = sa << 15; + if (sr != -32768) return 31; + + int ia = 1; + int ir = ia << 31; + if (ir != (-2147483647 - 1)) return 32; // INT_MIN + } + + // --- NEG overflow --- + { + signed char a = -128; + signed char r = -a; + if (r != -128) return 40; // -(-128) wraps to -128 in int8 + + short sa = -32768; + short sr = -sa; + if (sr != -32768) return 41; + } + + // --- Unsigned wrapping --- + { + unsigned char a = 255, b = 1; + unsigned char r = a + b; + if (r != 0) return 50; + + unsigned char c = 0, d = 1; + unsigned char r2 = c - d; + if (r2 != 255) return 51; + + unsigned short sa = 65535, sb = 1; + unsigned short sr = sa + sb; + if (sr != 0) return 52; + + unsigned int ia = 0xFFFFFFFFu, ib = 1; + unsigned int ir = ia + ib; + if (ir != 0) return 53; + } + + // --- BIT_NOT width --- + { + signed char a = 0; + signed char r = ~a; + if (r != -1) return 60; + + unsigned char ua = 0; + unsigned char ur = ~ua; + if (ur != 255) return 61; + + short sa = 0; + short sr = ~sa; + if (sr != -1) return 62; + } + + // --- Shift masking --- + { + // SHL_8: shift amount masked to 0-7 + signed char a = 1; + // In C, shifting by >= width is UB, but our IR should mask. + // Test within valid range but near boundary. + signed char r = a << 7; + if (r != -128) return 70; + + // SHR_8: arithmetic shift preserves sign + signed char b = -1; + signed char r2 = b >> 7; + if (r2 != -1) return 71; // all 1s, arithmetic shift fills with 1 + } + + return 0; +} diff --git a/tests/InterpretIR/test_pointers.c b/tests/InterpretIR/test_pointers.c new file mode 100644 index 000000000..0738d637c --- /dev/null +++ b/tests/InterpretIR/test_pointers.c @@ -0,0 +1,485 @@ +// Tests: pointer arithmetic (PTR_ADD, PTR_DIFF), pointer increment/decrement +// (RMW with PTR_ADD), pointer compound assignment (ptr += n, ptr -= n), +// array subscript, dereferencing, address-of (ALLOCA as pointer), +// GEP_FIELD for struct member access. + +/* + * Expected IR: + * + * function test_pointers (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=20 align=4 (arr) + * obj_1 LOCAL_VALUE size=8 align=8 (p) + * obj_2 LOCAL_VALUE size=8 align=8 (q) + * obj_3 LOCAL_VALUE size=8 align=8 (diff) + * obj_4 LOCAL_VALUE size=8 align=8 (r) + * obj_5 LOCAL_VALUE size=8 align=8 (s) + * obj_6 LOCAL size=8 align=4 (pt) + * obj_7 LOCAL_VALUE size=8 align=8 (pp) + * obj_8 LOCAL_VALUE size=8 align=8 (lo) + * obj_9 LOCAL_VALUE size=8 align=8 (hi) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %arr.0 = ALLOCA/LOCAL size=20 align=4 + * >> %p.1 = ALLOCA/LOCAL size=8 align=8 + * >> %q.2 = ALLOCA/LOCAL size=8 align=8 + * >> %diff.3 = ALLOCA/LOCAL size=8 align=8 + * >> %r.4 = ALLOCA/LOCAL size=8 align=8 + * >> %s.5 = ALLOCA/LOCAL size=8 align=8 + * >> %pt.6 = ALLOCA/LOCAL size=8 align=4 + * >> %pp.7 = ALLOCA/LOCAL size=8 align=8 + * >> %lo.8 = ALLOCA/LOCAL size=8 align=8 + * >> %hi.9 = ALLOCA/LOCAL size=8 align=8 + * >> %10 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %11 = ENTER_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * %arr.12 = CONST/UINT8 0 + * %arr.13 = CONST/UINT64 20 + * >> %arr.14 = MEMORY/MEMSET [%arr.0, %arr.12, %arr.13] + * %15 = CONST/INT32 10 // 10 + * >> %arr.16 = MEMORY/STORE_LE_32 [%arr.0, %15] + * %arr.17 = CONST/INT64 1 + * %arr.18 = PTR_ADD elem_size=4 [%arr.0, %arr.17] + * %19 = CONST/INT32 20 // 20 + * >> %arr.20 = MEMORY/STORE_LE_32 [%arr.18, %19] + * %arr.21 = CONST/INT64 2 + * %arr.22 = PTR_ADD elem_size=4 [%arr.0, %arr.21] + * %23 = CONST/INT32 30 // 30 + * >> %arr.24 = MEMORY/STORE_LE_32 [%arr.22, %23] + * %arr.25 = CONST/INT64 3 + * %arr.26 = PTR_ADD elem_size=4 [%arr.0, %arr.25] + * %27 = CONST/INT32 40 // 40 + * >> %arr.28 = MEMORY/STORE_LE_32 [%arr.26, %27] + * %arr.29 = CONST/INT64 4 + * %arr.30 = PTR_ADD elem_size=4 [%arr.0, %arr.29] + * %31 = CONST/INT32 50 // 50 + * >> %arr.32 = MEMORY/STORE_LE_32 [%arr.30, %31] + * %33 = CONST/INT32 0 // 0 + * %34 = PTR_ADD elem_size=4 [%arr.0, %33] // arr[0] + * %35 = MEMORY/LOAD_LE_32 [%34] // arr[0] + * %36 = CONST/INT32 10 // 10 + * %37 = CMP_NE [%35, %36] // arr[0] != 10 + * >> %38 = COND_BRANCH [%37] // if (arr[0] != 10) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %44 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * %45 = CONST/INT32 4 // 4 + * %46 = PTR_ADD elem_size=4 [%arr.0, %45] // arr[4] + * %47 = MEMORY/LOAD_LE_32 [%46] // arr[4] + * %48 = CONST/INT32 50 // 50 + * %49 = CMP_NE [%47, %48] // arr[4] != 50 + * >> %50 = COND_BRANCH [%49] // if (arr[4] != 50) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %56 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %p.1 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * >> %p.57 = MEMORY/STORE_LE_64 [%p.1, %arr.0] + * %58 = MEMORY/LOAD_LE_64 [%p.1] // p + * %59 = CONST/INT32 2 // 2 + * %60 = PTR_ADD elem_size=4 [%58, %59] // p + 2 + * >> %61 = MEMORY/STORE_LE_64 [%p.1, %60] // p = p + 2 + * %62 = MEMORY/LOAD_LE_64 [%p.1] // p + * %63 = MEMORY/LOAD_LE_32 [%62] // *p + * %64 = CONST/INT32 30 // 30 + * %65 = CMP_NE [%63, %64] // *p != 30 + * >> %66 = COND_BRANCH [%65] // if (*p != 30) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %72 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %q.2 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * %73 = CONST/INT32 4 // 4 + * %74 = PTR_ADD elem_size=4 [%arr.0, %73] // arr[4] + * >> %q.75 = MEMORY/STORE_LE_64 [%q.2, %74] + * %diff.3 = ALLOCA/LOCAL size=8 align=8 + * %76 = MEMORY/LOAD_LE_64 [%q.2] // q + * %p.1 = ALLOCA/LOCAL size=8 align=8 + * %77 = MEMORY/LOAD_LE_64 [%p.1] // p + * %78 = PTR_DIFF [%76, %77] // q - p + * >> %diff.79 = MEMORY/STORE_LE_64 [%diff.3, %78] + * %80 = MEMORY/LOAD_LE_64 [%diff.3] // diff + * %81 = CONST/INT32 2 // 2 + * %82 = CAST/SEXT_I32_I64 [%81] // 2 + * %83 = CMP_NE [%80, %82] // diff != 2 + * >> %84 = COND_BRANCH [%83] // if (diff != 2) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %90 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %r.4 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * >> %r.91 = MEMORY/STORE_LE_64 [%r.4, %arr.0] + * %92 = CONST/INT64 1 // r++ + * >> %93 = READ_MODIFY_WRITE(PTR_ADD old) [%r.4, %92] // r++ + * %94 = MEMORY/LOAD_LE_64 [%r.4] // r + * %95 = MEMORY/LOAD_LE_32 [%94] // *r + * %96 = CONST/INT32 20 // 20 + * %97 = CMP_NE [%95, %96] // *r != 20 + * >> %98 = COND_BRANCH [%97] // if (*r != 20) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %104 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %r.4 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * %105 = CONST/INT32 3 // 3 + * %106 = PTR_ADD elem_size=4 [%arr.0, %105] // arr[3] + * >> %107 = MEMORY/STORE_LE_64 [%r.4, %106] // r = &arr[3] + * %108 = CONST/INT64 -1 // r-- + * >> %109 = READ_MODIFY_WRITE(PTR_ADD old) [%r.4, %108] // r-- + * %110 = MEMORY/LOAD_LE_64 [%r.4] // r + * %111 = MEMORY/LOAD_LE_32 [%110] // *r + * %112 = CONST/INT32 30 // 30 + * %113 = CMP_NE [%111, %112] // *r != 30 + * >> %114 = COND_BRANCH [%113] // if (*r != 30) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %120 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %s.5 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * >> %s.121 = MEMORY/STORE_LE_64 [%s.5, %arr.0] + * %122 = CONST/INT32 3 // 3 + * >> %123 = READ_MODIFY_WRITE(PTR_ADD new) [%s.5, %122] // s += 3 + * %124 = MEMORY/LOAD_LE_64 [%s.5] // s + * %125 = MEMORY/LOAD_LE_32 [%124] // *s + * %126 = CONST/INT32 40 // 40 + * %127 = CMP_NE [%125, %126] // *s != 40 + * >> %128 = COND_BRANCH [%127] // if (*s != 40) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %134 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %s.5 = ALLOCA/LOCAL size=8 align=8 + * %135 = CONST/INT32 2 // 2 + * %136 = NEG [%135] // s -= 2 + * >> %137 = READ_MODIFY_WRITE(PTR_ADD new) [%s.5, %136] // s -= 2 + * %138 = MEMORY/LOAD_LE_64 [%s.5] // s + * %139 = MEMORY/LOAD_LE_32 [%138] // *s + * %140 = CONST/INT32 20 // 20 + * %141 = CMP_NE [%139, %140] // *s != 20 + * >> %142 = COND_BRANCH [%141] // if (*s != 20) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %148 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %pt.6 = ALLOCA/LOCAL size=8 align=4 + * %149 = GEP_FIELD offset=0 .x [%pt.6] // pt.x + * %150 = CONST/INT32 100 // 100 + * >> %151 = MEMORY/STORE_LE_32 [%149, %150] // pt.x = 100 + * %152 = GEP_FIELD offset=4 .y [%pt.6] // pt.y + * %153 = CONST/INT32 200 // 200 + * >> %154 = MEMORY/STORE_LE_32 [%152, %153] // pt.y = 200 + * %155 = GEP_FIELD offset=0 .x [%pt.6] // pt.x + * %156 = MEMORY/LOAD_LE_32 [%155] // pt.x + * %157 = CONST/INT32 100 // 100 + * %158 = CMP_NE [%156, %157] // pt.x != 100 + * >> %159 = COND_BRANCH [%158] // if (pt.x != 100) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %165 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %pt.6 = ALLOCA/LOCAL size=8 align=4 + * %166 = GEP_FIELD offset=4 .y [%pt.6] // pt.y + * %167 = MEMORY/LOAD_LE_32 [%166] // pt.y + * %168 = CONST/INT32 200 // 200 + * %169 = CMP_NE [%167, %168] // pt.y != 200 + * >> %170 = COND_BRANCH [%169] // if (pt.y != 200) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %176 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %pp.7 = ALLOCA/LOCAL size=8 align=8 + * %pt.6 = ALLOCA/LOCAL size=8 align=4 + * >> %pp.177 = MEMORY/STORE_LE_64 [%pp.7, %pt.6] + * %178 = MEMORY/LOAD_LE_64 [%pp.7] // pp + * %179 = GEP_FIELD offset=0 .x [%178] // pp->x + * %180 = CONST/INT32 300 // 300 + * >> %181 = MEMORY/STORE_LE_32 [%179, %180] // pp->x = 300 + * %182 = GEP_FIELD offset=0 .x [%pt.6] // pt.x + * %183 = MEMORY/LOAD_LE_32 [%182] // pt.x + * %184 = CONST/INT32 300 // 300 + * %185 = CMP_NE [%183, %184] // pt.x != 300 + * >> %186 = COND_BRANCH [%185] // if (pt.x != 300) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %192 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %lo.8 = ALLOCA/LOCAL size=8 align=8 + * %arr.0 = ALLOCA/LOCAL size=20 align=4 + * %193 = CONST/INT32 0 // 0 + * %194 = PTR_ADD elem_size=4 [%arr.0, %193] // arr[0] + * >> %lo.195 = MEMORY/STORE_LE_64 [%lo.8, %194] + * %hi.9 = ALLOCA/LOCAL size=8 align=8 + * %196 = CONST/INT32 4 // 4 + * %197 = PTR_ADD elem_size=4 [%arr.0, %196] // arr[4] + * >> %hi.198 = MEMORY/STORE_LE_64 [%hi.9, %197] + * %199 = MEMORY/LOAD_LE_64 [%hi.9] // hi + * %200 = MEMORY/LOAD_LE_64 [%lo.8] // lo + * %201 = UCMP_GT [%199, %200] // hi > lo + * %202 = LOGICAL_NOT [%201] // !(hi > lo) + * >> %203 = COND_BRANCH [%202] // if (!(hi > lo)) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %209 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %hi.9 = ALLOCA/LOCAL size=8 align=8 + * %210 = MEMORY/LOAD_LE_64 [%hi.9] // hi + * %lo.8 = ALLOCA/LOCAL size=8 align=8 + * %211 = MEMORY/LOAD_LE_64 [%lo.8] // lo + * %212 = UCMP_LT [%210, %211] // hi < lo + * >> %213 = COND_BRANCH [%212] // if (hi < lo) return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %219 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %hi.9 = ALLOCA/LOCAL size=8 align=8 + * %220 = MEMORY/LOAD_LE_64 [%hi.9] // hi + * %lo.8 = ALLOCA/LOCAL size=8 align=8 + * %221 = MEMORY/LOAD_LE_64 [%lo.8] // lo + * %222 = UCMP_LE [%220, %221] // hi <= lo + * >> %223 = COND_BRANCH [%222] // if (hi <= lo) return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %229 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %hi.9 = ALLOCA/LOCAL size=8 align=8 + * %230 = MEMORY/LOAD_LE_64 [%hi.9] // hi + * %lo.8 = ALLOCA/LOCAL size=8 align=8 + * %231 = MEMORY/LOAD_LE_64 [%lo.8] // lo + * %232 = UCMP_GE [%230, %231] // hi >= lo + * %233 = LOGICAL_NOT [%232] // !(hi >= lo) + * >> %234 = COND_BRANCH [%233] // if (!(hi >= lo)) return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %240 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %lo.8 = ALLOCA/LOCAL size=8 align=8 + * %241 = MEMORY/LOAD_LE_64 [%lo.8] // lo + * %hi.9 = ALLOCA/LOCAL size=8 align=8 + * %242 = MEMORY/LOAD_LE_64 [%hi.9] // hi + * %243 = UCMP_GT [%241, %242] // lo > hi + * >> %244 = COND_BRANCH [%243] // if (lo > hi) return 16 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %250 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %lo.8 = ALLOCA/LOCAL size=8 align=8 + * %251 = MEMORY/LOAD_LE_64 [%lo.8] // lo + * %hi.9 = ALLOCA/LOCAL size=8 align=8 + * %252 = MEMORY/LOAD_LE_64 [%hi.9] // hi + * %253 = UCMP_LT [%251, %252] // lo < hi + * %254 = LOGICAL_NOT [%253] // !(lo < hi) + * >> %255 = COND_BRANCH [%254] // if (!(lo < hi)) return 17 + * -> [block_50, block_51] + * block_51 IF_ELSE <- [block_49]: + * >> %261 = IMPLICIT_GOTO + * -> [block_52] + * block_52 IF_MERGE <- [block_51]: + * %263 = RETURN_PTR // return 0 + * %262 = CONST/INT32 0 // 0 + * >> %264 = MEMORY/STORE_LE_32 [%263, %262] // return 0 + * >> %265 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %266 = RET [%262] // return 0 + * block_50 IF_THEN <- [block_49]: + * %257 = RETURN_PTR // return 17 + * %256 = CONST/INT32 17 // 17 + * >> %258 = MEMORY/STORE_LE_32 [%257, %256] // return 17 + * >> %259 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %260 = RET [%256] // return 17 + * block_47 IF_THEN <- [block_46]: + * %246 = RETURN_PTR // return 16 + * %245 = CONST/INT32 16 // 16 + * >> %247 = MEMORY/STORE_LE_32 [%246, %245] // return 16 + * >> %248 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %249 = RET [%245] // return 16 + * block_44 IF_THEN <- [block_43]: + * %236 = RETURN_PTR // return 15 + * %235 = CONST/INT32 15 // 15 + * >> %237 = MEMORY/STORE_LE_32 [%236, %235] // return 15 + * >> %238 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %239 = RET [%235] // return 15 + * block_41 IF_THEN <- [block_40]: + * %225 = RETURN_PTR // return 14 + * %224 = CONST/INT32 14 // 14 + * >> %226 = MEMORY/STORE_LE_32 [%225, %224] // return 14 + * >> %227 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %228 = RET [%224] // return 14 + * block_38 IF_THEN <- [block_37]: + * %215 = RETURN_PTR // return 13 + * %214 = CONST/INT32 13 // 13 + * >> %216 = MEMORY/STORE_LE_32 [%215, %214] // return 13 + * >> %217 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %218 = RET [%214] // return 13 + * block_35 IF_THEN <- [block_34]: + * %205 = RETURN_PTR // return 12 + * %204 = CONST/INT32 12 // 12 + * >> %206 = MEMORY/STORE_LE_32 [%205, %204] // return 12 + * >> %207 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %208 = RET [%204] // return 12 + * block_32 IF_THEN <- [block_31]: + * %188 = RETURN_PTR // return 11 + * %187 = CONST/INT32 11 // 11 + * >> %189 = MEMORY/STORE_LE_32 [%188, %187] // return 11 + * >> %190 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %191 = RET [%187] // return 11 + * block_29 IF_THEN <- [block_28]: + * %172 = RETURN_PTR // return 10 + * %171 = CONST/INT32 10 // 10 + * >> %173 = MEMORY/STORE_LE_32 [%172, %171] // return 10 + * >> %174 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %175 = RET [%171] // return 10 + * block_26 IF_THEN <- [block_25]: + * %161 = RETURN_PTR // return 9 + * %160 = CONST/INT32 9 // 9 + * >> %162 = MEMORY/STORE_LE_32 [%161, %160] // return 9 + * >> %163 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %164 = RET [%160] // return 9 + * block_23 IF_THEN <- [block_22]: + * %144 = RETURN_PTR // return 8 + * %143 = CONST/INT32 8 // 8 + * >> %145 = MEMORY/STORE_LE_32 [%144, %143] // return 8 + * >> %146 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %147 = RET [%143] // return 8 + * block_20 IF_THEN <- [block_19]: + * %130 = RETURN_PTR // return 7 + * %129 = CONST/INT32 7 // 7 + * >> %131 = MEMORY/STORE_LE_32 [%130, %129] // return 7 + * >> %132 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %133 = RET [%129] // return 7 + * block_17 IF_THEN <- [block_16]: + * %116 = RETURN_PTR // return 6 + * %115 = CONST/INT32 6 // 6 + * >> %117 = MEMORY/STORE_LE_32 [%116, %115] // return 6 + * >> %118 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %119 = RET [%115] // return 6 + * block_14 IF_THEN <- [block_13]: + * %100 = RETURN_PTR // return 5 + * %99 = CONST/INT32 5 // 5 + * >> %101 = MEMORY/STORE_LE_32 [%100, %99] // return 5 + * >> %102 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %103 = RET [%99] // return 5 + * block_11 IF_THEN <- [block_10]: + * %86 = RETURN_PTR // return 4 + * %85 = CONST/INT32 4 // 4 + * >> %87 = MEMORY/STORE_LE_32 [%86, %85] // return 4 + * >> %88 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %89 = RET [%85] // return 4 + * block_8 IF_THEN <- [block_7]: + * %68 = RETURN_PTR // return 3 + * %67 = CONST/INT32 3 // 3 + * >> %69 = MEMORY/STORE_LE_32 [%68, %67] // return 3 + * >> %70 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %71 = RET [%67] // return 3 + * block_5 IF_THEN <- [block_4]: + * %52 = RETURN_PTR // return 2 + * %51 = CONST/INT32 2 // 2 + * >> %53 = MEMORY/STORE_LE_32 [%52, %51] // return 2 + * >> %54 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %55 = RET [%51] // return 2 + * block_2 IF_THEN <- [block_1]: + * %40 = RETURN_PTR // return 1 + * %39 = CONST/INT32 1 // 1 + * >> %41 = MEMORY/STORE_LE_32 [%40, %39] // return 1 + * >> %42 = EXIT_SCOPE // { int arr[5] = {10, 20, 30, 40, 50}; /... + * >> %43 = RET [%39] // return 1 + * } + */ + + + + + + + + + + +struct Point { + int x; + int y; +}; + +int test_pointers(void) { + int arr[5] = {10, 20, 30, 40, 50}; + + // Array subscript. + if (arr[0] != 10) return 1; + if (arr[4] != 50) return 2; + + // Pointer arithmetic. + int *p = arr; + p = p + 2; + if (*p != 30) return 3; + + // Pointer subtraction. + int *q = &arr[4]; + long diff = q - p; + if (diff != 2) return 4; + + // Pointer increment. + int *r = arr; + r++; + if (*r != 20) return 5; + + // Pointer decrement. + r = &arr[3]; + r--; + if (*r != 30) return 6; + + // Pointer compound assignment. + int *s = arr; + s += 3; + if (*s != 40) return 7; + s -= 2; + if (*s != 20) return 8; + + // Struct member access (GEP_FIELD). + struct Point pt; + pt.x = 100; + pt.y = 200; + if (pt.x != 100) return 9; + if (pt.y != 200) return 10; + + // Pointer to struct member. + struct Point *pp = &pt; + pp->x = 300; + if (pt.x != 300) return 11; + + // Pointer ordered comparisons (must use unsigned semantics). + int *lo = &arr[0]; + int *hi = &arr[4]; + if (!(hi > lo)) return 12; // hi > lo + if (hi < lo) return 13; // !(hi < lo) + if (hi <= lo) return 14; // !(hi <= lo) + if (!(hi >= lo)) return 15; // hi >= lo + if (lo > hi) return 16; // !(lo > hi) + if (!(lo < hi)) return 17; // lo < hi + + return 0; +} diff --git a/tests/InterpretIR/test_scopes.c b/tests/InterpretIR/test_scopes.c new file mode 100644 index 000000000..30c3af8f4 --- /dev/null +++ b/tests/InterpretIR/test_scopes.c @@ -0,0 +1,352 @@ +// Tests: scope tracking (ENTER_SCOPE, EXIT_SCOPE), nested scopes, +// for-init implicit scope, variable lifetime, compound statements, +// and GNU block expressions ({ ... }). + +/* + * Expected IR: + * + * function test_scopes (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (result) + * obj_1 LOCAL_VALUE size=4 align=4 (x) + * obj_2 LOCAL_VALUE size=4 align=4 (x) + * obj_3 LOCAL_VALUE size=4 align=4 (sum) + * obj_4 LOCAL_VALUE size=4 align=4 (i) + * obj_5 LOCAL_VALUE size=4 align=4 (total) + * obj_6 LOCAL_VALUE size=4 align=4 (i) + * obj_7 LOCAL_VALUE size=4 align=4 (i) + * obj_8 LOCAL_VALUE size=4 align=4 (x) + * obj_9 LOCAL_VALUE size=4 align=4 (y) + * obj_10 LOCAL_VALUE size=4 align=4 (block_val) + * obj_11 LOCAL_VALUE size=4 align=4 (a) + * obj_12 LOCAL_VALUE size=4 align=4 (b) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %result.0 = ALLOCA/LOCAL size=4 align=4 + * >> %x.1 = ALLOCA/LOCAL size=4 align=4 + * >> %x.2 = ALLOCA/LOCAL size=4 align=4 + * >> %sum.3 = ALLOCA/LOCAL size=4 align=4 + * >> %i.4 = ALLOCA/LOCAL size=4 align=4 + * >> %total.5 = ALLOCA/LOCAL size=4 align=4 + * >> %i.6 = ALLOCA/LOCAL size=4 align=4 + * >> %i.7 = ALLOCA/LOCAL size=4 align=4 + * >> %x.8 = ALLOCA/LOCAL size=4 align=4 + * >> %y.9 = ALLOCA/LOCAL size=4 align=4 + * >> %block_val.10 = ALLOCA/LOCAL size=4 align=4 + * >> %a.11 = ALLOCA/LOCAL size=4 align=4 + * >> %b.12 = ALLOCA/LOCAL size=4 align=4 + * >> %13 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %14 = ENTER_SCOPE // { int result = 0; // Nested scopes wit... + * %result.0 = ALLOCA/LOCAL size=4 align=4 + * %15 = CONST/INT32 0 // 0 + * >> %result.16 = MEMORY/STORE_LE_32 [%result.0, %15] + * >> %17 = ENTER_SCOPE // { int x = 10; result += x; } + * %x.1 = ALLOCA/LOCAL size=4 align=4 + * %18 = CONST/INT32 10 // 10 + * >> %x.19 = MEMORY/STORE_LE_32 [%x.1, %18] + * %20 = MEMORY/LOAD_LE_32 [%x.1] // x + * >> %21 = READ_MODIFY_WRITE(ADD new) [%result.0, %20] // result += x + * >> %22 = EXIT_SCOPE // { int x = 10; result += x; } + * >> %23 = ENTER_SCOPE // { int x = 20; result += x; } + * %x.2 = ALLOCA/LOCAL size=4 align=4 + * %24 = CONST/INT32 20 // 20 + * >> %x.25 = MEMORY/STORE_LE_32 [%x.2, %24] + * %26 = MEMORY/LOAD_LE_32 [%x.2] // x + * >> %27 = READ_MODIFY_WRITE(ADD new) [%result.0, %26] // result += x + * >> %28 = EXIT_SCOPE // { int x = 20; result += x; } + * %29 = MEMORY/LOAD_LE_32 [%result.0] // result + * %30 = CONST/INT32 30 // 30 + * %31 = CMP_NE [%29, %30] // result != 30 + * >> %32 = COND_BRANCH [%31] // if (result != 30) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %38 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %sum.3 = ALLOCA/LOCAL size=4 align=4 + * %39 = CONST/INT32 0 // 0 + * >> %sum.40 = MEMORY/STORE_LE_32 [%sum.3, %39] + * >> %41 = ENTER_SCOPE // for (int i = 0; i < 5; i++) { sum += i;... + * >> %42 = IMPLICIT_GOTO + * -> [block_5] + * block_5 LOOP_PREHEADER <- [block_4]: + * %i.4 = ALLOCA/LOCAL size=4 align=4 + * %43 = CONST/INT32 0 // 0 + * >> %i.44 = MEMORY/STORE_LE_32 [%i.4, %43] + * >> %45 = IMPLICIT_GOTO + * -> [block_6] + * block_6 LOOP_CONDITION <- [block_5, block_8]: + * %i.4 = ALLOCA/LOCAL size=4 align=4 + * %46 = MEMORY/LOAD_LE_32 [%i.4] // i + * %47 = CONST/INT32 5 // 5 + * %48 = CMP_LT [%46, %47] // i < 5 + * >> %49 = COND_BRANCH [%48] // for (int i = 0; i < 5; i++) { sum += i;... + * -> [block_7, block_9] + * block_9 LOOP_EXIT <- [block_6]: + * >> %58 = EXIT_SCOPE // for (int i = 0; i < 5; i++) { sum += i;... + * %sum.3 = ALLOCA/LOCAL size=4 align=4 + * %59 = MEMORY/LOAD_LE_32 [%sum.3] // sum + * %60 = CONST/INT32 10 // 10 + * %61 = CMP_NE [%59, %60] // sum != 10 + * >> %62 = COND_BRANCH [%61] // if (sum != 10) return 2 + * -> [block_10, block_11] + * block_11 IF_ELSE <- [block_9]: + * >> %68 = IMPLICIT_GOTO + * -> [block_12] + * block_12 IF_MERGE <- [block_11]: + * %total.5 = ALLOCA/LOCAL size=4 align=4 + * %69 = CONST/INT32 0 // 0 + * >> %total.70 = MEMORY/STORE_LE_32 [%total.5, %69] + * >> %71 = ENTER_SCOPE // for (int i = 0; i < 3; i++) { for (int ... + * >> %72 = IMPLICIT_GOTO + * -> [block_13] + * block_13 LOOP_PREHEADER <- [block_12]: + * %i.6 = ALLOCA/LOCAL size=4 align=4 + * %73 = CONST/INT32 0 // 0 + * >> %i.74 = MEMORY/STORE_LE_32 [%i.6, %73] + * >> %75 = IMPLICIT_GOTO + * -> [block_14] + * block_14 LOOP_CONDITION <- [block_13, block_16]: + * %i.6 = ALLOCA/LOCAL size=4 align=4 + * %76 = MEMORY/LOAD_LE_32 [%i.6] // i + * %77 = CONST/INT32 3 // 3 + * %78 = CMP_LT [%76, %77] // i < 3 + * >> %79 = COND_BRANCH [%78] // for (int i = 0; i < 3; i++) { for (int ... + * -> [block_15, block_17] + * block_17 LOOP_EXIT <- [block_14]: + * >> %104 = EXIT_SCOPE // for (int i = 0; i < 3; i++) { for (int ... + * %total.5 = ALLOCA/LOCAL size=4 align=4 + * %105 = MEMORY/LOAD_LE_32 [%total.5] // total + * %106 = CONST/INT32 6 // 6 + * %107 = CMP_NE [%105, %106] // total != 6 + * >> %108 = COND_BRANCH [%107] // if (total != 6) return 3 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_17]: + * >> %114 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * >> %115 = ENTER_SCOPE // { int x = 42; if (x == 42) { ... + * %x.8 = ALLOCA/LOCAL size=4 align=4 + * %116 = CONST/INT32 42 // 42 + * >> %x.117 = MEMORY/STORE_LE_32 [%x.8, %116] + * %118 = MEMORY/LOAD_LE_32 [%x.8] // x + * %119 = CONST/INT32 42 // 42 + * %120 = CMP_EQ [%118, %119] // x == 42 + * >> %121 = COND_BRANCH [%120] // if (x == 42) { // All paths in this... + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %144 = IMPLICIT_GOTO + * -> [block_31] + * block_26 IF_THEN <- [block_25]: + * >> %122 = ENTER_SCOPE // { // All paths in this scope return... + * >> %123 = ENTER_SCOPE // { int y = x + 1; ... + * %y.9 = ALLOCA/LOCAL size=4 align=4 + * %x.8 = ALLOCA/LOCAL size=4 align=4 + * %124 = MEMORY/LOAD_LE_32 [%x.8] // x + * %125 = CONST/INT32 1 // 1 + * %126 = ADD [%124, %125] // x + 1 + * >> %y.127 = MEMORY/STORE_LE_32 [%y.9, %126] + * %128 = MEMORY/LOAD_LE_32 [%y.9] // y + * %129 = CONST/INT32 43 // 43 + * %130 = CMP_NE [%128, %129] // y != 43 + * >> %131 = COND_BRANCH [%130] // if (y != 43) return 5 + * -> [block_28, block_29] + * block_29 IF_ELSE <- [block_26]: + * >> %140 = IMPLICIT_GOTO + * -> [block_30] + * block_30 IF_MERGE <- [block_29]: + * >> %141 = EXIT_SCOPE // { int y = x + 1; ... + * >> %142 = EXIT_SCOPE // { // All paths in this scope return... + * >> %143 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30, block_27]: + * >> %145 = EXIT_SCOPE // { int x = 42; if (x == 42) { ... + * >> %146 = ENTER_SCOPE // { int a = 5; int b = 7; ... + * %a.11 = ALLOCA/LOCAL size=4 align=4 + * %147 = CONST/INT32 5 // 5 + * >> %a.148 = MEMORY/STORE_LE_32 [%a.11, %147] + * %b.12 = ALLOCA/LOCAL size=4 align=4 + * %149 = CONST/INT32 7 // 7 + * >> %b.150 = MEMORY/STORE_LE_32 [%b.12, %149] + * >> %154 = EXIT_SCOPE // { int a = 5; int b = 7; ... + * %block_val.10 = ALLOCA/LOCAL size=4 align=4 + * %151 = MEMORY/LOAD_LE_32 [%a.11] // a + * %152 = MEMORY/LOAD_LE_32 [%b.12] // b + * %153 = ADD [%151, %152] // a + b + * >> %block_val.155 = MEMORY/STORE_LE_32 [%block_val.10, %153] + * %156 = MEMORY/LOAD_LE_32 [%block_val.10] // block_val + * %157 = CONST/INT32 12 // 12 + * %158 = CMP_NE [%156, %157] // block_val != 12 + * >> %159 = COND_BRANCH [%158] // if (block_val != 12) return 4 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %165 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %167 = RETURN_PTR // return 0 + * %166 = CONST/INT32 0 // 0 + * >> %168 = MEMORY/STORE_LE_32 [%167, %166] // return 0 + * >> %169 = EXIT_SCOPE // { int result = 0; // Nested scopes wit... + * >> %170 = RET [%166] // return 0 + * block_32 IF_THEN <- [block_31]: + * %161 = RETURN_PTR // return 4 + * %160 = CONST/INT32 4 // 4 + * >> %162 = MEMORY/STORE_LE_32 [%161, %160] // return 4 + * >> %163 = EXIT_SCOPE // { int result = 0; // Nested scopes wit... + * >> %164 = RET [%160] // return 4 + * block_28 IF_THEN <- [block_26]: + * %133 = RETURN_PTR // return 5 + * %132 = CONST/INT32 5 // 5 + * >> %134 = MEMORY/STORE_LE_32 [%133, %132] // return 5 + * >> %135 = EXIT_SCOPE // { int y = x + 1; ... + * >> %136 = EXIT_SCOPE // { // All paths in this scope return... + * >> %137 = EXIT_SCOPE // { int x = 42; if (x == 42) { ... + * >> %138 = EXIT_SCOPE // { int result = 0; // Nested scopes wit... + * >> %139 = RET [%132] // return 5 + * block_23 IF_THEN <- [block_17]: + * %110 = RETURN_PTR // return 3 + * %109 = CONST/INT32 3 // 3 + * >> %111 = MEMORY/STORE_LE_32 [%110, %109] // return 3 + * >> %112 = EXIT_SCOPE // { int result = 0; // Nested scopes wit... + * >> %113 = RET [%109] // return 3 + * block_15 LOOP_BODY <- [block_14]: + * >> %80 = ENTER_SCOPE // { for (int i = 0; i < 2; i++) { ... + * >> %81 = ENTER_SCOPE // for (int i = 0; i < 2; i++) { total... + * >> %82 = IMPLICIT_GOTO + * -> [block_18] + * block_18 LOOP_PREHEADER <- [block_15]: + * %i.7 = ALLOCA/LOCAL size=4 align=4 + * %83 = CONST/INT32 0 // 0 + * >> %i.84 = MEMORY/STORE_LE_32 [%i.7, %83] + * >> %85 = IMPLICIT_GOTO + * -> [block_19] + * block_19 LOOP_CONDITION <- [block_18, block_21]: + * %i.7 = ALLOCA/LOCAL size=4 align=4 + * %86 = MEMORY/LOAD_LE_32 [%i.7] // i + * %87 = CONST/INT32 2 // 2 + * %88 = CMP_LT [%86, %87] // i < 2 + * >> %89 = COND_BRANCH [%88] // for (int i = 0; i < 2; i++) { total... + * -> [block_20, block_22] + * block_22 LOOP_EXIT <- [block_19]: + * >> %98 = EXIT_SCOPE // for (int i = 0; i < 2; i++) { total... + * >> %99 = EXIT_SCOPE // { for (int i = 0; i < 2; i++) { ... + * >> %100 = IMPLICIT_GOTO + * -> [block_16] + * block_16 LOOP_INCREMENT <- [block_22]: + * %i.6 = ALLOCA/LOCAL size=4 align=4 + * %101 = CONST/INT32 1 // i++ + * >> %102 = READ_MODIFY_WRITE(ADD old) [%i.6, %101] // i++ + * >> %103 = IMPLICIT_GOTO + * -> [block_14] + * block_20 LOOP_BODY <- [block_19]: + * >> %90 = ENTER_SCOPE // { total++; } + * %total.5 = ALLOCA/LOCAL size=4 align=4 + * %91 = CONST/INT32 1 // total++ + * >> %92 = READ_MODIFY_WRITE(ADD old) [%total.5, %91] // total++ + * >> %93 = EXIT_SCOPE // { total++; } + * >> %94 = IMPLICIT_GOTO + * -> [block_21] + * block_21 LOOP_INCREMENT <- [block_20]: + * %i.7 = ALLOCA/LOCAL size=4 align=4 + * %95 = CONST/INT32 1 // i++ + * >> %96 = READ_MODIFY_WRITE(ADD old) [%i.7, %95] // i++ + * >> %97 = IMPLICIT_GOTO + * -> [block_19] + * block_10 IF_THEN <- [block_9]: + * %64 = RETURN_PTR // return 2 + * %63 = CONST/INT32 2 // 2 + * >> %65 = MEMORY/STORE_LE_32 [%64, %63] // return 2 + * >> %66 = EXIT_SCOPE // { int result = 0; // Nested scopes wit... + * >> %67 = RET [%63] // return 2 + * block_7 LOOP_BODY <- [block_6]: + * >> %50 = ENTER_SCOPE // { sum += i; } + * %sum.3 = ALLOCA/LOCAL size=4 align=4 + * %i.4 = ALLOCA/LOCAL size=4 align=4 + * %51 = MEMORY/LOAD_LE_32 [%i.4] // i + * >> %52 = READ_MODIFY_WRITE(ADD new) [%sum.3, %51] // sum += i + * >> %53 = EXIT_SCOPE // { sum += i; } + * >> %54 = IMPLICIT_GOTO + * -> [block_8] + * block_8 LOOP_INCREMENT <- [block_7]: + * %i.4 = ALLOCA/LOCAL size=4 align=4 + * %55 = CONST/INT32 1 // i++ + * >> %56 = READ_MODIFY_WRITE(ADD old) [%i.4, %55] // i++ + * >> %57 = IMPLICIT_GOTO + * -> [block_6] + * block_2 IF_THEN <- [block_1]: + * %34 = RETURN_PTR // return 1 + * %33 = CONST/INT32 1 // 1 + * >> %35 = MEMORY/STORE_LE_32 [%34, %33] // return 1 + * >> %36 = EXIT_SCOPE // { int result = 0; // Nested scopes wit... + * >> %37 = RET [%33] // return 1 + * } + */ + + + + + + + + + + +int test_scopes(void) { + int result = 0; + + // Nested scopes with same variable names. + { + int x = 10; + result += x; + } + { + int x = 20; + result += x; + } + if (result != 30) return 1; + + // For-init scope: 'i' is scoped to the for loop. + int sum = 0; + for (int i = 0; i < 5; i++) { + sum += i; + } + if (sum != 10) return 2; + + // Nested for loops with same variable name. + int total = 0; + for (int i = 0; i < 3; i++) { + for (int i = 0; i < 2; i++) { + total++; + } + } + if (total != 6) return 3; + + // Early return inside a nested scope: the scope's EXIT_SCOPE must + // not be emitted after the return terminator. + { + int x = 42; + if (x == 42) { + // All paths in this scope return; the scope exit is handled + // by the return paths themselves. + { + int y = x + 1; + if (y != 43) return 5; + } + } + } + // If we get here, the scope nesting was handled correctly. + + // GNU block expression. + int block_val = ({ + int a = 5; + int b = 7; + a + b; + }); + if (block_val != 12) return 4; + + return 0; +} diff --git a/tests/InterpretIR/test_sizeof_alignof.c b/tests/InterpretIR/test_sizeof_alignof.c new file mode 100644 index 000000000..9b3b09e61 --- /dev/null +++ b/tests/InterpretIR/test_sizeof_alignof.c @@ -0,0 +1,230 @@ +// Tests: sizeof and alignof lowered to CONST, offsetof lowered via +// EvaluateAsInt, and various type size queries. + +/* + * Expected IR: + * + * function test_sizeof_alignof (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=40 align=4 (arr) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %arr.0 = ALLOCA/LOCAL size=40 align=4 + * >> %1 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %2 = ENTER_SCOPE // { // sizeof basic types. if (sizeof(cha... + * %3 = CONST/UINT64 1 // sizeof(char) + * %4 = CONST/INT32 1 // 1 + * %5 = CAST/SEXT_I32_I64 [%4] // 1 + * %6 = CMP_NE [%3, %5] // sizeof(char) != 1 + * >> %7 = COND_BRANCH [%6] // if (sizeof(char) != 1) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %13 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %14 = CONST/UINT64 4 // sizeof(int) + * %15 = CONST/INT32 2 // 2 + * %16 = CAST/SEXT_I32_I64 [%15] // 2 + * %17 = UCMP_LT [%14, %16] // sizeof(int) < 2 + * >> %18 = COND_BRANCH [%17] // if (sizeof(int) < 2) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %24 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %25 = CONST/UINT64 8 // sizeof(long long) + * %26 = CONST/INT32 8 // 8 + * %27 = CAST/SEXT_I32_I64 [%26] // 8 + * %28 = UCMP_LT [%25, %27] // sizeof(long long) < 8 + * >> %29 = COND_BRANCH [%28] // if (sizeof(long long) < 8) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %35 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %36 = CONST/UINT64 12 // sizeof(struct Packed) + * %37 = CONST/INT32 6 // 6 + * %38 = CAST/SEXT_I32_I64 [%37] // 6 + * %39 = UCMP_LT [%36, %38] // sizeof(struct Packed) < 6 + * >> %40 = COND_BRANCH [%39] // if (sizeof(struct Packed) < 6) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %46 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %47 = CONST/UINT64 40 // sizeof(arr) + * %48 = CONST/INT32 10 // 10 + * %49 = CAST/SEXT_I32_I64 [%48] // 10 + * %50 = CONST/UINT64 4 // sizeof(int) + * %51 = MUL [%49, %50] // 10 * sizeof(int) + * %52 = CMP_NE [%47, %51] // sizeof(arr) != 10 * sizeof(int) + * >> %53 = COND_BRANCH [%52] // if (sizeof(arr) != 10 * sizeof(int)) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %59 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %60 = CONST/UINT64 8 // sizeof(int *) + * %61 = CONST/UINT64 8 // sizeof(void *) + * %62 = CMP_NE [%60, %61] // sizeof(int *) != sizeof(void *) + * >> %63 = COND_BRANCH [%62] // if (sizeof(int *) != sizeof(void *)) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %69 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %70 = CONST/UINT64 4 // _Alignof(int) + * %71 = CONST/INT32 1 // 1 + * %72 = CAST/SEXT_I32_I64 [%71] // 1 + * %73 = UCMP_LT [%70, %72] // _Alignof(int) < 1 + * >> %74 = COND_BRANCH [%73] // if (_Alignof(int) < 1) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %80 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %81 = CONST/UINT64 8 // _Alignof(double) + * %82 = CONST/INT32 1 // 1 + * %83 = CAST/SEXT_I32_I64 [%82] // 1 + * %84 = UCMP_LT [%81, %83] // _Alignof(double) < 1 + * >> %85 = COND_BRANCH [%84] // if (_Alignof(double) < 1) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %91 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %92 = CONST/UINT64 0 // __builtin_offsetof(structPacked,a) + * %93 = CONST/INT32 0 // 0 + * %94 = CAST/SEXT_I32_I64 [%93] // 0 + * %95 = CMP_NE [%92, %94] // __builtin_offsetof(structPacked,a) != 0 + * >> %96 = COND_BRANCH [%95] // if (__builtin_offsetof(structPacked,a) != 0) re... + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %102 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %103 = CONST/UINT64 4 // __builtin_offsetof(structPacked,b) + * %104 = CONST/INT32 1 // 1 + * %105 = CAST/SEXT_I32_I64 [%104] // 1 + * %106 = UCMP_LT [%103, %105] // __builtin_offsetof(structPacked,b) < 1 + * >> %107 = COND_BRANCH [%106] // if (__builtin_offsetof(structPacked,b) < 1) ret... + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %113 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %115 = RETURN_PTR // return 0 + * %114 = CONST/INT32 0 // 0 + * >> %116 = MEMORY/STORE_LE_32 [%115, %114] // return 0 + * >> %117 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %118 = RET [%114] // return 0 + * block_29 IF_THEN <- [block_28]: + * %109 = RETURN_PTR // return 10 + * %108 = CONST/INT32 10 // 10 + * >> %110 = MEMORY/STORE_LE_32 [%109, %108] // return 10 + * >> %111 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %112 = RET [%108] // return 10 + * block_26 IF_THEN <- [block_25]: + * %98 = RETURN_PTR // return 9 + * %97 = CONST/INT32 9 // 9 + * >> %99 = MEMORY/STORE_LE_32 [%98, %97] // return 9 + * >> %100 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %101 = RET [%97] // return 9 + * block_23 IF_THEN <- [block_22]: + * %87 = RETURN_PTR // return 8 + * %86 = CONST/INT32 8 // 8 + * >> %88 = MEMORY/STORE_LE_32 [%87, %86] // return 8 + * >> %89 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %90 = RET [%86] // return 8 + * block_20 IF_THEN <- [block_19]: + * %76 = RETURN_PTR // return 7 + * %75 = CONST/INT32 7 // 7 + * >> %77 = MEMORY/STORE_LE_32 [%76, %75] // return 7 + * >> %78 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %79 = RET [%75] // return 7 + * block_17 IF_THEN <- [block_16]: + * %65 = RETURN_PTR // return 6 + * %64 = CONST/INT32 6 // 6 + * >> %66 = MEMORY/STORE_LE_32 [%65, %64] // return 6 + * >> %67 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %68 = RET [%64] // return 6 + * block_14 IF_THEN <- [block_13]: + * %55 = RETURN_PTR // return 5 + * %54 = CONST/INT32 5 // 5 + * >> %56 = MEMORY/STORE_LE_32 [%55, %54] // return 5 + * >> %57 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %58 = RET [%54] // return 5 + * block_11 IF_THEN <- [block_10]: + * %42 = RETURN_PTR // return 4 + * %41 = CONST/INT32 4 // 4 + * >> %43 = MEMORY/STORE_LE_32 [%42, %41] // return 4 + * >> %44 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %45 = RET [%41] // return 4 + * block_8 IF_THEN <- [block_7]: + * %31 = RETURN_PTR // return 3 + * %30 = CONST/INT32 3 // 3 + * >> %32 = MEMORY/STORE_LE_32 [%31, %30] // return 3 + * >> %33 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %34 = RET [%30] // return 3 + * block_5 IF_THEN <- [block_4]: + * %20 = RETURN_PTR // return 2 + * %19 = CONST/INT32 2 // 2 + * >> %21 = MEMORY/STORE_LE_32 [%20, %19] // return 2 + * >> %22 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %23 = RET [%19] // return 2 + * block_2 IF_THEN <- [block_1]: + * %9 = RETURN_PTR // return 1 + * %8 = CONST/INT32 1 // 1 + * >> %10 = MEMORY/STORE_LE_32 [%9, %8] // return 1 + * >> %11 = EXIT_SCOPE // { // sizeof basic types. if (sizeof(cha... + * >> %12 = RET [%8] // return 1 + * } + */ + + + + + + + + + + +#define offsetof(type, member) __builtin_offsetof(type, member) + +struct Packed { + char a; + int b; + char c; +}; + +int test_sizeof_alignof(void) { + // sizeof basic types. + if (sizeof(char) != 1) return 1; + if (sizeof(int) < 2) return 2; + if (sizeof(long long) < 8) return 3; + + // sizeof struct. + if (sizeof(struct Packed) < 6) return 4; + + // sizeof array. + int arr[10]; + if (sizeof(arr) != 10 * sizeof(int)) return 5; + + // sizeof pointer. + if (sizeof(int *) != sizeof(void *)) return 6; + + // alignof. + if (_Alignof(int) < 1) return 7; + if (_Alignof(double) < 1) return 8; + + // offsetof. + if (offsetof(struct Packed, a) != 0) return 9; + if (offsetof(struct Packed, b) < 1) return 10; + + return 0; +} diff --git a/tests/InterpretIR/test_string_literals.c b/tests/InterpretIR/test_string_literals.c new file mode 100644 index 000000000..27775989c --- /dev/null +++ b/tests/InterpretIR/test_string_literals.c @@ -0,0 +1,594 @@ +// Tests: string literal handling (STRING_LITERAL objects, ALLOCA for string +// storage, non-power-of-2 sizes → MEMCPY for initialization), +// array initialization from string literals, string pointer assignment. + +/* + * Expected IR: + * + * function test_string_literals (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=6 align=1 (buf) + * obj_1 LOCAL_VALUE size=8 align=8 (p) + * obj_2 LOCAL_VALUE size=4 align=4 (len) + * obj_3 LOCAL_VALUE size=16 align=1 (long_buf) + * obj_4 LOCAL_VALUE size=1 align=1 (empty) + * obj_5 LOCAL_VALUE size=2 align=1 (single) + * obj_6 LOCAL_VALUE size=12 align=4 (wbuf) + * obj_7 LOCAL_VALUE size=8 align=2 (u16buf) + * obj_8 LOCAL_VALUE size=12 align=4 (u32buf) + * obj_9 LOCAL_VALUE size=20 align=1 (oversized) + * obj_10 PARAMETER size=8 align=8 + * obj_11 RETURN_SLOT size=4 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %buf.0 = ALLOCA/LOCAL size=6 align=1 + * >> %p.1 = ALLOCA/LOCAL size=8 align=8 + * >> %len.2 = ALLOCA/LOCAL size=4 align=4 + * >> %long_buf.3 = ALLOCA/LOCAL size=16 align=1 + * >> %empty.4 = ALLOCA/LOCAL size=1 align=1 + * >> %single.5 = ALLOCA/LOCAL size=2 align=1 + * >> %wbuf.6 = ALLOCA/LOCAL size=12 align=4 + * >> %u16buf.7 = ALLOCA/LOCAL size=8 align=2 + * >> %u32buf.8 = ALLOCA/LOCAL size=12 align=4 + * >> %oversized.9 = ALLOCA/LOCAL size=20 align=1 + * >> %10 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %11 = ENTER_SCOPE // { // String literal initialization of char ... + * %buf.0 = ALLOCA/LOCAL size=6 align=1 + * %12 = STRING_PTR // "hello" + * %13 = CONST/UINT64 6 + * >> %buf.14 = MEMORY/MEMCPY [%buf.0, %12, %13] + * %15 = CONST/INT32 0 // 0 + * %16 = PTR_ADD elem_size=1 [%buf.0, %15] // buf[0] + * %17 = MEMORY/LOAD_LE_8 [%16] // buf[0] + * %18 = CAST/SEXT_I8_I32 [%17] // buf[0] + * %19 = CONST/UINT8 104 // 'h' + * %20 = CMP_NE [%18, %19] // buf[0] != 'h' + * >> %21 = COND_BRANCH [%20] // if (buf[0] != 'h') return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %27 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %buf.0 = ALLOCA/LOCAL size=6 align=1 + * %28 = CONST/INT32 4 // 4 + * %29 = PTR_ADD elem_size=1 [%buf.0, %28] // buf[4] + * %30 = MEMORY/LOAD_LE_8 [%29] // buf[4] + * %31 = CAST/SEXT_I8_I32 [%30] // buf[4] + * %32 = CONST/UINT8 111 // 'o' + * %33 = CMP_NE [%31, %32] // buf[4] != 'o' + * >> %34 = COND_BRANCH [%33] // if (buf[4] != 'o') return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %40 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %buf.0 = ALLOCA/LOCAL size=6 align=1 + * %41 = CONST/INT32 5 // 5 + * %42 = PTR_ADD elem_size=1 [%buf.0, %41] // buf[5] + * %43 = MEMORY/LOAD_LE_8 [%42] // buf[5] + * %44 = CAST/SEXT_I8_I32 [%43] // buf[5] + * %45 = CONST/UINT8 0 // '\0' + * %46 = CMP_NE [%44, %45] // buf[5] != '\0' + * >> %47 = COND_BRANCH [%46] // if (buf[5] != '\0') return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %53 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %p.1 = ALLOCA/LOCAL size=8 align=8 + * %54 = STRING_PTR // "world" + * >> %p.55 = MEMORY/STORE_LE_64 [%p.1, %54] + * %56 = MEMORY/LOAD_LE_64 [%p.1] // p + * %57 = CONST/INT32 0 // 0 + * %58 = PTR_ADD elem_size=1 [%56, %57] // p[0] + * %59 = MEMORY/LOAD_LE_8 [%58] // p[0] + * %60 = CAST/SEXT_I8_I32 [%59] // p[0] + * %61 = CONST/UINT8 119 // 'w' + * %62 = CMP_NE [%60, %61] // p[0] != 'w' + * >> %63 = COND_BRANCH [%62] // if (p[0] != 'w') return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %69 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %p.1 = ALLOCA/LOCAL size=8 align=8 + * %70 = MEMORY/LOAD_LE_64 [%p.1] // p + * %71 = CONST/INT32 4 // 4 + * %72 = PTR_ADD elem_size=1 [%70, %71] // p[4] + * %73 = MEMORY/LOAD_LE_8 [%72] // p[4] + * %74 = CAST/SEXT_I8_I32 [%73] // p[4] + * %75 = CONST/UINT8 100 // 'd' + * %76 = CMP_NE [%74, %75] // p[4] != 'd' + * >> %77 = COND_BRANCH [%76] // if (p[4] != 'd') return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %83 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * >> %84 = ENTER_SCOPE // my_strlen("test") + * %86 = ALLOCA/ARG size=8 align=8 // "test" + * %85 = STRING_PTR // "test" + * >> %87 = MEMORY/STORE_LE_64 [%86, %85] // "test" + * %len.2 = ALLOCA/LOCAL size=4 align=4 + * %89 = CALL @my_strlen [%86] // my_strlen("test") + * >> %len.90 = MEMORY/STORE_LE_32 [%len.2, %89] + * >> %94 = EXIT_SCOPE + * %91 = MEMORY/LOAD_LE_32 [%len.2] // len + * %92 = CONST/INT32 4 // 4 + * %93 = CMP_NE [%91, %92] // len != 4 + * >> %95 = COND_BRANCH [%93] // if (len != 4) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %102 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %long_buf.3 = ALLOCA/LOCAL size=16 align=1 + * %103 = STRING_PTR // "0123456789abcde" + * %104 = CONST/UINT64 16 + * >> %long_buf.105 = MEMORY/MEMCPY [%long_buf.3, %103, %104] + * %106 = CONST/INT32 0 // 0 + * %107 = PTR_ADD elem_size=1 [%long_buf.3, %106] // long_buf[0] + * %108 = MEMORY/LOAD_LE_8 [%107] // long_buf[0] + * %109 = CAST/SEXT_I8_I32 [%108] // long_buf[0] + * %110 = CONST/UINT8 48 // '0' + * %111 = CMP_NE [%109, %110] // long_buf[0] != '0' + * >> %112 = COND_BRANCH [%111] // if (long_buf[0] != '0') return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %118 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %long_buf.3 = ALLOCA/LOCAL size=16 align=1 + * %119 = CONST/INT32 9 // 9 + * %120 = PTR_ADD elem_size=1 [%long_buf.3, %119] // long_buf[9] + * %121 = MEMORY/LOAD_LE_8 [%120] // long_buf[9] + * %122 = CAST/SEXT_I8_I32 [%121] // long_buf[9] + * %123 = CONST/UINT8 57 // '9' + * %124 = CMP_NE [%122, %123] // long_buf[9] != '9' + * >> %125 = COND_BRANCH [%124] // if (long_buf[9] != '9') return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %131 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %long_buf.3 = ALLOCA/LOCAL size=16 align=1 + * %132 = CONST/INT32 14 // 14 + * %133 = PTR_ADD elem_size=1 [%long_buf.3, %132] // long_buf[14] + * %134 = MEMORY/LOAD_LE_8 [%133] // long_buf[14] + * %135 = CAST/SEXT_I8_I32 [%134] // long_buf[14] + * %136 = CONST/UINT8 101 // 'e' + * %137 = CMP_NE [%135, %136] // long_buf[14] != 'e' + * >> %138 = COND_BRANCH [%137] // if (long_buf[14] != 'e') return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %144 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %long_buf.3 = ALLOCA/LOCAL size=16 align=1 + * %145 = CONST/INT32 15 // 15 + * %146 = PTR_ADD elem_size=1 [%long_buf.3, %145] // long_buf[15] + * %147 = MEMORY/LOAD_LE_8 [%146] // long_buf[15] + * %148 = CAST/SEXT_I8_I32 [%147] // long_buf[15] + * %149 = CONST/UINT8 0 // '\0' + * %150 = CMP_NE [%148, %149] // long_buf[15] != '\0' + * >> %151 = COND_BRANCH [%150] // if (long_buf[15] != '\0') return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %157 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %empty.4 = ALLOCA/LOCAL size=1 align=1 + * %158 = STRING_PTR // "" + * %159 = CONST/UINT64 1 + * >> %empty.160 = MEMORY/MEMCPY [%empty.4, %158, %159] + * %161 = CONST/INT32 0 // 0 + * %162 = PTR_ADD elem_size=1 [%empty.4, %161] // empty[0] + * %163 = MEMORY/LOAD_LE_8 [%162] // empty[0] + * %164 = CAST/SEXT_I8_I32 [%163] // empty[0] + * %165 = CONST/UINT8 0 // '\0' + * %166 = CMP_NE [%164, %165] // empty[0] != '\0' + * >> %167 = COND_BRANCH [%166] // if (empty[0] != '\0') return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %173 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %single.5 = ALLOCA/LOCAL size=2 align=1 + * %174 = STRING_PTR // "x" + * %175 = CONST/UINT64 2 + * >> %single.176 = MEMORY/MEMCPY [%single.5, %174, %175] + * %177 = CONST/INT32 0 // 0 + * %178 = PTR_ADD elem_size=1 [%single.5, %177] // single[0] + * %179 = MEMORY/LOAD_LE_8 [%178] // single[0] + * %180 = CAST/SEXT_I8_I32 [%179] // single[0] + * %181 = CONST/UINT8 120 // 'x' + * %182 = CMP_NE [%180, %181] // single[0] != 'x' + * >> %183 = COND_BRANCH [%182] // if (single[0] != 'x') return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %189 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %single.5 = ALLOCA/LOCAL size=2 align=1 + * %190 = CONST/INT32 1 // 1 + * %191 = PTR_ADD elem_size=1 [%single.5, %190] // single[1] + * %192 = MEMORY/LOAD_LE_8 [%191] // single[1] + * %193 = CAST/SEXT_I8_I32 [%192] // single[1] + * %194 = CONST/UINT8 0 // '\0' + * %195 = CMP_NE [%193, %194] // single[1] != '\0' + * >> %196 = COND_BRANCH [%195] // if (single[1] != '\0') return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %202 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %wbuf.6 = ALLOCA/LOCAL size=12 align=4 + * %203 = STRING_PTR // L"hi" + * %204 = CONST/UINT64 12 + * >> %wbuf.205 = MEMORY/MEMCPY [%wbuf.6, %203, %204] + * %206 = CONST/INT32 0 // 0 + * %207 = PTR_ADD elem_size=4 [%wbuf.6, %206] // wbuf[0] + * %208 = MEMORY/LOAD_LE_32 [%207] // wbuf[0] + * %209 = CONST/WCHAR32 104 // L'h' + * %210 = CMP_NE [%208, %209] // wbuf[0] != L'h' + * >> %211 = COND_BRANCH [%210] // if (wbuf[0] != L'h') return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %217 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %wbuf.6 = ALLOCA/LOCAL size=12 align=4 + * %218 = CONST/INT32 1 // 1 + * %219 = PTR_ADD elem_size=4 [%wbuf.6, %218] // wbuf[1] + * %220 = MEMORY/LOAD_LE_32 [%219] // wbuf[1] + * %221 = CONST/WCHAR32 105 // L'i' + * %222 = CMP_NE [%220, %221] // wbuf[1] != L'i' + * >> %223 = COND_BRANCH [%222] // if (wbuf[1] != L'i') return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %229 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %wbuf.6 = ALLOCA/LOCAL size=12 align=4 + * %230 = CONST/INT32 2 // 2 + * %231 = PTR_ADD elem_size=4 [%wbuf.6, %230] // wbuf[2] + * %232 = MEMORY/LOAD_LE_32 [%231] // wbuf[2] + * %233 = CONST/WCHAR32 0 // L'\0' + * %234 = CMP_NE [%232, %233] // wbuf[2] != L'\0' + * >> %235 = COND_BRANCH [%234] // if (wbuf[2] != L'\0') return 16 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %241 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %u16buf.7 = ALLOCA/LOCAL size=8 align=2 + * %242 = STRING_PTR // u"abc" + * %243 = CONST/UINT64 8 + * >> %u16buf.244 = MEMORY/MEMCPY [%u16buf.7, %242, %243] + * %245 = CONST/INT32 0 // 0 + * %246 = PTR_ADD elem_size=2 [%u16buf.7, %245] // u16buf[0] + * %247 = MEMORY/LOAD_LE_16 [%246] // u16buf[0] + * %248 = CAST/ZEXT_I16_I32 [%247] // u16buf[0] + * %249 = CONST/WCHAR16 97 // u'a' + * %250 = CAST/ZEXT_I16_I32 [%249] // u'a' + * %251 = CMP_NE [%248, %250] // u16buf[0] != u'a' + * >> %252 = COND_BRANCH [%251] // if (u16buf[0] != u'a') return 17 + * -> [block_50, block_51] + * block_51 IF_ELSE <- [block_49]: + * >> %258 = IMPLICIT_GOTO + * -> [block_52] + * block_52 IF_MERGE <- [block_51]: + * %u16buf.7 = ALLOCA/LOCAL size=8 align=2 + * %259 = CONST/INT32 3 // 3 + * %260 = PTR_ADD elem_size=2 [%u16buf.7, %259] // u16buf[3] + * %261 = MEMORY/LOAD_LE_16 [%260] // u16buf[3] + * %262 = CAST/ZEXT_I16_I32 [%261] // u16buf[3] + * %263 = CONST/INT32 0 // 0 + * %264 = CMP_NE [%262, %263] // u16buf[3] != 0 + * >> %265 = COND_BRANCH [%264] // if (u16buf[3] != 0) return 18 + * -> [block_53, block_54] + * block_54 IF_ELSE <- [block_52]: + * >> %271 = IMPLICIT_GOTO + * -> [block_55] + * block_55 IF_MERGE <- [block_54]: + * %u32buf.8 = ALLOCA/LOCAL size=12 align=4 + * %272 = STRING_PTR // U"ab" + * %273 = CONST/UINT64 12 + * >> %u32buf.274 = MEMORY/MEMCPY [%u32buf.8, %272, %273] + * %275 = CONST/INT32 0 // 0 + * %276 = PTR_ADD elem_size=4 [%u32buf.8, %275] // u32buf[0] + * %277 = MEMORY/LOAD_LE_32 [%276] // u32buf[0] + * %278 = CONST/WCHAR32 97 // U'a' + * %279 = CMP_NE [%277, %278] // u32buf[0] != U'a' + * >> %280 = COND_BRANCH [%279] // if (u32buf[0] != U'a') return 19 + * -> [block_56, block_57] + * block_57 IF_ELSE <- [block_55]: + * >> %286 = IMPLICIT_GOTO + * -> [block_58] + * block_58 IF_MERGE <- [block_57]: + * %u32buf.8 = ALLOCA/LOCAL size=12 align=4 + * %287 = CONST/INT32 2 // 2 + * %288 = PTR_ADD elem_size=4 [%u32buf.8, %287] // u32buf[2] + * %289 = MEMORY/LOAD_LE_32 [%288] // u32buf[2] + * %290 = CONST/INT32 0 // 0 + * %291 = CAST/IDENTITY [%290] // 0 + * %292 = CMP_NE [%289, %291] // u32buf[2] != 0 + * >> %293 = COND_BRANCH [%292] // if (u32buf[2] != 0) return 20 + * -> [block_59, block_60] + * block_60 IF_ELSE <- [block_58]: + * >> %299 = IMPLICIT_GOTO + * -> [block_61] + * block_61 IF_MERGE <- [block_60]: + * %oversized.9 = ALLOCA/LOCAL size=20 align=1 + * %300 = STRING_PTR // "hi" + * %301 = CONST/UINT64 3 + * >> %oversized.302 = MEMORY/MEMCPY [%oversized.9, %300, %301] + * %303 = CONST/INT32 0 // 0 + * %304 = PTR_ADD elem_size=1 [%oversized.9, %303] // oversized[0] + * %305 = MEMORY/LOAD_LE_8 [%304] // oversized[0] + * %306 = CAST/SEXT_I8_I32 [%305] // oversized[0] + * %307 = CONST/UINT8 104 // 'h' + * %308 = CMP_NE [%306, %307] // oversized[0] != 'h' + * >> %309 = COND_BRANCH [%308] // if (oversized[0] != 'h') return 21 + * -> [block_62, block_63] + * block_63 IF_ELSE <- [block_61]: + * >> %315 = IMPLICIT_GOTO + * -> [block_64] + * block_64 IF_MERGE <- [block_63]: + * %oversized.9 = ALLOCA/LOCAL size=20 align=1 + * %316 = CONST/INT32 2 // 2 + * %317 = PTR_ADD elem_size=1 [%oversized.9, %316] // oversized[2] + * %318 = MEMORY/LOAD_LE_8 [%317] // oversized[2] + * %319 = CAST/SEXT_I8_I32 [%318] // oversized[2] + * %320 = CONST/UINT8 0 // '\0' + * %321 = CMP_NE [%319, %320] // oversized[2] != '\0' + * >> %322 = COND_BRANCH [%321] // if (oversized[2] != '\0') return 22 + * -> [block_65, block_66] + * block_66 IF_ELSE <- [block_64]: + * >> %328 = IMPLICIT_GOTO + * -> [block_67] + * block_67 IF_MERGE <- [block_66]: + * %oversized.9 = ALLOCA/LOCAL size=20 align=1 + * %329 = CONST/INT32 19 // 19 + * %330 = PTR_ADD elem_size=1 [%oversized.9, %329] // oversized[19] + * %331 = MEMORY/LOAD_LE_8 [%330] // oversized[19] + * %332 = CAST/SEXT_I8_I32 [%331] // oversized[19] + * %333 = CONST/UINT8 0 // '\0' + * %334 = CMP_NE [%332, %333] // oversized[19] != '\0' + * >> %335 = COND_BRANCH [%334] // if (oversized[19] != '\0') return 23 + * -> [block_68, block_69] + * block_69 IF_ELSE <- [block_67]: + * >> %341 = IMPLICIT_GOTO + * -> [block_70] + * block_70 IF_MERGE <- [block_69]: + * %343 = RETURN_PTR // return 0 + * %342 = CONST/INT32 0 // 0 + * >> %344 = MEMORY/STORE_LE_32 [%343, %342] // return 0 + * >> %345 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %346 = RET [%342] // return 0 + * block_68 IF_THEN <- [block_67]: + * %337 = RETURN_PTR // return 23 + * %336 = CONST/INT32 23 // 23 + * >> %338 = MEMORY/STORE_LE_32 [%337, %336] // return 23 + * >> %339 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %340 = RET [%336] // return 23 + * block_65 IF_THEN <- [block_64]: + * %324 = RETURN_PTR // return 22 + * %323 = CONST/INT32 22 // 22 + * >> %325 = MEMORY/STORE_LE_32 [%324, %323] // return 22 + * >> %326 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %327 = RET [%323] // return 22 + * block_62 IF_THEN <- [block_61]: + * %311 = RETURN_PTR // return 21 + * %310 = CONST/INT32 21 // 21 + * >> %312 = MEMORY/STORE_LE_32 [%311, %310] // return 21 + * >> %313 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %314 = RET [%310] // return 21 + * block_59 IF_THEN <- [block_58]: + * %295 = RETURN_PTR // return 20 + * %294 = CONST/INT32 20 // 20 + * >> %296 = MEMORY/STORE_LE_32 [%295, %294] // return 20 + * >> %297 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %298 = RET [%294] // return 20 + * block_56 IF_THEN <- [block_55]: + * %282 = RETURN_PTR // return 19 + * %281 = CONST/INT32 19 // 19 + * >> %283 = MEMORY/STORE_LE_32 [%282, %281] // return 19 + * >> %284 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %285 = RET [%281] // return 19 + * block_53 IF_THEN <- [block_52]: + * %267 = RETURN_PTR // return 18 + * %266 = CONST/INT32 18 // 18 + * >> %268 = MEMORY/STORE_LE_32 [%267, %266] // return 18 + * >> %269 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %270 = RET [%266] // return 18 + * block_50 IF_THEN <- [block_49]: + * %254 = RETURN_PTR // return 17 + * %253 = CONST/INT32 17 // 17 + * >> %255 = MEMORY/STORE_LE_32 [%254, %253] // return 17 + * >> %256 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %257 = RET [%253] // return 17 + * block_47 IF_THEN <- [block_46]: + * %237 = RETURN_PTR // return 16 + * %236 = CONST/INT32 16 // 16 + * >> %238 = MEMORY/STORE_LE_32 [%237, %236] // return 16 + * >> %239 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %240 = RET [%236] // return 16 + * block_44 IF_THEN <- [block_43]: + * %225 = RETURN_PTR // return 15 + * %224 = CONST/INT32 15 // 15 + * >> %226 = MEMORY/STORE_LE_32 [%225, %224] // return 15 + * >> %227 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %228 = RET [%224] // return 15 + * block_41 IF_THEN <- [block_40]: + * %213 = RETURN_PTR // return 14 + * %212 = CONST/INT32 14 // 14 + * >> %214 = MEMORY/STORE_LE_32 [%213, %212] // return 14 + * >> %215 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %216 = RET [%212] // return 14 + * block_38 IF_THEN <- [block_37]: + * %198 = RETURN_PTR // return 13 + * %197 = CONST/INT32 13 // 13 + * >> %199 = MEMORY/STORE_LE_32 [%198, %197] // return 13 + * >> %200 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %201 = RET [%197] // return 13 + * block_35 IF_THEN <- [block_34]: + * %185 = RETURN_PTR // return 12 + * %184 = CONST/INT32 12 // 12 + * >> %186 = MEMORY/STORE_LE_32 [%185, %184] // return 12 + * >> %187 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %188 = RET [%184] // return 12 + * block_32 IF_THEN <- [block_31]: + * %169 = RETURN_PTR // return 11 + * %168 = CONST/INT32 11 // 11 + * >> %170 = MEMORY/STORE_LE_32 [%169, %168] // return 11 + * >> %171 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %172 = RET [%168] // return 11 + * block_29 IF_THEN <- [block_28]: + * %153 = RETURN_PTR // return 10 + * %152 = CONST/INT32 10 // 10 + * >> %154 = MEMORY/STORE_LE_32 [%153, %152] // return 10 + * >> %155 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %156 = RET [%152] // return 10 + * block_26 IF_THEN <- [block_25]: + * %140 = RETURN_PTR // return 9 + * %139 = CONST/INT32 9 // 9 + * >> %141 = MEMORY/STORE_LE_32 [%140, %139] // return 9 + * >> %142 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %143 = RET [%139] // return 9 + * block_23 IF_THEN <- [block_22]: + * %127 = RETURN_PTR // return 8 + * %126 = CONST/INT32 8 // 8 + * >> %128 = MEMORY/STORE_LE_32 [%127, %126] // return 8 + * >> %129 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %130 = RET [%126] // return 8 + * block_20 IF_THEN <- [block_19]: + * %114 = RETURN_PTR // return 7 + * %113 = CONST/INT32 7 // 7 + * >> %115 = MEMORY/STORE_LE_32 [%114, %113] // return 7 + * >> %116 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %117 = RET [%113] // return 7 + * block_17 IF_THEN <- [block_16]: + * %97 = RETURN_PTR // return 6 + * %96 = CONST/INT32 6 // 6 + * >> %98 = MEMORY/STORE_LE_32 [%97, %96] // return 6 + * >> %99 = EXIT_SCOPE // my_strlen("test") + * >> %100 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %101 = RET [%96] // return 6 + * block_14 IF_THEN <- [block_13]: + * %79 = RETURN_PTR // return 5 + * %78 = CONST/INT32 5 // 5 + * >> %80 = MEMORY/STORE_LE_32 [%79, %78] // return 5 + * >> %81 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %82 = RET [%78] // return 5 + * block_11 IF_THEN <- [block_10]: + * %65 = RETURN_PTR // return 4 + * %64 = CONST/INT32 4 // 4 + * >> %66 = MEMORY/STORE_LE_32 [%65, %64] // return 4 + * >> %67 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %68 = RET [%64] // return 4 + * block_8 IF_THEN <- [block_7]: + * %49 = RETURN_PTR // return 3 + * %48 = CONST/INT32 3 // 3 + * >> %50 = MEMORY/STORE_LE_32 [%49, %48] // return 3 + * >> %51 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %52 = RET [%48] // return 3 + * block_5 IF_THEN <- [block_4]: + * %36 = RETURN_PTR // return 2 + * %35 = CONST/INT32 2 // 2 + * >> %37 = MEMORY/STORE_LE_32 [%36, %35] // return 2 + * >> %38 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %39 = RET [%35] // return 2 + * block_2 IF_THEN <- [block_1]: + * %23 = RETURN_PTR // return 1 + * %22 = CONST/INT32 1 // 1 + * >> %24 = MEMORY/STORE_LE_32 [%23, %22] // return 1 + * >> %25 = EXIT_SCOPE // { // String literal initialization of char ... + * >> %26 = RET [%22] // return 1 + * } + */ + + + + + + + + + + +static int my_strlen(const char *s) { + int len = 0; + while (s[len] != '\0') { + len++; + } + return len; +} + +int test_string_literals(void) { + // String literal initialization of char array. + // "hello" is char[6] (5 chars + null) — non-power-of-2 → MEMCPY. + char buf[6] = "hello"; + if (buf[0] != 'h') return 1; + if (buf[4] != 'o') return 2; + if (buf[5] != '\0') return 3; + + // String pointer (decays to pointer to string literal storage). + const char *p = "world"; + if (p[0] != 'w') return 4; + if (p[4] != 'd') return 5; + + // String literal in function call. + int len = my_strlen("test"); + if (len != 4) return 6; + + // Longer string (> 8 bytes, definitely MEMCPY). + char long_buf[16] = "0123456789abcde"; + if (long_buf[0] != '0') return 7; + if (long_buf[9] != '9') return 8; + if (long_buf[14] != 'e') return 9; + if (long_buf[15] != '\0') return 10; + + // Empty string. + char empty[1] = ""; + if (empty[0] != '\0') return 11; + + // Single character string. + char single[2] = "x"; + if (single[0] != 'x') return 12; + if (single[1] != '\0') return 13; + + // Wide string literal (wchar_t, typically 4 bytes per char on this platform). + // L"hi" is 3 wchar_t values: 'h', 'i', '\0'. + typedef __WCHAR_TYPE__ wchar_t; + _Static_assert(sizeof(L'x') == 4, "wchar_t must be 4 bytes"); + wchar_t wbuf[3] = L"hi"; + if (wbuf[0] != L'h') return 14; + if (wbuf[1] != L'i') return 15; + if (wbuf[2] != L'\0') return 16; + + // char16_t string (C11 u"..." — 2 bytes per char). + // Requires but we can use __CHAR16_TYPE__ directly. + typedef __CHAR16_TYPE__ char16_t; + char16_t u16buf[4] = u"abc"; + if (u16buf[0] != u'a') return 17; + if (u16buf[3] != 0) return 18; + + // char32_t string (C11 U"..." — 4 bytes per char). + typedef __CHAR32_TYPE__ char32_t; + char32_t u32buf[3] = U"ab"; + if (u32buf[0] != U'a') return 19; + if (u32buf[2] != 0) return 20; + + // Oversized destination: char x[20] = "hi" — 3 bytes copied, rest zero. + char oversized[20] = "hi"; + if (oversized[0] != 'h') return 21; + if (oversized[2] != '\0') return 22; + if (oversized[19] != '\0') return 23; + + return 0; +} diff --git a/tests/InterpretIR/test_struct_assign.c b/tests/InterpretIR/test_struct_assign.c new file mode 100644 index 000000000..352041b44 --- /dev/null +++ b/tests/InterpretIR/test_struct_assign.c @@ -0,0 +1,419 @@ +// Tests: direct struct assignment using MEMCPY (not LOAD+STORE), +// struct parameter passing, struct return values, nested struct assignment, +// non-power-of-2 sized structs. + +/* + * Expected IR: + * + * function test_struct_assign (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=8 align=4 (a) + * obj_1 LOCAL_VALUE size=8 align=4 (b) + * obj_2 LOCAL_VALUE size=20 align=4 (la) + * obj_3 LOCAL_VALUE size=20 align=4 (lb) + * obj_4 LOCAL_VALUE size=4 align=4 (total) + * obj_5 LOCAL_VALUE size=8 align=4 (c) + * obj_6 LOCAL_VALUE size=12 align=4 (n1) + * obj_7 LOCAL_VALUE size=12 align=4 (n2) + * obj_8 LOCAL_VALUE size=8 align=4 (d) + * obj_9 PARAMETER size=20 align=4 + * obj_10 RETURN_SLOT size=4 align=4 + * obj_11 PARAMETER size=4 align=4 + * obj_12 PARAMETER size=4 align=4 + * obj_13 RETURN_SLOT size=8 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %a.0 = ALLOCA/LOCAL size=8 align=4 + * >> %b.1 = ALLOCA/LOCAL size=8 align=4 + * >> %la.2 = ALLOCA/LOCAL size=20 align=4 + * >> %lb.3 = ALLOCA/LOCAL size=20 align=4 + * >> %total.4 = ALLOCA/LOCAL size=4 align=4 + * >> %c.5 = ALLOCA/LOCAL size=8 align=4 + * >> %n1.6 = ALLOCA/LOCAL size=12 align=4 + * >> %n2.7 = ALLOCA/LOCAL size=12 align=4 + * >> %d.8 = ALLOCA/LOCAL size=8 align=4 + * >> %9 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %10 = ENTER_SCOPE // { // Direct struct assignment: a = b → ME... + * %a.0 = ALLOCA/LOCAL size=8 align=4 + * %11 = GEP_FIELD offset=0 .x [%a.0] // a.x + * %12 = CONST/INT32 10 // 10 + * >> %13 = MEMORY/STORE_LE_32 [%11, %12] // a.x = 10 + * %14 = GEP_FIELD offset=4 .y [%a.0] // a.y + * %15 = CONST/INT32 20 // 20 + * >> %16 = MEMORY/STORE_LE_32 [%14, %15] // a.y = 20 + * %b.1 = ALLOCA/LOCAL size=8 align=4 + * %17 = CONST/UINT64 8 + * >> %b.18 = MEMORY/MEMCPY [%b.1, %a.0, %17] + * %19 = GEP_FIELD offset=0 .x [%b.1] // b.x + * %20 = MEMORY/LOAD_LE_32 [%19] // b.x + * %21 = CONST/INT32 10 // 10 + * %22 = CMP_NE [%20, %21] // b.x != 10 + * >> %23 = COND_BRANCH [%22] // if (b.x != 10) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %29 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %b.1 = ALLOCA/LOCAL size=8 align=4 + * %30 = GEP_FIELD offset=4 .y [%b.1] // b.y + * %31 = MEMORY/LOAD_LE_32 [%30] // b.y + * %32 = CONST/INT32 20 // 20 + * %33 = CMP_NE [%31, %32] // b.y != 20 + * >> %34 = COND_BRANCH [%33] // if (b.y != 20) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %40 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %b.1 = ALLOCA/LOCAL size=8 align=4 + * %41 = GEP_FIELD offset=0 .x [%b.1] // b.x + * %42 = CONST/INT32 99 // 99 + * >> %43 = MEMORY/STORE_LE_32 [%41, %42] // b.x = 99 + * %a.0 = ALLOCA/LOCAL size=8 align=4 + * %44 = GEP_FIELD offset=0 .x [%a.0] // a.x + * %45 = MEMORY/LOAD_LE_32 [%44] // a.x + * %46 = CONST/INT32 10 // 10 + * %47 = CMP_NE [%45, %46] // a.x != 10 + * >> %48 = COND_BRANCH [%47] // if (a.x != 10) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %54 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %la.2 = ALLOCA/LOCAL size=20 align=4 + * %55 = GEP_FIELD offset=0 .a [%la.2] // la.a + * %56 = CONST/INT32 1 // 1 + * >> %57 = MEMORY/STORE_LE_32 [%55, %56] // la.a = 1 + * %58 = GEP_FIELD offset=4 .b [%la.2] // la.b + * %59 = CONST/INT32 2 // 2 + * >> %60 = MEMORY/STORE_LE_32 [%58, %59] // la.b = 2 + * %61 = GEP_FIELD offset=8 .c [%la.2] // la.c + * %62 = CONST/INT32 3 // 3 + * >> %63 = MEMORY/STORE_LE_32 [%61, %62] // la.c = 3 + * %64 = GEP_FIELD offset=12 .d [%la.2] // la.d + * %65 = CONST/INT32 4 // 4 + * >> %66 = MEMORY/STORE_LE_32 [%64, %65] // la.d = 4 + * %67 = GEP_FIELD offset=16 .e [%la.2] // la.e + * %68 = CONST/INT32 5 // 5 + * >> %69 = MEMORY/STORE_LE_32 [%67, %68] // la.e = 5 + * %lb.3 = ALLOCA/LOCAL size=20 align=4 + * %70 = CONST/UINT64 20 + * >> %lb.71 = MEMORY/MEMCPY [%lb.3, %la.2, %70] + * %72 = GEP_FIELD offset=0 .a [%lb.3] // lb.a + * %73 = MEMORY/LOAD_LE_32 [%72] // lb.a + * %74 = CONST/INT32 1 // 1 + * %75 = CMP_NE [%73, %74] // lb.a != 1 + * >> %76 = COND_BRANCH [%75] // if (lb.a != 1) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %82 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %lb.3 = ALLOCA/LOCAL size=20 align=4 + * %83 = GEP_FIELD offset=16 .e [%lb.3] // lb.e + * %84 = MEMORY/LOAD_LE_32 [%83] // lb.e + * %85 = CONST/INT32 5 // 5 + * %86 = CMP_NE [%84, %85] // lb.e != 5 + * >> %87 = COND_BRANCH [%86] // if (lb.e != 5) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %93 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * >> %94 = ENTER_SCOPE // sum_large(la) + * %95 = ALLOCA/ARG size=20 align=4 // la + * %la.2 = ALLOCA/LOCAL size=20 align=4 + * %96 = CONST/UINT64 20 + * >> %97 = MEMORY/MEMCPY [%95, %la.2, %96] // la + * %total.4 = ALLOCA/LOCAL size=4 align=4 + * %99 = CALL @sum_large [%95] // sum_large(la) + * >> %total.100 = MEMORY/STORE_LE_32 [%total.4, %99] + * >> %104 = EXIT_SCOPE + * %101 = MEMORY/LOAD_LE_32 [%total.4] // total + * %102 = CONST/INT32 15 // 15 + * %103 = CMP_NE [%101, %102] // total != 15 + * >> %105 = COND_BRANCH [%103] // if (total != 15) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %112 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * >> %113 = ENTER_SCOPE // make_small(100, 200) + * %115 = ALLOCA/ARG size=4 align=4 // 100 + * %114 = CONST/INT32 100 // 100 + * >> %116 = MEMORY/STORE_LE_32 [%115, %114] // 100 + * %118 = ALLOCA/ARG size=4 align=4 // 200 + * %117 = CONST/INT32 200 // 200 + * >> %119 = MEMORY/STORE_LE_32 [%118, %117] // 200 + * %c.5 = ALLOCA/LOCAL size=8 align=4 + * %121 = CALL @make_small [%115, %118] // make_small(100, 200) + * %122 = CONST/UINT64 8 + * >> %c.123 = MEMORY/MEMCPY [%c.5, %121, %122] + * >> %128 = EXIT_SCOPE + * %124 = GEP_FIELD offset=0 .x [%c.5] // c.x + * %125 = MEMORY/LOAD_LE_32 [%124] // c.x + * %126 = CONST/INT32 100 // 100 + * %127 = CMP_NE [%125, %126] // c.x != 100 + * >> %129 = COND_BRANCH [%127] // if (c.x != 100) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %136 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %c.5 = ALLOCA/LOCAL size=8 align=4 + * %137 = GEP_FIELD offset=4 .y [%c.5] // c.y + * %138 = MEMORY/LOAD_LE_32 [%137] // c.y + * %139 = CONST/INT32 200 // 200 + * %140 = CMP_NE [%138, %139] // c.y != 200 + * >> %141 = COND_BRANCH [%140] // if (c.y != 200) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %147 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %n1.6 = ALLOCA/LOCAL size=12 align=4 + * %148 = GEP_FIELD offset=0 .s [%n1.6] // n1.s + * %149 = GEP_FIELD offset=0 .x [%148] // n1.s.x + * %150 = CONST/INT32 1 // 1 + * >> %151 = MEMORY/STORE_LE_32 [%149, %150] // n1.s.x = 1 + * %152 = GEP_FIELD offset=0 .s [%n1.6] // n1.s + * %153 = GEP_FIELD offset=4 .y [%152] // n1.s.y + * %154 = CONST/INT32 2 // 2 + * >> %155 = MEMORY/STORE_LE_32 [%153, %154] // n1.s.y = 2 + * %156 = GEP_FIELD offset=8 .z [%n1.6] // n1.z + * %157 = CONST/INT32 3 // 3 + * >> %158 = MEMORY/STORE_LE_32 [%156, %157] // n1.z = 3 + * %n2.7 = ALLOCA/LOCAL size=12 align=4 + * %159 = CONST/UINT64 12 + * >> %n2.160 = MEMORY/MEMCPY [%n2.7, %n1.6, %159] + * %161 = GEP_FIELD offset=0 .s [%n2.7] // n2.s + * %162 = GEP_FIELD offset=0 .x [%161] // n2.s.x + * %163 = MEMORY/LOAD_LE_32 [%162] // n2.s.x + * %164 = CONST/INT32 1 // 1 + * %165 = CMP_NE [%163, %164] // n2.s.x != 1 + * >> %166 = COND_BRANCH [%165] // if (n2.s.x != 1) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %172 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %n2.7 = ALLOCA/LOCAL size=12 align=4 + * %173 = GEP_FIELD offset=8 .z [%n2.7] // n2.z + * %174 = MEMORY/LOAD_LE_32 [%173] // n2.z + * %175 = CONST/INT32 3 // 3 + * %176 = CMP_NE [%174, %175] // n2.z != 3 + * >> %177 = COND_BRANCH [%176] // if (n2.z != 3) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %183 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %d.8 = ALLOCA/LOCAL size=8 align=4 + * %184 = GEP_FIELD offset=0 .x [%d.8] // d.x + * %185 = CONST/INT32 0 // 0 + * >> %186 = MEMORY/STORE_LE_32 [%184, %185] // d.x = 0 + * %187 = GEP_FIELD offset=4 .y [%d.8] // d.y + * %188 = CONST/INT32 0 // 0 + * >> %189 = MEMORY/STORE_LE_32 [%187, %188] // d.y = 0 + * %a.0 = ALLOCA/LOCAL size=8 align=4 + * %190 = MEMORY/LOAD_LE_64 [%a.0] // a + * >> %191 = MEMORY/STORE_LE_64 [%d.8, %190] // d = a + * %192 = GEP_FIELD offset=0 .x [%d.8] // d.x + * %193 = MEMORY/LOAD_LE_32 [%192] // d.x + * %194 = CONST/INT32 10 // 10 + * %195 = CMP_NE [%193, %194] // d.x != 10 + * >> %196 = COND_BRANCH [%195] // if (d.x != 10) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %202 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %d.8 = ALLOCA/LOCAL size=8 align=4 + * %203 = GEP_FIELD offset=4 .y [%d.8] // d.y + * %204 = MEMORY/LOAD_LE_32 [%203] // d.y + * %205 = CONST/INT32 20 // 20 + * %206 = CMP_NE [%204, %205] // d.y != 20 + * >> %207 = COND_BRANCH [%206] // if (d.y != 20) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %213 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %215 = RETURN_PTR // return 0 + * %214 = CONST/INT32 0 // 0 + * >> %216 = MEMORY/STORE_LE_32 [%215, %214] // return 0 + * >> %217 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %218 = RET [%214] // return 0 + * block_35 IF_THEN <- [block_34]: + * %209 = RETURN_PTR // return 12 + * %208 = CONST/INT32 12 // 12 + * >> %210 = MEMORY/STORE_LE_32 [%209, %208] // return 12 + * >> %211 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %212 = RET [%208] // return 12 + * block_32 IF_THEN <- [block_31]: + * %198 = RETURN_PTR // return 11 + * %197 = CONST/INT32 11 // 11 + * >> %199 = MEMORY/STORE_LE_32 [%198, %197] // return 11 + * >> %200 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %201 = RET [%197] // return 11 + * block_29 IF_THEN <- [block_28]: + * %179 = RETURN_PTR // return 10 + * %178 = CONST/INT32 10 // 10 + * >> %180 = MEMORY/STORE_LE_32 [%179, %178] // return 10 + * >> %181 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %182 = RET [%178] // return 10 + * block_26 IF_THEN <- [block_25]: + * %168 = RETURN_PTR // return 9 + * %167 = CONST/INT32 9 // 9 + * >> %169 = MEMORY/STORE_LE_32 [%168, %167] // return 9 + * >> %170 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %171 = RET [%167] // return 9 + * block_23 IF_THEN <- [block_22]: + * %143 = RETURN_PTR // return 8 + * %142 = CONST/INT32 8 // 8 + * >> %144 = MEMORY/STORE_LE_32 [%143, %142] // return 8 + * >> %145 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %146 = RET [%142] // return 8 + * block_20 IF_THEN <- [block_19]: + * %131 = RETURN_PTR // return 7 + * %130 = CONST/INT32 7 // 7 + * >> %132 = MEMORY/STORE_LE_32 [%131, %130] // return 7 + * >> %133 = EXIT_SCOPE // make_small(100, 200) + * >> %134 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %135 = RET [%130] // return 7 + * block_17 IF_THEN <- [block_16]: + * %107 = RETURN_PTR // return 6 + * %106 = CONST/INT32 6 // 6 + * >> %108 = MEMORY/STORE_LE_32 [%107, %106] // return 6 + * >> %109 = EXIT_SCOPE // sum_large(la) + * >> %110 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %111 = RET [%106] // return 6 + * block_14 IF_THEN <- [block_13]: + * %89 = RETURN_PTR // return 5 + * %88 = CONST/INT32 5 // 5 + * >> %90 = MEMORY/STORE_LE_32 [%89, %88] // return 5 + * >> %91 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %92 = RET [%88] // return 5 + * block_11 IF_THEN <- [block_10]: + * %78 = RETURN_PTR // return 4 + * %77 = CONST/INT32 4 // 4 + * >> %79 = MEMORY/STORE_LE_32 [%78, %77] // return 4 + * >> %80 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %81 = RET [%77] // return 4 + * block_8 IF_THEN <- [block_7]: + * %50 = RETURN_PTR // return 3 + * %49 = CONST/INT32 3 // 3 + * >> %51 = MEMORY/STORE_LE_32 [%50, %49] // return 3 + * >> %52 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %53 = RET [%49] // return 3 + * block_5 IF_THEN <- [block_4]: + * %36 = RETURN_PTR // return 2 + * %35 = CONST/INT32 2 // 2 + * >> %37 = MEMORY/STORE_LE_32 [%36, %35] // return 2 + * >> %38 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %39 = RET [%35] // return 2 + * block_2 IF_THEN <- [block_1]: + * %25 = RETURN_PTR // return 1 + * %24 = CONST/INT32 1 // 1 + * >> %26 = MEMORY/STORE_LE_32 [%25, %24] // return 1 + * >> %27 = EXIT_SCOPE // { // Direct struct assignment: a = b → ME... + * >> %28 = RET [%24] // return 1 + * } + */ + + + + + + + + + + +struct Small { + int x; + int y; +}; + +struct Large { + int a; + int b; + int c; + int d; + int e; // 20 bytes — too big for scalar LOAD/STORE +}; + +struct Packed { + char a; + short b; + char c; + // 4 bytes with padding, but some ABIs may pack to 4 or 5 bytes +}; + +struct Nested { + struct Small s; + int z; +}; + +static struct Small make_small(int x, int y) { + struct Small s; + s.x = x; + s.y = y; + return s; +} + +static int sum_large(struct Large l) { + return l.a + l.b + l.c + l.d + l.e; +} + +int test_struct_assign(void) { + // Direct struct assignment: a = b → MEMCPY. + struct Small a; + a.x = 10; + a.y = 20; + struct Small b = a; // MEMCPY(b, a, sizeof(Small)) + if (b.x != 10) return 1; + if (b.y != 20) return 2; + + // Modify copy, original unchanged. + b.x = 99; + if (a.x != 10) return 3; + + // Large struct assignment. + struct Large la; + la.a = 1; la.b = 2; la.c = 3; la.d = 4; la.e = 5; + struct Large lb = la; // MEMCPY for 20-byte struct + if (lb.a != 1) return 4; + if (lb.e != 5) return 5; + + // Pass large struct to function (by value). + int total = sum_large(la); + if (total != 15) return 6; + + // Struct return. + struct Small c = make_small(100, 200); + if (c.x != 100) return 7; + if (c.y != 200) return 8; + + // Nested struct assignment. + struct Nested n1; + n1.s.x = 1; + n1.s.y = 2; + n1.z = 3; + struct Nested n2 = n1; + if (n2.s.x != 1) return 9; + if (n2.z != 3) return 10; + + // Re-assignment. + struct Small d; + d.x = 0; d.y = 0; + d = a; // a = b style assignment → MEMCPY + if (d.x != 10) return 11; + if (d.y != 20) return 12; + + return 0; +} diff --git a/tests/InterpretIR/test_switch.c b/tests/InterpretIR/test_switch.c new file mode 100644 index 000000000..323cb6ad8 --- /dev/null +++ b/tests/InterpretIR/test_switch.c @@ -0,0 +1,406 @@ +// Tests: switch statement (SWITCH, SWITCH_CASE, SWITCH_DEFAULT, SWITCH_EXIT), +// fallthrough (IMPLICIT_FALLTHROUGH), explicit fallthrough (FALLTHROUGH), +// break within switch (BREAK), nested switch, and switch with ranges (GNU). + +/* + * Expected IR: + * + * function test_switch (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (val) + * obj_1 LOCAL_VALUE size=4 align=4 (result) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %val.0 = ALLOCA/LOCAL size=4 align=4 + * >> %result.1 = ALLOCA/LOCAL size=4 align=4 + * >> %2 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %3 = ENTER_SCOPE // { // Basic switch. int val = 2; int... + * %val.0 = ALLOCA/LOCAL size=4 align=4 + * %4 = CONST/INT32 2 // 2 + * >> %val.5 = MEMORY/STORE_LE_32 [%val.0, %4] + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %6 = CONST/INT32 0 // 0 + * >> %result.7 = MEMORY/STORE_LE_32 [%result.1, %6] + * %8 = MEMORY/LOAD_LE_32 [%val.0] // val + * >> %9 = SWITCH cases=4 { 1->block_3, 2->block_4, 3->block_5, default->block_6 } [%8] // switch (val) { case 1: result = 10; bre... + * -> [block_3, block_4, block_5, block_6] + * block_6 SWITCH_DEFAULT <- [block_1]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %22 = CONST/INT32 1 // 1 + * %23 = NEG [%22] // -1 + * >> %24 = MEMORY/STORE_LE_32 [%result.1, %23] // result = -1 + * >> %25 = BREAK // break + * -> [block_2] + * block_5 SWITCH_CASE <- [block_1]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %18 = CONST/INT32 30 // 30 + * >> %19 = MEMORY/STORE_LE_32 [%result.1, %18] // result = 30 + * >> %20 = BREAK // break + * -> [block_2] + * block_4 SWITCH_CASE <- [block_1]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %14 = CONST/INT32 20 // 20 + * >> %15 = MEMORY/STORE_LE_32 [%result.1, %14] // result = 20 + * >> %16 = BREAK // break + * -> [block_2] + * block_3 SWITCH_CASE <- [block_1]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %10 = CONST/INT32 10 // 10 + * >> %11 = MEMORY/STORE_LE_32 [%result.1, %10] // result = 10 + * >> %12 = BREAK // break + * -> [block_2] + * block_2 SWITCH_EXIT <- [block_3, block_4, block_5, block_6]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %27 = MEMORY/LOAD_LE_32 [%result.1] // result + * %28 = CONST/INT32 20 // 20 + * %29 = CMP_NE [%27, %28] // result != 20 + * >> %30 = COND_BRANCH [%29] // if (result != 20) return 1 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_2]: + * >> %36 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %37 = CONST/INT32 99 // 99 + * >> %38 = SWITCH cases=2 { 1->block_15, default->block_16 } [%37] // switch (99) { case 1: result = 10; brea... + * -> [block_15, block_16] + * block_16 SWITCH_DEFAULT <- [block_13]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %43 = CONST/INT32 42 // 42 + * >> %44 = MEMORY/STORE_LE_32 [%result.1, %43] // result = 42 + * >> %45 = BREAK // break + * -> [block_14] + * block_15 SWITCH_CASE <- [block_13]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %39 = CONST/INT32 10 // 10 + * >> %40 = MEMORY/STORE_LE_32 [%result.1, %39] // result = 10 + * >> %41 = BREAK // break + * -> [block_14] + * block_14 SWITCH_EXIT <- [block_15, block_16]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %47 = MEMORY/LOAD_LE_32 [%result.1] // result + * %48 = CONST/INT32 42 // 42 + * %49 = CMP_NE [%47, %48] // result != 42 + * >> %50 = COND_BRANCH [%49] // if (result != 42) return 2 + * -> [block_19, block_20] + * block_20 IF_ELSE <- [block_14]: + * >> %56 = IMPLICIT_GOTO + * -> [block_21] + * block_21 IF_MERGE <- [block_20]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %57 = CONST/INT32 0 // 0 + * >> %58 = MEMORY/STORE_LE_32 [%result.1, %57] // result = 0 + * %59 = CONST/INT32 1 // 1 + * >> %60 = SWITCH cases=4 { 1->block_23, 2->block_24, 3->block_25, default->block_26 } [%59] // switch (1) { case 1: result += 1; ... + * -> [block_23, block_24, block_25, block_26] + * block_26 SWITCH_DEFAULT <- [block_21]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %71 = CONST/INT32 1 // 1 + * %72 = NEG [%71] // -1 + * >> %73 = MEMORY/STORE_LE_32 [%result.1, %72] // result = -1 + * >> %74 = BREAK // break + * -> [block_22] + * block_23 SWITCH_CASE <- [block_21]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %61 = CONST/INT32 1 // 1 + * >> %62 = READ_MODIFY_WRITE(ADD new) [%result.1, %61] // result += 1 + * >> %63 = IMPLICIT_FALLTHROUGH + * -> [block_24] + * block_24 SWITCH_CASE <- [block_21, block_23]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %64 = CONST/INT32 2 // 2 + * >> %65 = READ_MODIFY_WRITE(ADD new) [%result.1, %64] // result += 2 + * >> %66 = IMPLICIT_FALLTHROUGH + * -> [block_25] + * block_25 SWITCH_CASE <- [block_21, block_24]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %67 = CONST/INT32 3 // 3 + * >> %68 = READ_MODIFY_WRITE(ADD new) [%result.1, %67] // result += 3 + * >> %69 = BREAK // break + * -> [block_22] + * block_22 SWITCH_EXIT <- [block_25, block_26]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %76 = MEMORY/LOAD_LE_32 [%result.1] // result + * %77 = CONST/INT32 6 // 6 + * %78 = CMP_NE [%76, %77] // result != 6 + * >> %79 = COND_BRANCH [%78] // if (result != 6) return 3 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_22]: + * >> %85 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %86 = CONST/INT32 0 // 0 + * >> %87 = MEMORY/STORE_LE_32 [%result.1, %86] // result = 0 + * %88 = CONST/INT32 2 // 2 + * >> %89 = SWITCH cases=4 { 1->block_33, 2->block_34, 3->block_35, default->block_36 } [%88] // switch (2) { case 1: case 2: ... + * -> [block_33, block_34, block_35, block_36] + * block_36 SWITCH_DEFAULT <- [block_31]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %96 = CONST/INT32 1 // 1 + * %97 = NEG [%96] // -1 + * >> %98 = MEMORY/STORE_LE_32 [%result.1, %97] // result = -1 + * >> %99 = BREAK // break + * -> [block_32] + * block_33 SWITCH_CASE <- [block_31]: + * >> %90 = IMPLICIT_FALLTHROUGH + * -> [block_34] + * block_34 SWITCH_CASE <- [block_31, block_33]: + * >> %91 = IMPLICIT_FALLTHROUGH + * -> [block_35] + * block_35 SWITCH_CASE <- [block_31, block_34]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %92 = CONST/INT32 100 // 100 + * >> %93 = MEMORY/STORE_LE_32 [%result.1, %92] // result = 100 + * >> %94 = BREAK // break + * -> [block_32] + * block_32 SWITCH_EXIT <- [block_35, block_36]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %101 = MEMORY/LOAD_LE_32 [%result.1] // result + * %102 = CONST/INT32 100 // 100 + * %103 = CMP_NE [%101, %102] // result != 100 + * >> %104 = COND_BRANCH [%103] // if (result != 100) return 4 + * -> [block_39, block_40] + * block_40 IF_ELSE <- [block_32]: + * >> %110 = IMPLICIT_GOTO + * -> [block_41] + * block_41 IF_MERGE <- [block_40]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %111 = CONST/INT32 0 // 0 + * >> %112 = MEMORY/STORE_LE_32 [%result.1, %111] // result = 0 + * %113 = CONST/INT32 1 // 1 + * >> %114 = SWITCH cases=3 { 1->block_43, 2->block_44, default->block_45 } [%113] // switch (1) { case 1: switch... + * -> [block_43, block_44, block_45] + * block_45 SWITCH_DEFAULT <- [block_41]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %135 = CONST/INT32 90 // 90 + * >> %136 = MEMORY/STORE_LE_32 [%result.1, %135] // result = 90 + * >> %137 = BREAK // break + * -> [block_42] + * block_44 SWITCH_CASE <- [block_41]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %131 = CONST/INT32 80 // 80 + * >> %132 = MEMORY/STORE_LE_32 [%result.1, %131] // result = 80 + * >> %133 = BREAK // break + * -> [block_42] + * block_43 SWITCH_CASE <- [block_41]: + * %115 = CONST/INT32 10 // 10 + * >> %116 = SWITCH cases=3 { 10->block_47, 20->block_48, default->block_49 } [%115] // switch (10) { case 10: result =... + * -> [block_47, block_48, block_49] + * block_49 SWITCH_DEFAULT <- [block_43]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %125 = CONST/INT32 70 // 70 + * >> %126 = MEMORY/STORE_LE_32 [%result.1, %125] // result = 70 + * >> %127 = BREAK // break + * -> [block_46] + * block_48 SWITCH_CASE <- [block_43]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %121 = CONST/INT32 60 // 60 + * >> %122 = MEMORY/STORE_LE_32 [%result.1, %121] // result = 60 + * >> %123 = BREAK // break + * -> [block_46] + * block_47 SWITCH_CASE <- [block_43]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %117 = CONST/INT32 50 // 50 + * >> %118 = MEMORY/STORE_LE_32 [%result.1, %117] // result = 50 + * >> %119 = BREAK // break + * -> [block_46] + * block_46 SWITCH_EXIT <- [block_47, block_48, block_49]: + * >> %129 = BREAK // break + * -> [block_42] + * block_42 SWITCH_EXIT <- [block_46, block_44, block_45]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %139 = MEMORY/LOAD_LE_32 [%result.1] // result + * %140 = CONST/INT32 50 // 50 + * %141 = CMP_NE [%139, %140] // result != 50 + * >> %142 = COND_BRANCH [%141] // if (result != 50) return 5 + * -> [block_56, block_57] + * block_57 IF_ELSE <- [block_42]: + * >> %148 = IMPLICIT_GOTO + * -> [block_58] + * block_58 IF_MERGE <- [block_57]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %149 = CONST/INT32 0 // 0 + * >> %150 = MEMORY/STORE_LE_32 [%result.1, %149] // result = 0 + * %151 = CONST/INT32 2 // 2 + * >> %152 = SWITCH cases=3 { 1->block_60, 2->block_61, 3->block_62 } [%151] // switch (2) { case 1: result... + * -> [block_60, block_61, block_62] + * block_62 SWITCH_CASE <- [block_58]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %168 = CONST/INT32 1000 // 1000 + * >> %169 = READ_MODIFY_WRITE(ADD new) [%result.1, %168] // result += 1000 + * >> %170 = BREAK // break + * -> [block_59] + * block_60 SWITCH_CASE <- [block_58]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %153 = CONST/INT32 1 // 1 + * >> %154 = READ_MODIFY_WRITE(ADD new) [%result.1, %153] // result += 1 + * >> %155 = IMPLICIT_FALLTHROUGH + * -> [block_61] + * block_61 SWITCH_CASE <- [block_58, block_60]: + * %156 = CONST/INT32 20 // 20 + * >> %157 = SWITCH cases=2 { 10->block_64, 20->block_65 } [%156] // switch (20) { case 10: result +... + * -> [block_64, block_65] + * block_65 SWITCH_CASE <- [block_61]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %162 = CONST/INT32 200 // 200 + * >> %163 = READ_MODIFY_WRITE(ADD new) [%result.1, %162] // result += 200 + * >> %164 = BREAK // break + * -> [block_63] + * block_64 SWITCH_CASE <- [block_61]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %158 = CONST/INT32 100 // 100 + * >> %159 = READ_MODIFY_WRITE(ADD new) [%result.1, %158] // result += 100 + * >> %160 = BREAK // break + * -> [block_63] + * block_63 SWITCH_EXIT <- [block_64, block_65]: + * >> %166 = BREAK // break + * -> [block_59] + * block_59 SWITCH_EXIT <- [block_63, block_62]: + * %result.1 = ALLOCA/LOCAL size=4 align=4 + * %172 = MEMORY/LOAD_LE_32 [%result.1] // result + * %173 = CONST/INT32 200 // 200 + * %174 = CMP_NE [%172, %173] // result != 200 + * >> %175 = COND_BRANCH [%174] // if (result != 200) return 6 + * -> [block_70, block_71] + * block_71 IF_ELSE <- [block_59]: + * >> %181 = IMPLICIT_GOTO + * -> [block_72] + * block_72 IF_MERGE <- [block_71]: + * %183 = RETURN_PTR // return 0 + * %182 = CONST/INT32 0 // 0 + * >> %184 = MEMORY/STORE_LE_32 [%183, %182] // return 0 + * >> %185 = EXIT_SCOPE // { // Basic switch. int val = 2; int... + * >> %186 = RET [%182] // return 0 + * block_70 IF_THEN <- [block_59]: + * %177 = RETURN_PTR // return 6 + * %176 = CONST/INT32 6 // 6 + * >> %178 = MEMORY/STORE_LE_32 [%177, %176] // return 6 + * >> %179 = EXIT_SCOPE // { // Basic switch. int val = 2; int... + * >> %180 = RET [%176] // return 6 + * block_56 IF_THEN <- [block_42]: + * %144 = RETURN_PTR // return 5 + * %143 = CONST/INT32 5 // 5 + * >> %145 = MEMORY/STORE_LE_32 [%144, %143] // return 5 + * >> %146 = EXIT_SCOPE // { // Basic switch. int val = 2; int... + * >> %147 = RET [%143] // return 5 + * block_39 IF_THEN <- [block_32]: + * %106 = RETURN_PTR // return 4 + * %105 = CONST/INT32 4 // 4 + * >> %107 = MEMORY/STORE_LE_32 [%106, %105] // return 4 + * >> %108 = EXIT_SCOPE // { // Basic switch. int val = 2; int... + * >> %109 = RET [%105] // return 4 + * block_29 IF_THEN <- [block_22]: + * %81 = RETURN_PTR // return 3 + * %80 = CONST/INT32 3 // 3 + * >> %82 = MEMORY/STORE_LE_32 [%81, %80] // return 3 + * >> %83 = EXIT_SCOPE // { // Basic switch. int val = 2; int... + * >> %84 = RET [%80] // return 3 + * block_19 IF_THEN <- [block_14]: + * %52 = RETURN_PTR // return 2 + * %51 = CONST/INT32 2 // 2 + * >> %53 = MEMORY/STORE_LE_32 [%52, %51] // return 2 + * >> %54 = EXIT_SCOPE // { // Basic switch. int val = 2; int... + * >> %55 = RET [%51] // return 2 + * block_11 IF_THEN <- [block_2]: + * %32 = RETURN_PTR // return 1 + * %31 = CONST/INT32 1 // 1 + * >> %33 = MEMORY/STORE_LE_32 [%32, %31] // return 1 + * >> %34 = EXIT_SCOPE // { // Basic switch. int val = 2; int... + * >> %35 = RET [%31] // return 1 + * } + */ + + + + + + + + + + +int test_switch(void) { + // Basic switch. + int val = 2; + int result = 0; + switch (val) { + case 1: result = 10; break; + case 2: result = 20; break; + case 3: result = 30; break; + default: result = -1; break; + } + if (result != 20) return 1; + + // Default case. + switch (99) { + case 1: result = 10; break; + default: result = 42; break; + } + if (result != 42) return 2; + + // Fallthrough (implicit). + result = 0; + switch (1) { + case 1: result += 1; + case 2: result += 2; + case 3: result += 3; break; + default: result = -1; break; + } + if (result != 6) return 3; // 1+2+3 from fallthrough + + // Empty cases. + result = 0; + switch (2) { + case 1: + case 2: + case 3: + result = 100; + break; + default: + result = -1; + break; + } + if (result != 100) return 4; + + // Nested switch: inner switch cases must not leak into outer switch. + result = 0; + switch (1) { + case 1: + switch (10) { + case 10: result = 50; break; + case 20: result = 60; break; + default: result = 70; break; + } + break; + case 2: + result = 80; + break; + default: + result = 90; + break; + } + if (result != 50) return 5; + + // Nested switch with outer fallthrough. + result = 0; + switch (2) { + case 1: + result += 1; + case 2: + switch (20) { + case 10: result += 100; break; + case 20: result += 200; break; + } + break; + case 3: + result += 1000; + break; + } + if (result != 200) return 6; + + return 0; +} diff --git a/tests/InterpretIR/test_unsigned.c b/tests/InterpretIR/test_unsigned.c new file mode 100644 index 000000000..d2c86df2a --- /dev/null +++ b/tests/InterpretIR/test_unsigned.c @@ -0,0 +1,526 @@ +// Tests: unsigned integer operations — zero extension, unsigned arithmetic, +// unsigned comparisons, unsigned overflow/wrap-around, mixing signed/unsigned. + +/* + * Expected IR: + * + * function test_unsigned (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (ua) + * obj_1 LOCAL_VALUE size=4 align=4 (ub) + * obj_2 LOCAL_VALUE size=4 align=4 (sum) + * obj_3 LOCAL_VALUE size=4 align=4 (diff) + * obj_4 LOCAL_VALUE size=4 align=4 (wrapped) + * obj_5 LOCAL_VALUE size=1 align=1 (uc) + * obj_6 LOCAL_VALUE size=4 align=4 (zext) + * obj_7 LOCAL_VALUE size=1 align=1 (sc) + * obj_8 LOCAL_VALUE size=4 align=4 (sext) + * obj_9 LOCAL_VALUE size=4 align=4 (udiv) + * obj_10 LOCAL_VALUE size=4 align=4 (umod) + * obj_11 LOCAL_VALUE size=4 align=4 (large) + * obj_12 LOCAL_VALUE size=4 align=4 (half) + * obj_13 LOCAL_VALUE size=4 align=4 (shifted) + * obj_14 LOCAL_VALUE size=4 align=4 (rshifted) + * obj_15 LOCAL_VALUE size=4 align=4 (uval) + * obj_16 LOCAL_VALUE size=4 align=4 (high) + * obj_17 LOCAL_VALUE size=4 align=4 (low) + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %ua.0 = ALLOCA/LOCAL size=4 align=4 + * >> %ub.1 = ALLOCA/LOCAL size=4 align=4 + * >> %sum.2 = ALLOCA/LOCAL size=4 align=4 + * >> %diff.3 = ALLOCA/LOCAL size=4 align=4 + * >> %wrapped.4 = ALLOCA/LOCAL size=4 align=4 + * >> %uc.5 = ALLOCA/LOCAL size=1 align=1 + * >> %zext.6 = ALLOCA/LOCAL size=4 align=4 + * >> %sc.7 = ALLOCA/LOCAL size=1 align=1 + * >> %sext.8 = ALLOCA/LOCAL size=4 align=4 + * >> %udiv.9 = ALLOCA/LOCAL size=4 align=4 + * >> %umod.10 = ALLOCA/LOCAL size=4 align=4 + * >> %large.11 = ALLOCA/LOCAL size=4 align=4 + * >> %half.12 = ALLOCA/LOCAL size=4 align=4 + * >> %shifted.13 = ALLOCA/LOCAL size=4 align=4 + * >> %rshifted.14 = ALLOCA/LOCAL size=4 align=4 + * >> %uval.15 = ALLOCA/LOCAL size=4 align=4 + * >> %high.16 = ALLOCA/LOCAL size=4 align=4 + * >> %low.17 = ALLOCA/LOCAL size=4 align=4 + * >> %18 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %19 = ENTER_SCOPE // { // Basic unsigned values. unsigned in... + * %ua.0 = ALLOCA/LOCAL size=4 align=4 + * %20 = CONST/INT32 200 // 200 + * %21 = CAST/IDENTITY [%20] // 200 + * >> %ua.22 = MEMORY/STORE_LE_32 [%ua.0, %21] + * %ub.1 = ALLOCA/LOCAL size=4 align=4 + * %23 = CONST/INT32 100 // 100 + * %24 = CAST/IDENTITY [%23] // 100 + * >> %ub.25 = MEMORY/STORE_LE_32 [%ub.1, %24] + * %sum.2 = ALLOCA/LOCAL size=4 align=4 + * %26 = MEMORY/LOAD_LE_32 [%ua.0] // ua + * %27 = MEMORY/LOAD_LE_32 [%ub.1] // ub + * %28 = ADD [%26, %27] // ua + ub + * >> %sum.29 = MEMORY/STORE_LE_32 [%sum.2, %28] + * %30 = MEMORY/LOAD_LE_32 [%sum.2] // sum + * %31 = CONST/INT32 300 // 300 + * %32 = CAST/IDENTITY [%31] // 300 + * %33 = CMP_NE [%30, %32] // sum != 300 + * >> %34 = COND_BRANCH [%33] // if (sum != 300) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %40 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * %diff.3 = ALLOCA/LOCAL size=4 align=4 + * %ua.0 = ALLOCA/LOCAL size=4 align=4 + * %41 = MEMORY/LOAD_LE_32 [%ua.0] // ua + * %ub.1 = ALLOCA/LOCAL size=4 align=4 + * %42 = MEMORY/LOAD_LE_32 [%ub.1] // ub + * %43 = SUB [%41, %42] // ua - ub + * >> %diff.44 = MEMORY/STORE_LE_32 [%diff.3, %43] + * %45 = MEMORY/LOAD_LE_32 [%diff.3] // diff + * %46 = CONST/INT32 100 // 100 + * %47 = CAST/IDENTITY [%46] // 100 + * %48 = CMP_NE [%45, %47] // diff != 100 + * >> %49 = COND_BRANCH [%48] // if (diff != 100) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %55 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * %ua.0 = ALLOCA/LOCAL size=4 align=4 + * %56 = MEMORY/LOAD_LE_32 [%ua.0] // ua + * %ub.1 = ALLOCA/LOCAL size=4 align=4 + * %57 = MEMORY/LOAD_LE_32 [%ub.1] // ub + * %58 = UCMP_GT [%56, %57] // ua > ub + * %59 = LOGICAL_NOT [%58] // !(ua > ub) + * >> %60 = COND_BRANCH [%59] // if (!(ua > ub)) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %66 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * %ua.0 = ALLOCA/LOCAL size=4 align=4 + * %67 = MEMORY/LOAD_LE_32 [%ua.0] // ua + * %ub.1 = ALLOCA/LOCAL size=4 align=4 + * %68 = MEMORY/LOAD_LE_32 [%ub.1] // ub + * %69 = UCMP_LT [%67, %68] // ua < ub + * >> %70 = COND_BRANCH [%69] // if (ua < ub) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %76 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * %ua.0 = ALLOCA/LOCAL size=4 align=4 + * %77 = MEMORY/LOAD_LE_32 [%ua.0] // ua + * %ub.1 = ALLOCA/LOCAL size=4 align=4 + * %78 = MEMORY/LOAD_LE_32 [%ub.1] // ub + * %79 = CMP_EQ [%77, %78] // ua == ub + * >> %80 = COND_BRANCH [%79] // if (ua == ub) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %86 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %wrapped.4 = ALLOCA/LOCAL size=4 align=4 + * %87 = CONST/UINT32 0 // 0u + * %88 = CONST/UINT32 1 // 1u + * %89 = SUB [%87, %88] // 0u - 1u + * >> %wrapped.90 = MEMORY/STORE_LE_32 [%wrapped.4, %89] + * %91 = MEMORY/LOAD_LE_32 [%wrapped.4] // wrapped + * %92 = CONST/UINT32 4294967295 // 4294967295u + * %93 = CMP_NE [%91, %92] // wrapped != 4294967295u + * >> %94 = COND_BRANCH [%93] // if (wrapped != 4294967295u) return 6 + * -> [block_17, block_18] + * block_18 IF_ELSE <- [block_16]: + * >> %100 = IMPLICIT_GOTO + * -> [block_19] + * block_19 IF_MERGE <- [block_18]: + * %uc.5 = ALLOCA/LOCAL size=1 align=1 + * %101 = CONST/INT32 200 // 200 + * %102 = CAST/TRUNC_I32_I8 [%101] // 200 + * >> %uc.103 = MEMORY/STORE_LE_8 [%uc.5, %102] + * %zext.6 = ALLOCA/LOCAL size=4 align=4 + * %104 = MEMORY/LOAD_LE_8 [%uc.5] // uc + * %105 = CAST/ZEXT_I8_I32 [%104] // uc + * >> %zext.106 = MEMORY/STORE_LE_32 [%zext.6, %105] + * %107 = MEMORY/LOAD_LE_32 [%zext.6] // zext + * %108 = CONST/INT32 200 // 200 + * %109 = CAST/IDENTITY [%108] // 200 + * %110 = CMP_NE [%107, %109] // zext != 200 + * >> %111 = COND_BRANCH [%110] // if (zext != 200) return 7 + * -> [block_20, block_21] + * block_21 IF_ELSE <- [block_19]: + * >> %117 = IMPLICIT_GOTO + * -> [block_22] + * block_22 IF_MERGE <- [block_21]: + * %sc.7 = ALLOCA/LOCAL size=1 align=1 + * %118 = CONST/INT32 5 // 5 + * %119 = NEG [%118] // -5 + * %120 = CAST/TRUNC_I32_I8 [%119] // -5 + * >> %sc.121 = MEMORY/STORE_LE_8 [%sc.7, %120] + * %sext.8 = ALLOCA/LOCAL size=4 align=4 + * %122 = MEMORY/LOAD_LE_8 [%sc.7] // sc + * %123 = CAST/SEXT_I8_I32 [%122] // sc + * >> %sext.124 = MEMORY/STORE_LE_32 [%sext.8, %123] + * %125 = MEMORY/LOAD_LE_32 [%sext.8] // sext + * %126 = CONST/INT32 5 // 5 + * %127 = NEG [%126] // -5 + * %128 = CMP_NE [%125, %127] // sext != -5 + * >> %129 = COND_BRANCH [%128] // if (sext != -5) return 8 + * -> [block_23, block_24] + * block_24 IF_ELSE <- [block_22]: + * >> %135 = IMPLICIT_GOTO + * -> [block_25] + * block_25 IF_MERGE <- [block_24]: + * %udiv.9 = ALLOCA/LOCAL size=4 align=4 + * %136 = CONST/UINT32 10 // 10u + * %137 = CONST/UINT32 3 // 3u + * %138 = UDIV [%136, %137] // 10u / 3u + * >> %udiv.139 = MEMORY/STORE_LE_32 [%udiv.9, %138] + * %140 = MEMORY/LOAD_LE_32 [%udiv.9] // udiv + * %141 = CONST/INT32 3 // 3 + * %142 = CAST/IDENTITY [%141] // 3 + * %143 = CMP_NE [%140, %142] // udiv != 3 + * >> %144 = COND_BRANCH [%143] // if (udiv != 3) return 9 + * -> [block_26, block_27] + * block_27 IF_ELSE <- [block_25]: + * >> %150 = IMPLICIT_GOTO + * -> [block_28] + * block_28 IF_MERGE <- [block_27]: + * %umod.10 = ALLOCA/LOCAL size=4 align=4 + * %151 = CONST/UINT32 10 // 10u + * %152 = CONST/UINT32 3 // 3u + * %153 = UREM [%151, %152] // 10u % 3u + * >> %umod.154 = MEMORY/STORE_LE_32 [%umod.10, %153] + * %155 = MEMORY/LOAD_LE_32 [%umod.10] // umod + * %156 = CONST/INT32 1 // 1 + * %157 = CAST/IDENTITY [%156] // 1 + * %158 = CMP_NE [%155, %157] // umod != 1 + * >> %159 = COND_BRANCH [%158] // if (umod != 1) return 10 + * -> [block_29, block_30] + * block_30 IF_ELSE <- [block_28]: + * >> %165 = IMPLICIT_GOTO + * -> [block_31] + * block_31 IF_MERGE <- [block_30]: + * %large.11 = ALLOCA/LOCAL size=4 align=4 + * %166 = CONST/UINT32 4294967295 // 0xFFFFFFFF + * >> %large.167 = MEMORY/STORE_LE_32 [%large.11, %166] + * %168 = MEMORY/LOAD_LE_32 [%large.11] // large + * %169 = CONST/UINT32 4294967295 // 4294967295u + * %170 = CMP_NE [%168, %169] // large != 4294967295u + * >> %171 = COND_BRANCH [%170] // if (large != 4294967295u) return 11 + * -> [block_32, block_33] + * block_33 IF_ELSE <- [block_31]: + * >> %177 = IMPLICIT_GOTO + * -> [block_34] + * block_34 IF_MERGE <- [block_33]: + * %half.12 = ALLOCA/LOCAL size=4 align=4 + * %large.11 = ALLOCA/LOCAL size=4 align=4 + * %178 = MEMORY/LOAD_LE_32 [%large.11] // large + * %179 = CONST/INT32 2 // 2 + * %180 = CAST/IDENTITY [%179] // 2 + * %181 = UDIV [%178, %180] // large / 2 + * >> %half.182 = MEMORY/STORE_LE_32 [%half.12, %181] + * %183 = MEMORY/LOAD_LE_32 [%half.12] // half + * %184 = CONST/UINT32 2147483647 // 2147483647u + * %185 = CMP_NE [%183, %184] // half != 2147483647u + * >> %186 = COND_BRANCH [%185] // if (half != 2147483647u) return 12 + * -> [block_35, block_36] + * block_36 IF_ELSE <- [block_34]: + * >> %192 = IMPLICIT_GOTO + * -> [block_37] + * block_37 IF_MERGE <- [block_36]: + * %shifted.13 = ALLOCA/LOCAL size=4 align=4 + * %193 = CONST/UINT32 1 // 1u + * %194 = CONST/INT32 31 // 31 + * %195 = SHL [%193, %194] // 1u << 31 + * >> %shifted.196 = MEMORY/STORE_LE_32 [%shifted.13, %195] + * %197 = MEMORY/LOAD_LE_32 [%shifted.13] // shifted + * %198 = CONST/UINT32 2147483648 // 2147483648u + * %199 = CMP_NE [%197, %198] // shifted != 2147483648u + * >> %200 = COND_BRANCH [%199] // if (shifted != 2147483648u) return 13 + * -> [block_38, block_39] + * block_39 IF_ELSE <- [block_37]: + * >> %206 = IMPLICIT_GOTO + * -> [block_40] + * block_40 IF_MERGE <- [block_39]: + * %rshifted.14 = ALLOCA/LOCAL size=4 align=4 + * %shifted.13 = ALLOCA/LOCAL size=4 align=4 + * %207 = MEMORY/LOAD_LE_32 [%shifted.13] // shifted + * %208 = CONST/INT32 1 // 1 + * %209 = USHR [%207, %208] // shifted >> 1 + * >> %rshifted.210 = MEMORY/STORE_LE_32 [%rshifted.14, %209] + * %211 = MEMORY/LOAD_LE_32 [%rshifted.14] // rshifted + * %212 = CONST/UINT32 1073741824 // 1073741824u + * %213 = CMP_NE [%211, %212] // rshifted != 1073741824u + * >> %214 = COND_BRANCH [%213] // if (rshifted != 1073741824u) return 14 + * -> [block_41, block_42] + * block_42 IF_ELSE <- [block_40]: + * >> %220 = IMPLICIT_GOTO + * -> [block_43] + * block_43 IF_MERGE <- [block_42]: + * %uval.15 = ALLOCA/LOCAL size=4 align=4 + * %221 = CONST/INT32 42 // 42 + * %222 = CAST/IDENTITY [%221] // 42 + * >> %uval.223 = MEMORY/STORE_LE_32 [%uval.15, %222] + * %224 = MEMORY/LOAD_LE_32 [%uval.15] // uval + * %225 = CONST/INT32 42 // 42 + * %226 = CAST/IDENTITY [%225] // 42 + * %227 = CMP_NE [%224, %226] // uval != 42 + * >> %228 = COND_BRANCH [%227] // if (uval != 42) return 15 + * -> [block_44, block_45] + * block_45 IF_ELSE <- [block_43]: + * >> %234 = IMPLICIT_GOTO + * -> [block_46] + * block_46 IF_MERGE <- [block_45]: + * %high.16 = ALLOCA/LOCAL size=4 align=4 + * %235 = CONST/UINT32 2147483649 // 0x80000001u + * >> %high.236 = MEMORY/STORE_LE_32 [%high.16, %235] + * %low.17 = ALLOCA/LOCAL size=4 align=4 + * %237 = CONST/UINT32 1 // 1u + * >> %low.238 = MEMORY/STORE_LE_32 [%low.17, %237] + * %239 = MEMORY/LOAD_LE_32 [%high.16] // high + * %240 = MEMORY/LOAD_LE_32 [%low.17] // low + * %241 = UCMP_GT [%239, %240] // high > low + * %242 = LOGICAL_NOT [%241] // !(high > low) + * >> %243 = COND_BRANCH [%242] // if (!(high > low)) return 16 + * -> [block_47, block_48] + * block_48 IF_ELSE <- [block_46]: + * >> %249 = IMPLICIT_GOTO + * -> [block_49] + * block_49 IF_MERGE <- [block_48]: + * %high.16 = ALLOCA/LOCAL size=4 align=4 + * %250 = MEMORY/LOAD_LE_32 [%high.16] // high + * %low.17 = ALLOCA/LOCAL size=4 align=4 + * %251 = MEMORY/LOAD_LE_32 [%low.17] // low + * %252 = UCMP_LT [%250, %251] // high < low + * >> %253 = COND_BRANCH [%252] // if (high < low) return 17 + * -> [block_50, block_51] + * block_51 IF_ELSE <- [block_49]: + * >> %259 = IMPLICIT_GOTO + * -> [block_52] + * block_52 IF_MERGE <- [block_51]: + * %high.16 = ALLOCA/LOCAL size=4 align=4 + * %260 = MEMORY/LOAD_LE_32 [%high.16] // high + * %low.17 = ALLOCA/LOCAL size=4 align=4 + * %261 = MEMORY/LOAD_LE_32 [%low.17] // low + * %262 = UCMP_LE [%260, %261] // high <= low + * >> %263 = COND_BRANCH [%262] // if (high <= low) return 18 + * -> [block_53, block_54] + * block_54 IF_ELSE <- [block_52]: + * >> %269 = IMPLICIT_GOTO + * -> [block_55] + * block_55 IF_MERGE <- [block_54]: + * %high.16 = ALLOCA/LOCAL size=4 align=4 + * %270 = MEMORY/LOAD_LE_32 [%high.16] // high + * %low.17 = ALLOCA/LOCAL size=4 align=4 + * %271 = MEMORY/LOAD_LE_32 [%low.17] // low + * %272 = UCMP_GE [%270, %271] // high >= low + * %273 = LOGICAL_NOT [%272] // !(high >= low) + * >> %274 = COND_BRANCH [%273] // if (!(high >= low)) return 19 + * -> [block_56, block_57] + * block_57 IF_ELSE <- [block_55]: + * >> %280 = IMPLICIT_GOTO + * -> [block_58] + * block_58 IF_MERGE <- [block_57]: + * %282 = RETURN_PTR // return 0 + * %281 = CONST/INT32 0 // 0 + * >> %283 = MEMORY/STORE_LE_32 [%282, %281] // return 0 + * >> %284 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %285 = RET [%281] // return 0 + * block_56 IF_THEN <- [block_55]: + * %276 = RETURN_PTR // return 19 + * %275 = CONST/INT32 19 // 19 + * >> %277 = MEMORY/STORE_LE_32 [%276, %275] // return 19 + * >> %278 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %279 = RET [%275] // return 19 + * block_53 IF_THEN <- [block_52]: + * %265 = RETURN_PTR // return 18 + * %264 = CONST/INT32 18 // 18 + * >> %266 = MEMORY/STORE_LE_32 [%265, %264] // return 18 + * >> %267 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %268 = RET [%264] // return 18 + * block_50 IF_THEN <- [block_49]: + * %255 = RETURN_PTR // return 17 + * %254 = CONST/INT32 17 // 17 + * >> %256 = MEMORY/STORE_LE_32 [%255, %254] // return 17 + * >> %257 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %258 = RET [%254] // return 17 + * block_47 IF_THEN <- [block_46]: + * %245 = RETURN_PTR // return 16 + * %244 = CONST/INT32 16 // 16 + * >> %246 = MEMORY/STORE_LE_32 [%245, %244] // return 16 + * >> %247 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %248 = RET [%244] // return 16 + * block_44 IF_THEN <- [block_43]: + * %230 = RETURN_PTR // return 15 + * %229 = CONST/INT32 15 // 15 + * >> %231 = MEMORY/STORE_LE_32 [%230, %229] // return 15 + * >> %232 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %233 = RET [%229] // return 15 + * block_41 IF_THEN <- [block_40]: + * %216 = RETURN_PTR // return 14 + * %215 = CONST/INT32 14 // 14 + * >> %217 = MEMORY/STORE_LE_32 [%216, %215] // return 14 + * >> %218 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %219 = RET [%215] // return 14 + * block_38 IF_THEN <- [block_37]: + * %202 = RETURN_PTR // return 13 + * %201 = CONST/INT32 13 // 13 + * >> %203 = MEMORY/STORE_LE_32 [%202, %201] // return 13 + * >> %204 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %205 = RET [%201] // return 13 + * block_35 IF_THEN <- [block_34]: + * %188 = RETURN_PTR // return 12 + * %187 = CONST/INT32 12 // 12 + * >> %189 = MEMORY/STORE_LE_32 [%188, %187] // return 12 + * >> %190 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %191 = RET [%187] // return 12 + * block_32 IF_THEN <- [block_31]: + * %173 = RETURN_PTR // return 11 + * %172 = CONST/INT32 11 // 11 + * >> %174 = MEMORY/STORE_LE_32 [%173, %172] // return 11 + * >> %175 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %176 = RET [%172] // return 11 + * block_29 IF_THEN <- [block_28]: + * %161 = RETURN_PTR // return 10 + * %160 = CONST/INT32 10 // 10 + * >> %162 = MEMORY/STORE_LE_32 [%161, %160] // return 10 + * >> %163 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %164 = RET [%160] // return 10 + * block_26 IF_THEN <- [block_25]: + * %146 = RETURN_PTR // return 9 + * %145 = CONST/INT32 9 // 9 + * >> %147 = MEMORY/STORE_LE_32 [%146, %145] // return 9 + * >> %148 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %149 = RET [%145] // return 9 + * block_23 IF_THEN <- [block_22]: + * %131 = RETURN_PTR // return 8 + * %130 = CONST/INT32 8 // 8 + * >> %132 = MEMORY/STORE_LE_32 [%131, %130] // return 8 + * >> %133 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %134 = RET [%130] // return 8 + * block_20 IF_THEN <- [block_19]: + * %113 = RETURN_PTR // return 7 + * %112 = CONST/INT32 7 // 7 + * >> %114 = MEMORY/STORE_LE_32 [%113, %112] // return 7 + * >> %115 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %116 = RET [%112] // return 7 + * block_17 IF_THEN <- [block_16]: + * %96 = RETURN_PTR // return 6 + * %95 = CONST/INT32 6 // 6 + * >> %97 = MEMORY/STORE_LE_32 [%96, %95] // return 6 + * >> %98 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %99 = RET [%95] // return 6 + * block_14 IF_THEN <- [block_13]: + * %82 = RETURN_PTR // return 5 + * %81 = CONST/INT32 5 // 5 + * >> %83 = MEMORY/STORE_LE_32 [%82, %81] // return 5 + * >> %84 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %85 = RET [%81] // return 5 + * block_11 IF_THEN <- [block_10]: + * %72 = RETURN_PTR // return 4 + * %71 = CONST/INT32 4 // 4 + * >> %73 = MEMORY/STORE_LE_32 [%72, %71] // return 4 + * >> %74 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %75 = RET [%71] // return 4 + * block_8 IF_THEN <- [block_7]: + * %62 = RETURN_PTR // return 3 + * %61 = CONST/INT32 3 // 3 + * >> %63 = MEMORY/STORE_LE_32 [%62, %61] // return 3 + * >> %64 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %65 = RET [%61] // return 3 + * block_5 IF_THEN <- [block_4]: + * %51 = RETURN_PTR // return 2 + * %50 = CONST/INT32 2 // 2 + * >> %52 = MEMORY/STORE_LE_32 [%51, %50] // return 2 + * >> %53 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %54 = RET [%50] // return 2 + * block_2 IF_THEN <- [block_1]: + * %36 = RETURN_PTR // return 1 + * %35 = CONST/INT32 1 // 1 + * >> %37 = MEMORY/STORE_LE_32 [%36, %35] // return 1 + * >> %38 = EXIT_SCOPE // { // Basic unsigned values. unsigned in... + * >> %39 = RET [%35] // return 1 + * } + */ + + + + + + + + + + +int test_unsigned(void) { + // Basic unsigned values. + unsigned int ua = 200; + unsigned int ub = 100; + + // Unsigned arithmetic. + unsigned int sum = ua + ub; + if (sum != 300) return 1; + + unsigned int diff = ua - ub; + if (diff != 100) return 2; + + // Unsigned comparison. + if (!(ua > ub)) return 3; + if (ua < ub) return 4; + if (ua == ub) return 5; + + // Unsigned wrap-around (underflow). + unsigned int wrapped = 0u - 1u; + if (wrapped != 4294967295u) return 6; + + // Unsigned char to unsigned int (zero extension). + unsigned char uc = 200; + unsigned int zext = uc; + if (zext != 200) return 7; + + // Signed char to int (sign extension). + signed char sc = -5; + int sext = sc; + if (sext != -5) return 8; + + // Unsigned division. + unsigned int udiv = 10u / 3u; + if (udiv != 3) return 9; + + // Unsigned modulo. + unsigned int umod = 10u % 3u; + if (umod != 1) return 10; + + // Large unsigned values. + unsigned int large = 0xFFFFFFFF; + if (large != 4294967295u) return 11; + + unsigned int half = large / 2; + if (half != 2147483647u) return 12; + + // Unsigned shift. + unsigned int shifted = 1u << 31; + if (shifted != 2147483648u) return 13; + + unsigned int rshifted = shifted >> 1; + if (rshifted != 1073741824u) return 14; + + // Mixing: unsigned compared to signed constant. + unsigned int uval = 42; + if (uval != 42) return 15; + + // Unsigned comparison with high-bit values (would fail with signed CMP). + unsigned int high = 0x80000001u; + unsigned int low = 1u; + if (!(high > low)) return 16; // 2147483649 > 1, true unsigned + if (high < low) return 17; // false unsigned + if (high <= low) return 18; // false unsigned + if (!(high >= low)) return 19; // true unsigned + + return 0; +} diff --git a/tests/InterpretIR/test_unsigned_compound.c b/tests/InterpretIR/test_unsigned_compound.c new file mode 100644 index 000000000..ea25505b5 --- /dev/null +++ b/tests/InterpretIR/test_unsigned_compound.c @@ -0,0 +1,37 @@ +// Tests: unsigned compound assignment operators that must use UDIV/UREM/USHR +// instead of signed DIV/REM/SHR. Also tests unsigned pre/post increment. + +int test_unsigned_compound(void) { + // Unsigned right shift (logical, not arithmetic). + unsigned int u = 0x80000000u; // high bit set + u >>= 1; + // Logical shift: 0x80000000 >> 1 = 0x40000000 + if (u != 0x40000000u) return 1; + + // Unsigned division. + unsigned int a = 0xFFFFFFFFu; // 4294967295 + a /= 2u; + if (a != 2147483647u) return 2; + + // Unsigned remainder. + unsigned int b = 0xFFFFFFFFu; + b %= 10u; + if (b != 5u) return 3; // 4294967295 % 10 = 5 + + // Unsigned increment (should wrap). + unsigned int c = 0xFFFFFFFFu; + c++; + if (c != 0u) return 4; + + // Unsigned decrement (should wrap). + unsigned int d = 0u; + d--; + if (d != 0xFFFFFFFFu) return 5; + + // Unsigned compound add. + unsigned int e = 0xFFFFFFF0u; + e += 0x20u; + if (e != 0x10u) return 6; // wraps + + return 0; +} diff --git a/tests/InterpretIR/test_variadics.c b/tests/InterpretIR/test_variadics.c new file mode 100644 index 000000000..d9be94063 --- /dev/null +++ b/tests/InterpretIR/test_variadics.c @@ -0,0 +1,279 @@ +// Tests: variadic function handling (VA_START, VA_END, VA_COPY, +// CONSUME_VA_PARAM via MEMORY sub-opcode), va_arg with different types. + +/* + * Expected IR: + * + * function test_variadics (NORMAL) { + * objects: + * obj_0 LOCAL_VALUE size=4 align=4 (s1) + * obj_1 LOCAL_VALUE size=4 align=4 (s2) + * obj_2 LOCAL_VALUE size=4 align=4 (s3) + * obj_3 LOCAL_VALUE size=4 align=4 (first) + * obj_4 LOCAL_VALUE size=4 align=4 (copy_result) + * obj_5 PARAMETER size=4 align=4 + * obj_6 PARAMETER size=4 align=4 + * obj_7 PARAMETER size=4 align=4 + * obj_8 PARAMETER size=4 align=4 + * obj_9 RETURN_SLOT size=4 align=4 + * obj_10 PARAMETER size=4 align=4 + * obj_11 PARAMETER size=4 align=4 + * obj_12 RETURN_SLOT size=4 align=4 + * obj_13 PARAMETER size=4 align=4 + * obj_14 RETURN_SLOT size=4 align=4 + * obj_15 PARAMETER size=4 align=4 + * obj_16 PARAMETER size=4 align=4 + * obj_17 RETURN_SLOT size=4 align=4 + * obj_18 PARAMETER size=4 align=4 + * obj_19 PARAMETER size=4 align=4 + * obj_20 PARAMETER size=4 align=4 + * obj_21 PARAMETER size=4 align=4 + * obj_22 RETURN_SLOT size=4 align=4 + * body_scope: FUNCTION_SCOPE + * + * blocks: + * block_0 FRAME: + * >> %s1.0 = ALLOCA/LOCAL size=4 align=4 + * >> %s2.1 = ALLOCA/LOCAL size=4 align=4 + * >> %s3.2 = ALLOCA/LOCAL size=4 align=4 + * >> %first.3 = ALLOCA/LOCAL size=4 align=4 + * >> %copy_result.4 = ALLOCA/LOCAL size=4 align=4 + * >> %5 = IMPLICIT_GOTO + * -> [block_1] + * block_1 ENTRY <- [block_0]: + * >> %6 = ENTER_SCOPE // { // Basic variadic sum. int s1 = va_su... + * >> %7 = ENTER_SCOPE // va_sum(3, 10, 20, 30) + * %9 = ALLOCA/ARG size=4 align=4 // 3 + * %8 = CONST/INT32 3 // 3 + * >> %10 = MEMORY/STORE_LE_32 [%9, %8] // 3 + * %12 = ALLOCA/ARG size=4 align=4 // 10 + * %11 = CONST/INT32 10 // 10 + * >> %13 = MEMORY/STORE_LE_32 [%12, %11] // 10 + * %15 = ALLOCA/ARG size=4 align=4 // 20 + * %14 = CONST/INT32 20 // 20 + * >> %16 = MEMORY/STORE_LE_32 [%15, %14] // 20 + * %18 = ALLOCA/ARG size=4 align=4 // 30 + * %17 = CONST/INT32 30 // 30 + * >> %19 = MEMORY/STORE_LE_32 [%18, %17] // 30 + * %s1.0 = ALLOCA/LOCAL size=4 align=4 + * %21 = CALL @va_sum [%9, %12, %15, %18] // va_sum(3, 10, 20, 30) + * >> %s1.22 = MEMORY/STORE_LE_32 [%s1.0, %21] + * >> %26 = EXIT_SCOPE + * %23 = MEMORY/LOAD_LE_32 [%s1.0] // s1 + * %24 = CONST/INT32 60 // 60 + * %25 = CMP_NE [%23, %24] // s1 != 60 + * >> %27 = COND_BRANCH [%25] // if (s1 != 60) return 1 + * -> [block_2, block_3] + * block_3 IF_ELSE <- [block_1]: + * >> %34 = IMPLICIT_GOTO + * -> [block_4] + * block_4 IF_MERGE <- [block_3]: + * >> %35 = ENTER_SCOPE // va_sum(1, 42) + * %37 = ALLOCA/ARG size=4 align=4 // 1 + * %36 = CONST/INT32 1 // 1 + * >> %38 = MEMORY/STORE_LE_32 [%37, %36] // 1 + * %40 = ALLOCA/ARG size=4 align=4 // 42 + * %39 = CONST/INT32 42 // 42 + * >> %41 = MEMORY/STORE_LE_32 [%40, %39] // 42 + * %s2.1 = ALLOCA/LOCAL size=4 align=4 + * %43 = CALL @va_sum [%37, %40] // va_sum(1, 42) + * >> %s2.44 = MEMORY/STORE_LE_32 [%s2.1, %43] + * >> %48 = EXIT_SCOPE + * %45 = MEMORY/LOAD_LE_32 [%s2.1] // s2 + * %46 = CONST/INT32 42 // 42 + * %47 = CMP_NE [%45, %46] // s2 != 42 + * >> %49 = COND_BRANCH [%47] // if (s2 != 42) return 2 + * -> [block_5, block_6] + * block_6 IF_ELSE <- [block_4]: + * >> %56 = IMPLICIT_GOTO + * -> [block_7] + * block_7 IF_MERGE <- [block_6]: + * >> %57 = ENTER_SCOPE // va_sum(0) + * %59 = ALLOCA/ARG size=4 align=4 // 0 + * %58 = CONST/INT32 0 // 0 + * >> %60 = MEMORY/STORE_LE_32 [%59, %58] // 0 + * %s3.2 = ALLOCA/LOCAL size=4 align=4 + * %62 = CALL @va_sum [%59] // va_sum(0) + * >> %s3.63 = MEMORY/STORE_LE_32 [%s3.2, %62] + * >> %67 = EXIT_SCOPE + * %64 = MEMORY/LOAD_LE_32 [%s3.2] // s3 + * %65 = CONST/INT32 0 // 0 + * %66 = CMP_NE [%64, %65] // s3 != 0 + * >> %68 = COND_BRANCH [%66] // if (s3 != 0) return 3 + * -> [block_8, block_9] + * block_9 IF_ELSE <- [block_7]: + * >> %75 = IMPLICIT_GOTO + * -> [block_10] + * block_10 IF_MERGE <- [block_9]: + * >> %76 = ENTER_SCOPE // va_first_int(0, 99) + * %78 = ALLOCA/ARG size=4 align=4 // 0 + * %77 = CONST/INT32 0 // 0 + * >> %79 = MEMORY/STORE_LE_32 [%78, %77] // 0 + * %81 = ALLOCA/ARG size=4 align=4 // 99 + * %80 = CONST/INT32 99 // 99 + * >> %82 = MEMORY/STORE_LE_32 [%81, %80] // 99 + * %first.3 = ALLOCA/LOCAL size=4 align=4 + * %84 = CALL @va_first_int [%78, %81] // va_first_int(0, 99) + * >> %first.85 = MEMORY/STORE_LE_32 [%first.3, %84] + * >> %89 = EXIT_SCOPE + * %86 = MEMORY/LOAD_LE_32 [%first.3] // first + * %87 = CONST/INT32 99 // 99 + * %88 = CMP_NE [%86, %87] // first != 99 + * >> %90 = COND_BRANCH [%88] // if (first != 99) return 4 + * -> [block_11, block_12] + * block_12 IF_ELSE <- [block_10]: + * >> %97 = IMPLICIT_GOTO + * -> [block_13] + * block_13 IF_MERGE <- [block_12]: + * >> %98 = ENTER_SCOPE // va_copy_test(3, 10, 20, 30) + * %100 = ALLOCA/ARG size=4 align=4 // 3 + * %99 = CONST/INT32 3 // 3 + * >> %101 = MEMORY/STORE_LE_32 [%100, %99] // 3 + * %103 = ALLOCA/ARG size=4 align=4 // 10 + * %102 = CONST/INT32 10 // 10 + * >> %104 = MEMORY/STORE_LE_32 [%103, %102] // 10 + * %106 = ALLOCA/ARG size=4 align=4 // 20 + * %105 = CONST/INT32 20 // 20 + * >> %107 = MEMORY/STORE_LE_32 [%106, %105] // 20 + * %109 = ALLOCA/ARG size=4 align=4 // 30 + * %108 = CONST/INT32 30 // 30 + * >> %110 = MEMORY/STORE_LE_32 [%109, %108] // 30 + * %copy_result.4 = ALLOCA/LOCAL size=4 align=4 + * %112 = CALL @va_copy_test [%100, %103, %106, %109] // va_copy_test(3, 10, 20, 30) + * >> %copy_result.113 = MEMORY/STORE_LE_32 [%copy_result.4, %112] + * >> %117 = EXIT_SCOPE + * %114 = MEMORY/LOAD_LE_32 [%copy_result.4] // copy_result + * %115 = CONST/INT32 50 // 50 + * %116 = CMP_NE [%114, %115] // copy_result != 50 + * >> %118 = COND_BRANCH [%116] // if (copy_result != 50) return 5 + * -> [block_14, block_15] + * block_15 IF_ELSE <- [block_13]: + * >> %125 = IMPLICIT_GOTO + * -> [block_16] + * block_16 IF_MERGE <- [block_15]: + * %127 = RETURN_PTR // return 0 + * %126 = CONST/INT32 0 // 0 + * >> %128 = MEMORY/STORE_LE_32 [%127, %126] // return 0 + * >> %129 = EXIT_SCOPE // { // Basic variadic sum. int s1 = va_su... + * >> %130 = RET [%126] // return 0 + * block_14 IF_THEN <- [block_13]: + * %120 = RETURN_PTR // return 5 + * %119 = CONST/INT32 5 // 5 + * >> %121 = MEMORY/STORE_LE_32 [%120, %119] // return 5 + * >> %122 = EXIT_SCOPE // va_copy_test(3, 10, 20, 30) + * >> %123 = EXIT_SCOPE // { // Basic variadic sum. int s1 = va_su... + * >> %124 = RET [%119] // return 5 + * block_11 IF_THEN <- [block_10]: + * %92 = RETURN_PTR // return 4 + * %91 = CONST/INT32 4 // 4 + * >> %93 = MEMORY/STORE_LE_32 [%92, %91] // return 4 + * >> %94 = EXIT_SCOPE // va_first_int(0, 99) + * >> %95 = EXIT_SCOPE // { // Basic variadic sum. int s1 = va_su... + * >> %96 = RET [%91] // return 4 + * block_8 IF_THEN <- [block_7]: + * %70 = RETURN_PTR // return 3 + * %69 = CONST/INT32 3 // 3 + * >> %71 = MEMORY/STORE_LE_32 [%70, %69] // return 3 + * >> %72 = EXIT_SCOPE // va_sum(0) + * >> %73 = EXIT_SCOPE // { // Basic variadic sum. int s1 = va_su... + * >> %74 = RET [%69] // return 3 + * block_5 IF_THEN <- [block_4]: + * %51 = RETURN_PTR // return 2 + * %50 = CONST/INT32 2 // 2 + * >> %52 = MEMORY/STORE_LE_32 [%51, %50] // return 2 + * >> %53 = EXIT_SCOPE // va_sum(1, 42) + * >> %54 = EXIT_SCOPE // { // Basic variadic sum. int s1 = va_su... + * >> %55 = RET [%50] // return 2 + * block_2 IF_THEN <- [block_1]: + * %29 = RETURN_PTR // return 1 + * %28 = CONST/INT32 1 // 1 + * >> %30 = MEMORY/STORE_LE_32 [%29, %28] // return 1 + * >> %31 = EXIT_SCOPE // va_sum(3, 10, 20, 30) + * >> %32 = EXIT_SCOPE // { // Basic variadic sum. int s1 = va_su... + * >> %33 = RET [%28] // return 1 + * } + */ + + + + + + + + + + +#include + +static int va_sum(int count, ...) { + va_list ap; + va_start(ap, count); + int total = 0; + for (int i = 0; i < count; i++) { + total += va_arg(ap, int); + } + va_end(ap); + return total; +} + +static int va_first_int(int dummy, ...) { + va_list ap; + va_start(ap, dummy); + int result = va_arg(ap, int); + va_end(ap); + return result; +} + +static double va_sum_doubles(int count, ...) { + va_list ap; + va_start(ap, count); + double total = 0.0; + for (int i = 0; i < count; i++) { + total += va_arg(ap, double); + } + va_end(ap); + return total; +} + +static int va_copy_test(int count, ...) { + va_list ap, ap2; + va_start(ap, count); + + // Read first element. + int first = va_arg(ap, int); + + // Copy va_list and read from copy. + va_copy(ap2, ap); + int second_from_copy = va_arg(ap2, int); + va_end(ap2); + + // Read from original (should give same second element). + int second_from_orig = va_arg(ap, int); + + va_end(ap); + return first + second_from_copy + second_from_orig; +} + +int test_variadics(void) { + // Basic variadic sum. + int s1 = va_sum(3, 10, 20, 30); + if (s1 != 60) return 1; + + // Single variadic arg. + int s2 = va_sum(1, 42); + if (s2 != 42) return 2; + + // Zero variadic args. + int s3 = va_sum(0); + if (s3 != 0) return 3; + + // First int extraction. + int first = va_first_int(0, 99); + if (first != 99) return 4; + + // va_copy: first=10, second=20, result = 10 + 20 + 20 = 50. + int copy_result = va_copy_test(3, 10, 20, 30); + if (copy_result != 50) return 5; + + return 0; +} diff --git a/tests/InterpretIR/test_width_arithmetic.c b/tests/InterpretIR/test_width_arithmetic.c new file mode 100644 index 000000000..4151f9346 --- /dev/null +++ b/tests/InterpretIR/test_width_arithmetic.c @@ -0,0 +1,133 @@ +// Tests: sized integer arithmetic at all 4 widths (8/16/32/64). +// Verifies ADD, SUB, MUL, DIV, REM, NEG, BIT_NOT at each width, +// plus unsigned UDIV, UREM, USHR. +// Each operation is tested with values that exercise the width boundary. + +#include + +int test_width_arithmetic(void) { + // --- 8-bit signed --- + { + signed char a = 100, b = 27; + if ((signed char)(a + b) != 127) return 1; + if ((signed char)(a - b) != 73) return 2; + if ((signed char)(a * 2) != (signed char)200) return 3; // wraps to -56 + signed char d = -120; + if (d / 4 != -30) return 4; + if (d % 7 != -1) return 5; // -120 % 7 = -1 + if (-d != 120) return 6; + signed char e = 0x55; + if ((signed char)(~e) != (signed char)0xAA) return 7; + } + + // --- 8-bit unsigned --- + { + unsigned char ua = 200, ub = 7; + if (ua / ub != 28) return 10; // 200/7 = 28 + if (ua % ub != 4) return 11; // 200%7 = 4 + unsigned char uc = 0x80; + if ((uc >> 1) != 0x40) return 12; // logical shift + } + + // --- 16-bit signed --- + { + short a = 30000, b = 2767; + if ((short)(a + b) != 32767) return 20; + if ((short)(a - b) != 27233) return 21; + if ((short)(a * 2) != (short)60000) return 22; // wraps to -5536 + short d = -30000; + if (d / 100 != -300) return 23; + if (d % 100 != 0) return 24; + if (-d != 30000) return 25; + short e = 0x5555; + if ((short)(~e) != (short)0xAAAA) return 26; + } + + // --- 16-bit unsigned --- + { + unsigned short ua = 50000, ub = 7; + if (ua / ub != 7142) return 30; // 50000/7 = 7142 + if (ua % ub != 6) return 31; // 50000%7 = 6 + unsigned short uc = 0x8000; + if ((uc >> 1) != 0x4000) return 32; + } + + // --- 32-bit signed --- + { + int a = 2000000000, b = 147483647; + if (a + b != 2147483647) return 40; + if (a - b != 1852516353) return 41; + int d = -2000000000; + if (d / 100 != -20000000) return 42; + if (d % 100 != 0) return 43; + if (-d != 2000000000) return 44; + int e = 0x55555555; + if (~e != (int)0xAAAAAAAA) return 45; + } + + // --- 32-bit unsigned --- + { + unsigned int ua = 4000000000u, ub = 7; + if (ua / ub != 571428571u) return 50; + if (ua % ub != 3u) return 51; + unsigned int uc = 0x80000000u; + if ((uc >> 1) != 0x40000000u) return 52; + } + + // --- 64-bit signed --- + { + long long a = 4000000000LL, b = 3000000000LL; + if (a + b != 7000000000LL) return 60; + if (a - b != 1000000000LL) return 61; + if (a * 2 != 8000000000LL) return 62; + long long d = -9000000000LL; + if (d / 1000 != -9000000LL) return 63; + if (d % 1000 != 0) return 64; + if (-d != 9000000000LL) return 65; + } + + // --- 64-bit unsigned --- + { + unsigned long long ua = 18000000000000000000ULL, ub = 7; + if (ua / ub != 2571428571428571428ULL) return 70; + if (ua % ub != 4ULL) return 71; + unsigned long long uc = 0x8000000000000000ULL; + if ((uc >> 1) != 0x4000000000000000ULL) return 72; + } + + // --- Shifts at all widths --- + { + signed char s8 = 1; + if ((signed char)(s8 << 6) != 64) return 80; + signed char neg = -128; + if ((signed char)(neg >> 1) != -64) return 81; // arithmetic shift + + short s16 = 1; + if ((short)(s16 << 14) != 16384) return 82; + + int s32 = 1; + if (s32 << 30 != 1073741824) return 83; + + long long s64 = 1LL; + if (s64 << 62 != 4611686018427387904LL) return 84; + } + + // --- Bitwise at all widths --- + { + signed char a8 = 0x3C, b8 = 0x5A; + if ((a8 & b8) != 0x18) return 90; + if ((a8 | b8) != 0x7E) return 91; + if ((a8 ^ b8) != 0x66) return 92; + + short a16 = 0x3C3C, b16 = 0x5A5A; + if ((a16 & b16) != 0x1818) return 93; + + int a32 = 0x3C3C3C3C, b32 = 0x5A5A5A5A; + if ((a32 & b32) != 0x18181818) return 94; + + long long a64 = 0x3C3C3C3C3C3C3C3CLL, b64 = 0x5A5A5A5A5A5A5A5ALL; + if ((a64 & b64) != 0x1818181818181818LL) return 95; + } + + return 0; +} diff --git a/tests/InterpretIR/test_width_comparisons.c b/tests/InterpretIR/test_width_comparisons.c new file mode 100644 index 000000000..25993bb09 --- /dev/null +++ b/tests/InterpretIR/test_width_comparisons.c @@ -0,0 +1,114 @@ +// Tests: sized comparisons at all widths (8/16/32/64), signed and unsigned. +// Also tests float comparisons at both 32 and 64 bit precision. + +int test_width_comparisons(void) { + // --- 8-bit signed --- + { + signed char a = -1, b = 1; + if (!(a == a)) return 1; + if (!(a != b)) return 2; + if (!(a < b)) return 3; + if (!(a <= a)) return 4; + if (!(b > a)) return 5; + if (!(b >= b)) return 6; + } + + // --- 8-bit unsigned --- + { + unsigned char a = 255, b = 0; + if (!(a > b)) return 10; // 255 > 0 unsigned + if (!(a >= a)) return 11; + if (!(b < a)) return 12; + if (!(b <= b)) return 13; + // Key: 255 as signed char is -1, which is < 0. As unsigned, 255 > 0. + } + + // --- 16-bit signed --- + { + short a = -32000, b = 32000; + if (!(a < b)) return 20; + if (!(b > a)) return 21; + if (a == b) return 22; + if (!(a != b)) return 23; + } + + // --- 16-bit unsigned --- + { + unsigned short a = 65535, b = 0; + if (!(a > b)) return 30; + if (b >= a) return 31; + } + + // --- 32-bit signed --- + { + int a = -2000000000, b = 2000000000; + if (!(a < b)) return 40; + if (!(a <= a)) return 41; + if (!(b > a)) return 42; + if (!(b >= b)) return 43; + if (a == b) return 44; + if (!(a != b)) return 45; + } + + // --- 32-bit unsigned --- + { + unsigned int a = 4000000000u, b = 1; + if (!(a > b)) return 50; + if (a < b) return 51; + // As signed, 4000000000 is negative. As unsigned, it's > 1. + } + + // --- 64-bit signed --- + { + long long a = -9000000000000000000LL, b = 9000000000000000000LL; + if (!(a < b)) return 60; + if (!(b > a)) return 61; + if (a == b) return 62; + } + + // --- 64-bit unsigned --- + { + unsigned long long a = 18000000000000000000ULL, b = 1; + if (!(a > b)) return 70; + if (a < b) return 71; + } + + // --- Float 32-bit comparisons --- + { + float a = 1.0f / 3.0f, b = 0.5f; + if (!(a < b)) return 80; + if (!(b > a)) return 81; + if (a == b) return 82; + if (!(a != b)) return 83; + if (!(a <= b)) return 84; + if (!(b >= a)) return 85; + + // NaN comparisons (if supported). + // float nan = 0.0f / 0.0f; + // All comparisons with NaN should be false except !=. + } + + // --- Float 64-bit comparisons --- + { + double a = 1.0 / 3.0, b = 0.5; + if (!(a < b)) return 90; + if (!(b > a)) return 91; + if (a == b) return 92; + if (!(a != b)) return 93; + } + + // --- Cross-width comparison: values equal in wider type but differ in narrow --- + { + // 16777217 can't be represented exactly in float (rounds to 16777216). + // In double, it's exact. This tests that float comparisons use float precision. + float f1 = 16777216.0f; + float f2 = 16777217.0f; // rounds to 16777216.0f in float + if (f1 != f2) return 100; // should be equal in float! + + double d1 = 16777216.0; + double d2 = 16777217.0; + if (d1 == d2) return 101; // should be different in double + } + + return 0; +} diff --git a/tests/InterpretIR/test_width_rmw.c b/tests/InterpretIR/test_width_rmw.c new file mode 100644 index 000000000..9417070fa --- /dev/null +++ b/tests/InterpretIR/test_width_rmw.c @@ -0,0 +1,167 @@ +// Tests: READ_MODIFY_WRITE at all widths for compound assignment and +// pre/post increment/decrement, including unsigned variants. +// Covers: ADD, SUB, MUL, DIV, REM, AND, OR, XOR, SHL, SHR (signed), +// UDIV, UREM, USHR (unsigned), all at 8/16/32/64 bit widths. + +int test_width_rmw(void) { + // --- 8-bit compound assign --- + { + signed char x = 100; + x += 20; + if (x != 120) return 1; + x -= 10; + if (x != 110) return 2; + x *= 2; + if (x != (signed char)220) return 3; // wraps to -36 + x = 120; + x /= 4; + if (x != 30) return 4; + x = 100; + x %= 7; + if (x != 2) return 5; + x = 0x3C; + x &= 0x5A; + if (x != 0x18) return 6; + x = 0x3C; + x |= 0x5A; + if (x != 0x7E) return 7; + x = 0x3C; + x ^= 0x5A; + if (x != 0x66) return 8; + x = 1; + x <<= 6; + if (x != 64) return 9; + x = -128; + x >>= 1; + if (x != -64) return 10; // arithmetic shift + } + + // --- 8-bit unsigned compound assign --- + { + unsigned char u = 200; + u /= 7; + if (u != 28) return 15; // 200/7 = 28 + u = 200; + u %= 7; + if (u != 4) return 16; + u = 0x80; + u >>= 1; + if (u != 0x40) return 17; // logical shift + } + + // --- 16-bit compound assign --- + { + short x = 30000; + x += 2000; + if (x != 32000) return 20; + x -= 1000; + if (x != 31000) return 21; + x = 1000; + x *= 30; + if (x != 30000) return 22; + x /= 100; + if (x != 300) return 23; + x %= 7; + if (x != 6) return 24; + } + + // --- 16-bit unsigned --- + { + unsigned short u = 50000; + u /= 7; + if (u != 7142) return 30; + u = 50000; + u %= 7; + if (u != 6) return 31; + u = 0x8000; + u >>= 1; + if (u != 0x4000) return 32; + } + + // --- 32-bit compound assign --- + { + int x = 1000000000; + x += 500000000; + if (x != 1500000000) return 40; + x -= 250000000; + if (x != 1250000000) return 41; + x = 100000; + x *= 10000; + if (x != 1000000000) return 42; + x /= 100; + if (x != 10000000) return 43; + x %= 7; + if (x != 3) return 44; + } + + // --- 32-bit unsigned --- + { + unsigned int u = 0x80000000u; + u >>= 1; + if (u != 0x40000000u) return 50; + u = 4000000000u; + u /= 7; + if (u != 571428571u) return 51; + } + + // --- 64-bit compound assign --- + { + long long x = 4000000000LL; + x += 3000000000LL; + if (x != 7000000000LL) return 60; + x -= 2000000000LL; + if (x != 5000000000LL) return 61; + x = 1000000LL; + x *= 1000000LL; + if (x != 1000000000000LL) return 62; + x /= 1000; + if (x != 1000000000LL) return 63; + x %= 7; + if (x != 6) return 64; + } + + // --- 64-bit unsigned --- + { + unsigned long long u = 0x8000000000000000ULL; + u >>= 1; + if (u != 0x4000000000000000ULL) return 70; + } + + // --- Pre/post increment at different widths --- + { + signed char c = 126; + ++c; + if (c != 127) return 80; + c++; + if (c != -128) return 81; // wraps + + short s = 32766; + ++s; + if (s != 32767) return 82; + + unsigned char uc = 255; + uc++; + if (uc != 0) return 83; // wraps + + long long ll = 9000000000000000000LL; + ll++; + if (ll != 9000000000000000001LL) return 84; + } + + // --- Pre/post decrement at different widths --- + { + signed char c = -127; + --c; + if (c != -128) return 90; + + unsigned char uc = 0; + uc--; + if (uc != 255) return 91; // wraps + + long long ll = -9000000000000000000LL; + --ll; + if (ll != -9000000000000000001LL) return 92; + } + + return 0; +} diff --git a/vendor/sqlite/CMakeLists.txt b/vendor/sqlite/CMakeLists.txt index 72f95f5c8..b75f4cc2a 100644 --- a/vendor/sqlite/CMakeLists.txt +++ b/vendor/sqlite/CMakeLists.txt @@ -14,8 +14,8 @@ endif() FetchContent_Declare( sqlite - URL https://www.sqlite.org/2024/sqlite-amalgamation-3460100.zip - URL_HASH SHA3_256=af6aae8d3eccc608857c63cf56efbadc70da48b5c719446b353ed88dded1e288 + URL https://www.sqlite.org/2026/sqlite-amalgamation-3530000.zip + URL_HASH SHA3_256=c2325c53b3b41761469f91cfb078e96882ac5d85bac10c11b0bd8f253b031e5b ) FetchContent_MakeAvailable(sqlite)