prism 2.0.0.rc2 → 2.0.0

data/include/prism/parser.hpp

@@ -0,0 +1,274 @@
+/**
+ * @file parser.hpp
+ *
+ * Ownership of parsers from C++, and lookups through a parser into the source,
+ * the constant pool, comments, and diagnostics.
+ */
+#ifndef PRISM_PARSER_HPP
+#define PRISM_PARSER_HPP
+
+#include "prism/compiler/cplusplus.hpp"
+#include "prism/compiler/lifetimebound.hpp"
+
+#include "prism/arena.h"
+#include "prism/constant_pool.h"
+#include "prism/line_offset_list.h"
+#include "prism/parser.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <string_view>
+
+namespace prism {
+
+/** Frees a parser with pm_parser_free. */
+struct parser_deleter {
+    /**
+     * Free the given parser.
+     *
+     * @param parser The parser to free.
+     */
+    void operator()(pm_parser_t *parser) const noexcept { pm_parser_free(parser); }
+};
+
+/** An owned parser. */
+using unique_parser = std::unique_ptr<pm_parser_t, parser_deleter>;
+
+/**
+ * Allocate a new parser over the given source. The source, the arena, and the
+ * options (which may be null) are not copied, so all three must outlive the
+ * parser. Allocation failure aborts, so this never throws.
+ *
+ * @param arena The arena to use for allocations.
+ * @param source The source code to parse.
+ * @param options The parse options, or null for defaults.
+ * @return A unique_parser owning the newly allocated parser.
+ */
+[[nodiscard]] inline unique_parser
+make_parser(pm_arena_t *arena PRISM_LIFETIMEBOUND, std::string_view source PRISM_LIFETIMEBOUND, const pm_options_t *options PRISM_LIFETIMEBOUND = nullptr) noexcept {
+    return unique_parser(pm_parser_new(arena, reinterpret_cast<const std::uint8_t *>(source.data()), source.size(), options));
+}
+
+/**
+ * The name of the constant with the given id, which must not be zero. Fields
+ * holding an optional constant use zero for none, so check those first.
+ *
+ * @param parser The parser containing the constant.
+ * @param constant_id The id of the constant.
+ * @return The value of the constant.
+ */
+[[nodiscard]] inline std::string_view
+constant(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_constant_id_t constant_id) noexcept {
+    assert(constant_id != 0);
+    const pm_constant_t *entry = pm_parser_constant(parser, constant_id);
+    return std::string_view(reinterpret_cast<const char *>(pm_constant_start(entry)), pm_constant_length(entry));
+}
+
+/**
+ * The bytes of source that the given location covers.
+ *
+ * @param parser The parser containing the source.
+ * @param location The location in the source.
+ * @return The bytes of source covered by the location.
+ */
+[[nodiscard]] inline std::string_view
+slice(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_location_t location) noexcept {
+    return std::string_view(reinterpret_cast<const char *>(pm_parser_start(parser) + location.start), location.length);
+}
+
+/**
+ * The line and column of the given byte offset into the source. Lines start at
+ * the parser's start line, and columns are byte offsets from the line start.
+ *
+ * @param parser The parser containing the source.
+ * @param offset The byte offset into the source.
+ * @return The line and column of the byte offset.
+ */
+[[nodiscard]] inline pm_line_column_t
+line_column(const pm_parser_t *parser, std::uint32_t offset) noexcept {
+    return pm_line_offset_list_line_column(pm_parser_line_offsets(parser), offset, pm_parser_start_line(parser));
+}
+
+namespace detail {
+
+/**
+ * The diagnostics, comments, or magic comments found while parsing, usable in a
+ * range-based for loop and with the standard algorithms. Each element is a
+ * pointer to the C struct, which the C accessors read, and Next is the C
+ * function that returns the item after a given one. It refers to the parser
+ * rather than copying from it, so the parser must outlive it. It is used
+ * through diagnostic_range, comment_range, and magic_comment_range.
+ */
+template <typename T, const T *(*Next)(const T *)> class next_range {
+public:
+    /** Steps through the items one after another. */
+    class iterator {
+    public:
+        /** The iterator category, for the standard algorithms. */
+        using iterator_category = std::forward_iterator_tag;
+
+        /** The type of each element. */
+        using value_type = const T *;
+
+        /** The type of the distance between two iterators. */
+        using difference_type = std::ptrdiff_t;
+
+        /** The type of a pointer to an element. */
+        using pointer = const value_type *;
+
+        /** The type of a reference to an element. */
+        using reference = const value_type &;
+
+        /** Create the iterator that marks the end of the items. */
+        iterator() noexcept = default;
+
+        /**
+         * Create an iterator at the given item.
+         *
+         * @param current The current item.
+         */
+        explicit iterator(const T *current) noexcept : current_(current) {}
+
+        /**
+         * The item at this position, which must not be the end.
+         *
+         * @return The current item.
+         */
+        reference operator*() const noexcept { return current_; }
+
+        /**
+         * Advance to the next item.
+         *
+         * @return The iterator after advancing.
+         */
+        iterator &
+        operator++() noexcept {
+            assert(current_ != nullptr);
+            current_ = Next(current_);
+            return *this;
+        }
+
+        /**
+         * Advance to the next item, returning the iterator from before.
+         *
+         * @return The iterator from before advancing.
+         */
+        iterator
+        operator++(int) noexcept {
+            iterator previous = *this;
+            ++*this;
+            return previous;
+        }
+
+        /** Whether the two iterators are at the same item. */
+        friend bool operator==(iterator left, iterator right) noexcept { return left.current_ == right.current_; }
+
+        /** Whether the two iterators are at different items. */
+        friend bool operator!=(iterator left, iterator right) noexcept { return left.current_ != right.current_; }
+
+    private:
+        const T *current_ = nullptr;
+    };
+
+    /**
+     * Create a range of the given number of items starting at first.
+     *
+     * @param first The first item.
+     * @param size The number of items.
+     */
+    next_range(const T *first, std::size_t size) noexcept : first_(first), size_(size) {}
+
+    /**
+     * An iterator at the first item.
+     *
+     * @return An iterator at the first item.
+     */
+    iterator begin() const noexcept { return iterator(first_); }
+
+    /**
+     * An iterator past the last item.
+     *
+     * @return An iterator past the last item.
+     */
+    iterator end() const noexcept { return iterator(); }
+
+    /**
+     * The number of items.
+     *
+     * @return The number of items.
+     */
+    std::size_t size() const noexcept { return size_; }
+
+    /**
+     * Whether there are no items.
+     *
+     * @return Whether there are no items.
+     */
+    [[nodiscard]] bool empty() const noexcept { return size_ == 0; }
+
+private:
+    const T *first_;
+    std::size_t size_;
+};
+
+}
+
+/** The errors or warnings found while parsing. */
+using diagnostic_range = detail::next_range<pm_diagnostic_t, pm_diagnostic_next>;
+
+/** The comments found while parsing. */
+using comment_range = detail::next_range<pm_comment_t, pm_comment_next>;
+
+/** The magic comments found while parsing. */
+using magic_comment_range = detail::next_range<pm_magic_comment_t, pm_magic_comment_next>;
+
+/**
+ * The errors found while parsing.
+ *
+ * @param parser The parser containing the source.
+ * @return The range of errors found while parsing.
+ */
+[[nodiscard]] inline diagnostic_range
+errors(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
+    return diagnostic_range(pm_parser_errors_first(parser), pm_parser_errors_size(parser));
+}
+
+/**
+ * The warnings found while parsing.
+ *
+ * @param parser The parser containing the source.
+ * @return The range of warnings found while parsing.
+ */
+[[nodiscard]] inline diagnostic_range
+warnings(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
+    return diagnostic_range(pm_parser_warnings_first(parser), pm_parser_warnings_size(parser));
+}
+
+/**
+ * The comments found while parsing, in source order.
+ *
+ * @param parser The parser containing the source.
+ * @return The range of comments found while parsing.
+ */
+[[nodiscard]] inline comment_range
+comments(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
+    return comment_range(pm_parser_comments_first(parser), pm_parser_comments_size(parser));
+}
+
+/**
+ * The magic comments found while parsing.
+ *
+ * @param parser The parser containing the source.
+ * @return The range of magic comments found while parsing.
+ */
+[[nodiscard]] inline magic_comment_range
+magic_comments(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
+    return magic_comment_range(pm_parser_magic_comments_first(parser), pm_parser_magic_comments_size(parser));
+}
+
+}
+
+#endif

data/include/prism/prettyprint.h

@@ -17,6 +17,10 @@
 #include "prism/buffer.h"
 #include "prism/parser.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * Pretty-prints the AST represented by the given node to the given buffer.
  *
@@ -26,6 +30,10 @@
  */
 PRISM_EXPORTED_FUNCTION void pm_prettyprint(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node) PRISM_NONNULL(1, 2, 3);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
 
 #endif

data/include/prism/serialize.h

@@ -22,6 +22,10 @@
 #include "prism/source.h"
 #include "prism/stream.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * Serialize the AST represented by the given node to the given buffer.
  *
@@ -110,6 +114,10 @@ PRISM_EXPORTED_FUNCTION bool pm_serialize_parse_success_p(const uint8_t *source,
  */
 PRISM_EXPORTED_FUNCTION int8_t pm_serialize_parse_errors_format(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data, pm_errors_format_type_t format_type) PRISM_NONNULL(1, 2);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
 
 #endif

data/include/prism/source.h

@@ -15,6 +15,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * An opaque type representing source code being parsed.
  */
@@ -152,4 +156,8 @@ PRISM_EXPORTED_FUNCTION size_t pm_source_length(const pm_source_t *source) PRISM
  */
 PRISM_EXPORTED_FUNCTION const uint8_t * pm_source_source(const pm_source_t *source) PRISM_NONNULL(1);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/stream.h

@@ -14,6 +14,10 @@
 #include "prism/parser.h"
 #include "prism/source.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * Parse a stream of Ruby source and return the tree.
  *
@@ -25,4 +29,8 @@
  */
 PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse_stream(pm_parser_t **parser, pm_arena_t *arena, pm_source_t *source, const pm_options_t *options) PRISM_NONNULL(1, 2, 3);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/string_query.h

@@ -13,6 +13,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * Represents the results of a slice query.
  */
@@ -71,4 +75,8 @@ PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_method_name(const uint
  */
 PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_keyword(const uint8_t *source, size_t length, const char *encoding_name) PRISM_NONNULL(1, 3);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/stringy.h

@@ -1,7 +1,7 @@
 /**
  * @file stringy.h
  *
- * A generic string type that can have various ownership semantics.
+ * A view of a sequence of bytes owned by someone else.
  */
 #ifndef PRISM_STRINGY_H
 #define PRISM_STRINGY_H
@@ -12,8 +12,13 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
- * A generic string type that can have various ownership semantics.
+ * A view of a sequence of bytes. The string does not own the bytes, so they
+ * must remain valid for as long as the string is in use.
  */
 typedef struct {
     /** A pointer to the start of the string. */
@@ -21,37 +26,17 @@ typedef struct {
 
     /** The length of the string in bytes of memory. */
     size_t length;
-
-    /** The type of the string. This field determines how the string should be freed. */
-    enum {
-        /** This string is a constant string, and should not be freed. */
-        PM_STRING_CONSTANT,
-
-        /** This is a slice of another string, and should not be freed. */
-        PM_STRING_SHARED,
-
-        /** This string owns its memory, and should be freed internally. */
-        PM_STRING_OWNED
-    } type;
 } pm_string_t;
 
 /**
- * Initialize a constant string that doesn't own its memory source.
- *
- * @param string The string to initialize.
- * @param source The source of the string.
- * @param length The length of the string.
- */
-PRISM_EXPORTED_FUNCTION void pm_string_constant_init(pm_string_t *string, const char *source, size_t length) PRISM_NONNULL(1);
-
-/**
- * Initialize an owned string that is responsible for freeing allocated memory.
+ * Initialize a string that views the given bytes. The bytes are not copied, so
+ * they must remain valid for as long as the string is in use.
  *
  * @param string The string to initialize.
- * @param source The source of the string.
- * @param length The length of the string.
+ * @param source The start of the bytes.
+ * @param length The number of bytes.
  */
-PRISM_EXPORTED_FUNCTION void pm_string_owned_init(pm_string_t *string, uint8_t *source, size_t length) PRISM_NONNULL(1, 2);
+PRISM_EXPORTED_FUNCTION void pm_string_init(pm_string_t *string, const uint8_t *source, size_t length) PRISM_NONNULL(1);
 
 /**
  * Returns the length associated with the string.
@@ -69,4 +54,8 @@ PRISM_EXPORTED_FUNCTION size_t pm_string_length(const pm_string_t *string) PRISM
  */
 PRISM_EXPORTED_FUNCTION const uint8_t * pm_string_source(const pm_string_t *string) PRISM_NONNULL(1);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/stringy.hpp

@@ -0,0 +1,31 @@
+/**
+ * @file stringy.hpp
+ *
+ * Access to the contents of strings from C++.
+ */
+#ifndef PRISM_STRINGY_HPP
+#define PRISM_STRINGY_HPP
+
+#include "prism/compiler/cplusplus.hpp"
+#include "prism/compiler/lifetimebound.hpp"
+
+#include "prism/stringy.h"
+
+#include <string_view>
+
+namespace prism {
+
+/**
+ * The bytes of the given string.
+ *
+ * @param string The string to view.
+ * @return A view of the bytes of the string.
+ */
+[[nodiscard]] inline std::string_view
+view(const pm_string_t &string PRISM_LIFETIMEBOUND) noexcept {
+    return std::string_view(reinterpret_cast<const char *>(pm_string_source(&string)), pm_string_length(&string));
+}
+
+}
+
+#endif

data/include/prism/version.h

@@ -8,6 +8,10 @@
 
 #include "prism/compiler/exported.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * The major version of the Prism library as an int.
  */
@@ -26,7 +30,7 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "2.0.0.rc2"
+#define PRISM_VERSION "2.0.0"
 
 /**
  * The prism version and the serialization format.
@@ -35,4 +39,8 @@
  */
 PRISM_EXPORTED_FUNCTION const char * pm_version(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism.h

@@ -6,10 +6,6 @@
 #ifndef PRISM_H
 #define PRISM_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "prism/arena.h"
 #include "prism/ast.h"
 #include "prism/buffer.h"
@@ -124,8 +120,4 @@ extern "C" {
  * ```
  */
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif

data/include/prism.hpp

@@ -0,0 +1,24 @@
+/**
+ * @file prism.hpp
+ *
+ * The main header file for the C++ interface to the prism parser. It adds
+ * ownership, checked casts between node types, and callable-based iteration on
+ * top of the C API. It never wraps the C structs: every function in it takes
+ * and returns the same pm_*_t types that prism.h declares, so the two can be
+ * mixed freely. It requires C++17 or later.
+ */
+#ifndef PRISM_HPP
+#define PRISM_HPP
+
+#include "prism.h"
+
+#include "prism/arena.hpp"
+#include "prism/ast.hpp"
+#include "prism/buffer.hpp"
+#include "prism/node.hpp"
+#include "prism/node_type.hpp"
+#include "prism/options.hpp"
+#include "prism/parser.hpp"
+#include "prism/stringy.hpp"
+
+#endif