pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/include/rbs/util/rbs_assert.h

@@ -0,0 +1,20 @@
+#ifndef RBS_ASSERT_H
+#define RBS_ASSERT_H
+
+#include "rbs/defines.h"
+#include <stdbool.h>
+
+/**
+ * RBS_ASSERT macro that calls rbs_assert in debug builds and is removed in release builds.
+ * In debug mode, it forwards all arguments to the rbs_assert function.
+ * In release mode, it expands to nothing.
+ */
+#ifdef NDEBUG
+#define RBS_ASSERT(condition, ...) ((void) 0)
+#else
+#define RBS_ASSERT(condition, ...) rbs_assert_impl(condition, __VA_ARGS__)
+#endif
+
+void rbs_assert_impl(bool condition, const char *fmt, ...) RBS_ATTRIBUTE_FORMAT(2, 3);
+
+#endif

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/include/rbs/util/rbs_buffer.h

@@ -0,0 +1,83 @@
+#ifndef RBS__RBS_BUFFER_H
+#define RBS__RBS_BUFFER_H
+
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/string.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * The default capacity of a rbs_buffer_t.
+ * If the buffer needs to grow beyond this capacity, it will be doubled.
+ */
+#define RBS_BUFFER_DEFAULT_CAPACITY 128
+
+/**
+ * A rbs_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
+ */
+typedef struct {
+    /** The length of the buffer in bytes. */
+    size_t length;
+
+    /** The capacity of the buffer in bytes that has been allocated. */
+    size_t capacity;
+
+    /** A pointer to the start of the buffer. */
+    char *value;
+} rbs_buffer_t;
+
+/**
+ * Initialize a rbs_buffer_t with its default values.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to initialize.
+ * @returns True if the buffer was initialized successfully, false otherwise.
+ */
+bool rbs_buffer_init(rbs_allocator_t *, rbs_buffer_t *buffer);
+
+/**
+ * Return the value of the buffer.
+ *
+ * @param buffer The buffer to get the value of.
+ * @returns The value of the buffer.
+ */
+char *rbs_buffer_value(const rbs_buffer_t *buffer);
+
+/**
+ * Return the length of the buffer.
+ *
+ * @param buffer The buffer to get the length of.
+ * @returns The length of the buffer.
+ */
+size_t rbs_buffer_length(const rbs_buffer_t *buffer);
+
+/**
+ * Append a C string to the buffer.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to append to.
+ * @param value The C string to append.
+ */
+void rbs_buffer_append_cstr(rbs_allocator_t *, rbs_buffer_t *buffer, const char *value);
+
+/**
+ * Append a string to the buffer.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to append to.
+ * @param value The string to append.
+ * @param length The length of the string to append.
+ */
+void rbs_buffer_append_string(rbs_allocator_t *, rbs_buffer_t *buffer, const char *value, size_t length);
+
+/**
+ * Convert the buffer to a rbs_string_t.
+ *
+ * @param buffer The buffer to convert.
+ * @returns The converted rbs_string_t.
+ */
+rbs_string_t rbs_buffer_to_string(rbs_buffer_t *buffer);
+
+#endif

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/include/rbs/util/rbs_constant_pool.h

@@ -0,0 +1,155 @@
+/**
+ * @file rbs_constant_pool.h
+ *
+ * A data structure that stores a set of strings.
+ *
+ * Each string is assigned a unique id, which can be used to compare strings for
+ * equality. This comparison ends up being much faster than strcmp, since it
+ * only requires a single integer comparison.
+ */
+#ifndef RBS_CONSTANT_POOL_H
+#define RBS_CONSTANT_POOL_H
+
+#include "rbs/util/rbs_encoding.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * When we allocate constants into the pool, we reserve 0 to mean that the slot
+ * is not yet filled. This constant is reused in other places to indicate the
+ * lack of a constant id.
+ */
+#define RBS_CONSTANT_ID_UNSET 0
+
+/**
+ * A constant id is a unique identifier for a constant in the constant pool.
+ */
+typedef uint32_t rbs_constant_id_t;
+
+/**
+ * The type of bucket in the constant pool hash map. This determines how the
+ * bucket should be freed.
+ */
+typedef unsigned int rbs_constant_pool_bucket_type_t;
+
+/** By default, each constant is a slice of the source. */
+static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_DEFAULT = 0;
+
+/** An owned constant is one for which memory has been allocated. */
+static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_OWNED = 1;
+
+/** A constant constant is known at compile time. */
+static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_CONSTANT = 2;
+
+/** A bucket in the hash map. */
+typedef struct {
+    /** The incremental ID used for indexing back into the pool. */
+    unsigned int id : 30;
+
+    /** The type of the bucket, which determines how to free it. */
+    rbs_constant_pool_bucket_type_t type : 2;
+
+    /** The hash of the bucket. */
+    uint32_t hash;
+} rbs_constant_pool_bucket_t;
+
+/** A constant in the pool which effectively stores a string. */
+typedef struct {
+    /** A pointer to the start of the string. */
+    const uint8_t *start;
+
+    /** The length of the string. */
+    size_t length;
+} rbs_constant_t;
+
+/** The overall constant pool, which stores constants found while parsing. */
+typedef struct {
+    /** The buckets in the hash map. */
+    rbs_constant_pool_bucket_t *buckets;
+
+    /** The constants that are stored in the buckets. */
+    rbs_constant_t *constants;
+
+    /** The number of buckets in the hash map. */
+    uint32_t size;
+
+    /** The number of buckets that have been allocated in the hash map. */
+    uint32_t capacity;
+} rbs_constant_pool_t;
+
+/**
+ * Initialize a new constant pool with a given capacity.
+ *
+ * @param pool The pool to initialize.
+ * @param capacity The initial capacity of the pool.
+ * @return Whether the initialization succeeded.
+ */
+bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity);
+
+/**
+ * Return a pointer to the constant indicated by the given constant id.
+ *
+ * @param pool The pool to get the constant from.
+ * @param constant_id The id of the constant to get.
+ * @return A pointer to the constant.
+ */
+rbs_constant_t *rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_id_t constant_id);
+
+/**
+ * Find a constant in a constant pool. Returns the id of the constant, or 0 if
+ * the constant is not found.
+ *
+ * @param pool The pool to find the constant in.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_find(const rbs_constant_pool_t *pool, const uint8_t *start, size_t length);
+
+/**
+ * Insert a constant into a constant pool that is a slice of a source string.
+ * Returns the id of the constant, or 0 if any potential calls to resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_insert_shared(rbs_constant_pool_t *pool, const uint8_t *start, size_t length);
+rbs_constant_id_t rbs_constant_pool_insert_shared_with_encoding(rbs_constant_pool_t *pool, const uint8_t *start, size_t length, const rbs_encoding_t *encoding);
+
+/**
+ * Insert a constant into a constant pool from memory that is now owned by the
+ * constant pool. Returns the id of the constant, or 0 if any potential calls to
+ * resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_insert_owned(rbs_constant_pool_t *pool, uint8_t *start, size_t length);
+
+/**
+ * Insert a constant into a constant pool from memory that is constant. Returns
+ * the id of the constant, or 0 if any potential calls to resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_insert_constant(rbs_constant_pool_t *pool, const uint8_t *start, size_t length);
+
+/**
+ * Free the memory associated with a constant pool.
+ *
+ * @param pool The pool to free.
+ */
+void rbs_constant_pool_free(rbs_constant_pool_t *pool);
+
+#endif

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/include/rbs/util/rbs_encoding.h

@@ -0,0 +1,282 @@
+/**
+ * @file encoding.h
+ *
+ * The encoding interface and implementations used by the parser.
+ */
+#ifndef RBS_RBS_ENCODING_H
+#define RBS_RBS_ENCODING_H
+
+#include "rbs/defines.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * This struct defines the functions necessary to implement the encoding
+ * interface so we can determine how many bytes the subsequent character takes.
+ * Each callback should return the number of bytes, or 0 if the next bytes are
+ * invalid for the encoding and type.
+ */
+typedef struct {
+    /**
+     * Return the number of bytes that the next character takes if it is valid
+     * in the encoding. Does not read more than n bytes. It is assumed that n is
+     * at least 1.
+     */
+    size_t (*char_width)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * Return the number of bytes that the next character takes if it is valid
+     * in the encoding and is alphabetical. Does not read more than n bytes. It
+     * is assumed that n is at least 1.
+     */
+    size_t (*alpha_char)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * Return the number of bytes that the next character takes if it is valid
+     * in the encoding and is alphanumeric. Does not read more than n bytes. It
+     * is assumed that n is at least 1.
+     */
+    size_t (*alnum_char)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * Return true if the next character is valid in the encoding and is an
+     * uppercase character. Does not read more than n bytes. It is assumed that
+     * n is at least 1.
+     */
+    bool (*isupper_char)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * The name of the encoding. This should correspond to a value that can be
+     * passed to Encoding.find in Ruby.
+     */
+    const char *name;
+
+    /**
+     * Return true if the encoding is a multibyte encoding.
+     */
+    bool multibyte;
+} rbs_encoding_t;
+
+/**
+ * All of the lookup tables use the first bit of each embedded byte to indicate
+ * whether the codepoint is alphabetical.
+ */
+#define RBS_ENCODING_ALPHABETIC_BIT 1 << 0
+
+/**
+ * All of the lookup tables use the second bit of each embedded byte to indicate
+ * whether the codepoint is alphanumeric.
+ */
+#define RBS_ENCODING_ALPHANUMERIC_BIT 1 << 1
+
+/**
+ * All of the lookup tables use the third bit of each embedded byte to indicate
+ * whether the codepoint is uppercase.
+ */
+#define RBS_ENCODING_UPPERCASE_BIT 1 << 2
+
+/**
+ * Return the size of the next character in the UTF-8 encoding.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns The number of bytes that the next character takes if it is valid in
+ *     the encoding, or 0 if it is not.
+ */
+size_t rbs_encoding_utf_8_char_width(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * Return the size of the next character in the UTF-8 encoding if it is an
+ * alphabetical character.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns The number of bytes that the next character takes if it is valid in
+ *     the encoding, or 0 if it is not.
+ */
+size_t rbs_encoding_utf_8_alpha_char(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * Return the size of the next character in the UTF-8 encoding if it is an
+ * alphanumeric character.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns The number of bytes that the next character takes if it is valid in
+ *     the encoding, or 0 if it is not.
+ */
+size_t rbs_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * Return true if the next character in the UTF-8 encoding if it is an uppercase
+ * character.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns True if the next character is valid in the encoding and is an
+ *     uppercase character, or false if it is not.
+ */
+bool rbs_encoding_utf_8_isupper_char(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * This lookup table is referenced in both the UTF-8 encoding file and the
+ * parser directly in order to speed up the default encoding processing. It is
+ * used to indicate whether a character is alphabetical, alphanumeric, or
+ * uppercase in unicode mappings.
+ */
+extern const uint8_t rbs_encoding_unicode_table[256];
+
+/**
+ * These are all of the encodings that prism supports.
+ */
+typedef enum {
+    RBS_ENCODING_UTF_8 = 0,
+    RBS_ENCODING_US_ASCII,
+    RBS_ENCODING_ASCII_8BIT,
+    RBS_ENCODING_EUC_JP,
+    RBS_ENCODING_WINDOWS_31J,
+
+// We optionally support excluding the full set of encodings to only support the
+// minimum necessary to process Ruby code without encoding comments.
+#ifndef RBS_ENCODING_EXCLUDE_FULL
+    RBS_ENCODING_BIG5,
+    RBS_ENCODING_BIG5_HKSCS,
+    RBS_ENCODING_BIG5_UAO,
+    RBS_ENCODING_CESU_8,
+    RBS_ENCODING_CP51932,
+    RBS_ENCODING_CP850,
+    RBS_ENCODING_CP852,
+    RBS_ENCODING_CP855,
+    RBS_ENCODING_CP949,
+    RBS_ENCODING_CP950,
+    RBS_ENCODING_CP951,
+    RBS_ENCODING_EMACS_MULE,
+    RBS_ENCODING_EUC_JP_MS,
+    RBS_ENCODING_EUC_JIS_2004,
+    RBS_ENCODING_EUC_KR,
+    RBS_ENCODING_EUC_TW,
+    RBS_ENCODING_GB12345,
+    RBS_ENCODING_GB18030,
+    RBS_ENCODING_GB1988,
+    RBS_ENCODING_GB2312,
+    RBS_ENCODING_GBK,
+    RBS_ENCODING_IBM437,
+    RBS_ENCODING_IBM720,
+    RBS_ENCODING_IBM737,
+    RBS_ENCODING_IBM775,
+    RBS_ENCODING_IBM852,
+    RBS_ENCODING_IBM855,
+    RBS_ENCODING_IBM857,
+    RBS_ENCODING_IBM860,
+    RBS_ENCODING_IBM861,
+    RBS_ENCODING_IBM862,
+    RBS_ENCODING_IBM863,
+    RBS_ENCODING_IBM864,
+    RBS_ENCODING_IBM865,
+    RBS_ENCODING_IBM866,
+    RBS_ENCODING_IBM869,
+    RBS_ENCODING_ISO_8859_1,
+    RBS_ENCODING_ISO_8859_2,
+    RBS_ENCODING_ISO_8859_3,
+    RBS_ENCODING_ISO_8859_4,
+    RBS_ENCODING_ISO_8859_5,
+    RBS_ENCODING_ISO_8859_6,
+    RBS_ENCODING_ISO_8859_7,
+    RBS_ENCODING_ISO_8859_8,
+    RBS_ENCODING_ISO_8859_9,
+    RBS_ENCODING_ISO_8859_10,
+    RBS_ENCODING_ISO_8859_11,
+    RBS_ENCODING_ISO_8859_13,
+    RBS_ENCODING_ISO_8859_14,
+    RBS_ENCODING_ISO_8859_15,
+    RBS_ENCODING_ISO_8859_16,
+    RBS_ENCODING_KOI8_R,
+    RBS_ENCODING_KOI8_U,
+    RBS_ENCODING_MAC_CENT_EURO,
+    RBS_ENCODING_MAC_CROATIAN,
+    RBS_ENCODING_MAC_CYRILLIC,
+    RBS_ENCODING_MAC_GREEK,
+    RBS_ENCODING_MAC_ICELAND,
+    RBS_ENCODING_MAC_JAPANESE,
+    RBS_ENCODING_MAC_ROMAN,
+    RBS_ENCODING_MAC_ROMANIA,
+    RBS_ENCODING_MAC_THAI,
+    RBS_ENCODING_MAC_TURKISH,
+    RBS_ENCODING_MAC_UKRAINE,
+    RBS_ENCODING_SHIFT_JIS,
+    RBS_ENCODING_SJIS_DOCOMO,
+    RBS_ENCODING_SJIS_KDDI,
+    RBS_ENCODING_SJIS_SOFTBANK,
+    RBS_ENCODING_STATELESS_ISO_2022_JP,
+    RBS_ENCODING_STATELESS_ISO_2022_JP_KDDI,
+    RBS_ENCODING_TIS_620,
+    RBS_ENCODING_UTF8_MAC,
+    RBS_ENCODING_UTF8_DOCOMO,
+    RBS_ENCODING_UTF8_KDDI,
+    RBS_ENCODING_UTF8_SOFTBANK,
+    RBS_ENCODING_WINDOWS_1250,
+    RBS_ENCODING_WINDOWS_1251,
+    RBS_ENCODING_WINDOWS_1252,
+    RBS_ENCODING_WINDOWS_1253,
+    RBS_ENCODING_WINDOWS_1254,
+    RBS_ENCODING_WINDOWS_1255,
+    RBS_ENCODING_WINDOWS_1256,
+    RBS_ENCODING_WINDOWS_1257,
+    RBS_ENCODING_WINDOWS_1258,
+    RBS_ENCODING_WINDOWS_874,
+#endif
+
+    RBS_ENCODING_MAXIMUM
+} rbs_encoding_type_t;
+
+/**
+ * This is the table of all of the encodings that prism supports.
+ */
+extern const rbs_encoding_t rbs_encodings[RBS_ENCODING_MAXIMUM];
+
+/**
+ * This is the default UTF-8 encoding. We need a reference to it to quickly
+ * create parsers.
+ */
+#define RBS_ENCODING_UTF_8_ENTRY (&rbs_encodings[RBS_ENCODING_UTF_8])
+
+/**
+ * This is the US-ASCII encoding. We need a reference to it to be able to
+ * compare against it when a string is being created because it could possibly
+ * need to fall back to ASCII-8BIT.
+ */
+#define RBS_ENCODING_US_ASCII_ENTRY (&rbs_encodings[RBS_ENCODING_US_ASCII])
+
+/**
+ * This is the ASCII-8BIT encoding. We need a reference to it so that rbs_strpbrk
+ * can compare against it because invalid multibyte characters are not a thing
+ * in this encoding. It is also needed for handling Regexp encoding flags.
+ */
+#define RBS_ENCODING_ASCII_8BIT_ENTRY (&rbs_encodings[RBS_ENCODING_ASCII_8BIT])
+
+/**
+ * This is the EUC-JP encoding. We need a reference to it to quickly process
+ * regular expression modifiers.
+ */
+#define RBS_ENCODING_EUC_JP_ENTRY (&rbs_encodings[RBS_ENCODING_EUC_JP])
+
+/**
+ * This is the Windows-31J encoding. We need a reference to it to quickly
+ * process regular expression modifiers.
+ */
+#define RBS_ENCODING_WINDOWS_31J_ENTRY (&rbs_encodings[RBS_ENCODING_WINDOWS_31J])
+
+/**
+ * Parse the given name of an encoding and return a pointer to the corresponding
+ * encoding struct if one can be found, otherwise return NULL.
+ *
+ * @param start A pointer to the first byte of the name.
+ * @param end A pointer to the last byte of the name.
+ * @returns A pointer to the encoding struct if one is found, otherwise NULL.
+ */
+const rbs_encoding_t *rbs_encoding_find(const uint8_t *start, const uint8_t *end);
+
+#endif

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/include/rbs/util/rbs_unescape.h

@@ -0,0 +1,24 @@
+#ifndef RBS_RBS_UNESCAPE_H
+#define RBS_RBS_UNESCAPE_H
+
+#include <stddef.h>
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/string.h"
+#include "rbs/util/rbs_encoding.h"
+
+/**
+ * Receives `rbs_parser_t` and `range`, which represents a string token or symbol token, and returns a string VALUE.
+ *
+ *    Input token | Output string
+ *    ------------+-------------
+ *    "foo\\n"    | foo\n
+ *    'foo'       | foo
+ *    `bar`       | bar
+ *    :"baz\\t"   | baz\t
+ *    :'baz'      | baz
+ *
+ * @returns A new owned string that will be freed when the allocator is freed.
+ * */
+rbs_string_t rbs_unquote_string(rbs_allocator_t *, const rbs_string_t input, const rbs_encoding_t *encoding);
+
+#endif // RBS_RBS_UNESCAPE_H

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/include/rbs.h

@@ -0,0 +1,14 @@
+#ifndef RBS_H
+#define RBS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "rbs/parser.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/ancestor_graph.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RBS
+  class AncestorGraph
+    InstanceNode = _ = Struct.new(:type_name, keyword_init: true)
+    SingletonNode = _ = Struct.new(:type_name, keyword_init: true)
+
+    attr_reader :env
+    attr_reader :ancestor_builder
+    attr_reader :parents
+    attr_reader :children
+
+    def initialize(env:, ancestor_builder: DefinitionBuilder::AncestorBuilder.new(env: env))
+      @env = env
+      @ancestor_builder = ancestor_builder
+      build()
+    end
+
+    def build()
+      @parents = {}
+      @children = {}
+
+      env.class_decls.each_key do |type_name|
+        build_ancestors(InstanceNode.new(type_name: type_name), ancestor_builder.one_instance_ancestors(type_name))
+        build_ancestors(SingletonNode.new(type_name: type_name), ancestor_builder.one_singleton_ancestors(type_name))
+      end
+      env.interface_decls.each_key do |type_name|
+        build_ancestors(InstanceNode.new(type_name: type_name), ancestor_builder.one_interface_ancestors(type_name))
+      end
+    end
+
+    def build_ancestors(node, ancestors)
+      ancestors.each_ancestor do |ancestor|
+        case ancestor
+        when Definition::Ancestor::Instance
+          register(child: node, parent: InstanceNode.new(type_name: ancestor.name))
+        when Definition::Ancestor::Singleton
+          register(child: node, parent: SingletonNode.new(type_name: ancestor.name))
+        end
+      end
+    end
+
+    def register(parent:, child:)
+      (parents[child] ||= Set[]) << parent
+      (children[parent] ||= Set[]) << child
+    end
+
+    def each_parent(node, &block)
+      if block
+        parents[node]&.each(&block)
+      else
+        enum_for :each_parent, node
+      end
+    end
+
+    def each_child(node, &block)
+      if block
+        children[node]&.each(&block)
+      else
+        enum_for :each_child, node
+      end
+    end
+
+    def each_ancestor(node, yielded: Set[], &block)
+      if block
+        each_parent(node) do |parent|
+          unless yielded.member?(parent)
+            yielded << parent
+            yield parent
+            each_ancestor(parent, yielded: yielded, &block)
+          end
+        end
+      else
+        enum_for :each_ancestor, node
+      end
+    end
+
+    def each_descendant(node, yielded: Set[], &block)
+      if block
+        each_child(node) do |child|
+          unless yielded.member?(child)
+            yielded << child
+            yield child
+            each_descendant(child, yielded: yielded, &block)
+          end
+        end
+      else
+        enum_for :each_descendant, node
+      end
+    end
+  end
+end