rbs 3.9.2 → 4.0.0.dev.1

data/include/rbs/defines.h

@@ -0,0 +1,60 @@
+/**
+ * @file defines.h
+ *
+ * Macro definitions used throughout the rbs library.
+ *
+ * This file should be included first by any *.h or *.c in rbs for consistency
+ * and to ensure that the macros are defined before they are used.
+ */
+
+#ifndef RBS_DEFINES_H
+#define RBS_DEFINES_H
+
+
+/***********************************************************************************************************************
+ * Copied+modified subset of Prism's `include/prism/defines.h`                                                         *
+ **********************************************************************************************************************/
+
+/**
+ * Certain compilers support specifying that a function accepts variadic
+ * parameters that look like printf format strings to provide a better developer
+ * experience when someone is using the function. This macro does that in a
+ * compiler-agnostic way.
+ */
+#if defined(__GNUC__)
+#   if defined(__MINGW_PRINTF_FORMAT)
+#       define RBS_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((format(__MINGW_PRINTF_FORMAT, string_index, argument_index)))
+#   else
+#       define RBS_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((format(printf, string_index, argument_index)))
+#   endif
+#elif defined(__clang__)
+#   define RBS_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((__format__(__printf__, string_index, argument_index)))
+#else
+#   define RBS_ATTRIBUTE_FORMAT(string_index, argument_index)
+#endif
+
+/**
+ * We use -Wimplicit-fallthrough to guard potentially unintended fall-through between cases of a switch.
+ * Use RBS_FALLTHROUGH to explicitly annotate cases where the fallthrough is intentional.
+ */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L // C23 or later
+    #define RBS_FALLTHROUGH [[fallthrough]];
+#elif defined(__GNUC__) || defined(__clang__)
+    #define RBS_FALLTHROUGH __attribute__((fallthrough));
+#elif defined(_MSC_VER)
+    #define RBS_FALLTHROUGH __fallthrough;
+#else
+    #define RBS_FALLTHROUGH
+#endif
+
+/***********************************************************************************************************************
+ * Custom defines for RBS                                                                                              *
+ **********************************************************************************************************************/
+
+#if defined(_MSC_VER)
+#define NODISCARD _Check_return_
+#else
+#define NODISCARD __attribute__((warn_unused_result))
+#endif
+
+#endif

data/{ext/rbs_extension → include/rbs}/lexer.h

@@ -1,7 +1,10 @@
 #ifndef RBS__LEXER_H
 #define RBS__LEXER_H
 
-enum TokenType {
+#include "string.h"
+#include "util/rbs_encoding.h"
+
+enum RBSTokenType {
   NullType,         /* (Nothing) */
   pEOF,             /* EOF */
   ErrorToken,       /* Error */
@@ -61,6 +64,9 @@ enum TokenType {
   kUSE,             /* use */
   kAS,              /* as */
   k__TODO__,        /* __todo__ */
+  kATRBS,           /* @rbs */
+  kSKIP,            /* skip */
+  kRETURN,          /* return */
 
   tLIDENT,          /* Identifiers starting with lower case */
   tUIDENT,          /* Identifiers starting with upper case */
@@ -77,6 +83,7 @@ enum TokenType {
 
   tCOMMENT,         /* Comment */
   tLINECOMMENT,     /* Comment of all line */
+  tINLINECOMMENT,   /* Comment in inline decl starting with -- */
 
   tTRIVIA,          /* Trivia tokens -- space and new line */
 
@@ -100,17 +107,17 @@ typedef struct {
   int char_pos;
   int line;
   int column;
-} position;
+} rbs_position_t;
 
 typedef struct {
-  position start;
-  position end;
-} range;
+  rbs_position_t start;
+  rbs_position_t end;
+} rbs_range_t;
 
 typedef struct {
-  enum TokenType type;
-  range range;
-} token;
+  enum RBSTokenType type;
+  rbs_range_t range;
+} rbs_token_t;
 
 /**
  * The lexer state is the curren token.
@@ -123,57 +130,58 @@ typedef struct {
  * ```
  * */
 typedef struct {
-  VALUE string;
+  rbs_string_t string;
   int start_pos;                  /* The character position that defines the start of the input */
   int end_pos;                    /* The character position that defines the end of the input */
-  position current;               /* The current position */
-  position start;                 /* The start position of the current token */
+  rbs_position_t current;               /* The current position */
+  rbs_position_t start;                 /* The start position of the current token */
   bool first_token_of_line;       /* This flag is used for tLINECOMMENT */
   unsigned int last_char;         /* Last peeked character */
-} lexstate;
+  const rbs_encoding_t *encoding;
+} rbs_lexer_t;
 
-extern token NullToken;
-extern position NullPosition;
-extern range NULL_RANGE;
+extern rbs_token_t NullToken;
+extern rbs_position_t NullPosition;
+extern rbs_range_t NULL_RANGE;
 
-char *peek_token(lexstate *state, token tok);
-int token_chars(token tok);
-int token_bytes(token tok);
+char *rbs_peek_token(rbs_lexer_t *lexer, rbs_token_t tok);
+int rbs_token_chars(rbs_token_t tok);
+int rbs_token_bytes(rbs_token_t tok);
 
-#define null_position_p(pos) (pos.byte_pos == -1)
-#define null_range_p(range) (range.start.byte_pos == -1)
-#define nonnull_pos_or(pos1, pos2) (null_position_p(pos1) ? pos2 : pos1)
-#define RANGE_BYTES(range) (range.end.byte_pos - range.start.byte_pos)
+#define rbs_null_position_p(pos) (pos.byte_pos == -1)
+#define rbs_null_range_p(range) (range.start.byte_pos == -1)
+#define rbs_nonnull_pos_or(pos1, pos2) (rbs_null_position_p(pos1) ? pos2 : pos1)
+#define RBS_RANGE_BYTES(range) (range.end.byte_pos - range.start.byte_pos)
 
-const char *token_type_str(enum TokenType type);
+const char *rbs_token_type_str(enum RBSTokenType type);
 
 /**
  * Read next character.
  * */
-unsigned int peek(lexstate *state);
+unsigned int rbs_peek(rbs_lexer_t *lexer);
 
 /**
  * Skip one character.
  * */
-void rbs_skip(lexstate *state);
+void rbs_skip(rbs_lexer_t *lexer);
 
 /**
  * Skip n characters.
  * */
-void skipn(lexstate *state, size_t size);
+void rbs_skipn(rbs_lexer_t *lexer, size_t size);
 
 /**
- * Return new token with given type.
+ * Return new rbs_token_t with given type.
  * */
-token next_token(lexstate *state, enum TokenType type);
+rbs_token_t rbs_next_token(rbs_lexer_t *lexer, enum RBSTokenType type);
 
 /**
- * Return new token with EOF type.
+ * Return new rbs_token_t with EOF type.
  * */
-token next_eof_token(lexstate *state);
+rbs_token_t rbs_next_eof_token(rbs_lexer_t *lexer);
 
-token rbsparser_next_token(lexstate *state);
+rbs_token_t rbs_lexer_next_token(rbs_lexer_t *lexer);
 
-void print_token(token tok);
+void rbs_print_token(rbs_token_t tok);
 
 #endif

data/include/rbs/location.h

@@ -0,0 +1,59 @@
+#ifndef RBS__RBS_LOCATION_H
+#define RBS__RBS_LOCATION_H
+
+#include "lexer.h"
+
+#include "rbs/util/rbs_constant_pool.h"
+#include "rbs/util/rbs_allocator.h"
+
+typedef struct {
+  int start;
+  int end;
+} rbs_loc_range;
+
+typedef struct {
+  rbs_constant_id_t name;
+  rbs_loc_range rg;
+} rbs_loc_entry;
+
+typedef unsigned int rbs_loc_entry_bitmap;
+
+// The flexible array always allocates, but it's okay.
+// This struct is not allocated when the `rbs_loc` doesn't have children.
+typedef struct {
+  unsigned short len;
+  unsigned short cap;
+  rbs_loc_entry_bitmap required_p;
+  rbs_loc_entry entries[1];
+} rbs_loc_children;
+
+typedef struct rbs_location {
+    rbs_range_t rg;
+    rbs_loc_children *children;
+} rbs_location_t;
+
+typedef struct rbs_location_list_node {
+  rbs_location_t *loc;
+  struct rbs_location_list_node *next;
+} rbs_location_list_node_t;
+
+typedef struct rbs_location_list {
+  rbs_allocator_t *allocator;
+  rbs_location_list_node_t *head;
+  rbs_location_list_node_t *tail;
+  size_t length;
+} rbs_location_list_t;
+
+void rbs_loc_alloc_children(rbs_allocator_t *, rbs_location_t *loc, size_t capacity);
+void rbs_loc_add_required_child(rbs_location_t *loc, rbs_constant_id_t name, rbs_range_t r);
+void rbs_loc_add_optional_child(rbs_location_t *loc, rbs_constant_id_t name, rbs_range_t r);
+
+/**
+ * Allocate new rbs_location_t object through the given allocator.
+ * */
+rbs_location_t *rbs_location_new(rbs_allocator_t *, rbs_range_t rg);
+
+rbs_location_list_t *rbs_location_list_new(rbs_allocator_t *allocator);
+void rbs_location_list_append(rbs_location_list_t *list, rbs_location_t *loc);
+
+#endif

data/include/rbs/parser.h

@@ -0,0 +1,151 @@
+#ifndef RBS__PARSER_H
+#define RBS__PARSER_H
+
+#include "rbs/defines.h"
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/util/rbs_constant_pool.h"
+#include "rbs/lexer.h"
+#include "rbs/ast.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+/**
+ * comment represents a sequence of comment lines.
+ *
+ *     # Comment for the method.
+ *     #
+ *     # ```rb
+ *     # object.foo()  # Do something
+ *     # ```
+ *     #
+ *     def foo: () -> void
+ *
+ * A comment object represents the six lines of comments.
+ * */
+typedef struct rbs_comment_t {
+  rbs_position_t start;
+  rbs_position_t end;
+
+  size_t line_size;
+  size_t line_count;
+  rbs_token_t *tokens;
+
+  struct rbs_comment_t *next_comment;
+} rbs_comment_t;
+
+typedef struct rbs_error_t {
+  char *message;
+  rbs_token_t token;
+  bool syntax_error;
+} rbs_error_t;
+
+/**
+ * An RBS parser is a LL(3) parser.
+ * */
+typedef struct {
+  rbs_lexer_t *rbs_lexer_t;
+
+  rbs_token_t current_token;
+  rbs_token_t next_token;       /* The first lookahead token */
+  rbs_token_t next_token2;      /* The second lookahead token */
+  rbs_token_t next_token3;      /* The third lookahead token */
+
+  struct id_table *vars;  /* Known type variables */
+  rbs_comment_t *last_comment;  /* Last read comment */
+
+  rbs_constant_pool_t constant_pool;
+  rbs_allocator_t *allocator;
+  rbs_error_t *error;
+} rbs_parser_t;
+
+/**
+ * Insert new table entry.
+ * Setting `reset` inserts a _reset_ entry, which stops searching.
+ *
+ * ```
+ * class Foo[A]
+ *          ^^^                      <= push new table with reset
+ *   def foo: [B] () -> [A, B]
+ *            ^^^                    <= push new table without reset
+ *
+ *   class Baz[C]
+ *            ^^^                    <= push new table with reset
+ *   end
+ * end
+ * ```
+ * */
+void rbs_parser_push_typevar_table(rbs_parser_t *parser, bool reset);
+
+/**
+ * Insert new type variable into the latest table.
+ * */
+NODISCARD bool rbs_parser_insert_typevar(rbs_parser_t *parser, rbs_constant_id_t id);
+
+/**
+ * Allocate new rbs_lexer_t object.
+ *
+ * ```
+ * VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+ * rbs_lexer_new(string, 0, 31)    // New rbs_lexer_t with buffer content
+ * ```
+ * */
+rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *, rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+
+/**
+ * Allocate new rbs_parser_t object.
+ *
+ * ```
+ * rbs_parser_new(buffer, string, encoding, 0, 1);
+ * ```
+ * */
+rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+void rbs_parser_free(rbs_parser_t *parser);
+
+/**
+ * Advance one token.
+ * */
+void rbs_parser_advance(rbs_parser_t *parser);
+
+void rbs_parser_print(rbs_parser_t *parser);
+
+/**
+ * Returns a RBS::Comment object associated with an subject at `subject_line`.
+ *
+ * ```rbs
+ * # Comment1
+ * class Foo           # This is the subject line for Comment1
+ *
+ *   # Comment2
+ *   %a{annotation}    # This is the subject line for Comment2
+ *   def foo: () -> void
+ * end
+ * ```
+ * */
+rbs_ast_comment_t *rbs_parser_get_comment(rbs_parser_t *parser, int subject_line);
+
+void rbs_parser_set_error(rbs_parser_t *parser, rbs_token_t tok, bool syntax_error, const char *fmt, ...) RBS_ATTRIBUTE_FORMAT(4, 5);
+
+bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type);
+bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type);
+bool rbs_parse_signature(rbs_parser_t *parser, rbs_signature_t **signature);
+
+/**
+ * Parse an inline leading annotation from a string.
+ *
+ * @param parser The parser to use
+ * @param annotation Pointer to store the resulting annotation
+ * @return true if parsing succeeded, false otherwise
+ */
+bool rbs_parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_annotations_t **annotation);
+
+/**
+ * Parse an inline trailing annotation from a string.
+ *
+ * @param parser The parser to use
+ * @param annotation Pointer to store the resulting annotation
+ * @return true if parsing succeeded, false otherwise
+ */
+bool rbs_parse_inline_trailing_annotation(rbs_parser_t *parser, rbs_ast_ruby_annotations_t **annotation);
+
+#endif

data/include/rbs/string.h

@@ -0,0 +1,49 @@
+#ifndef RBS__RBS_STRING_H
+#define RBS__RBS_STRING_H
+
+#include <stddef.h>
+#include <stdbool.h>
+#include "rbs/util/rbs_allocator.h"
+
+typedef struct {
+  const char *start;
+  const char *end;
+} rbs_string_t;
+
+#define RBS_STRING_NULL ((rbs_string_t) { \
+    .start = NULL,                        \
+    .end = NULL,                          \
+  })
+
+/**
+ * Returns a new `rbs_string_t` struct
+ */
+rbs_string_t rbs_string_new(const char *start, const char *end);
+
+/**
+ * Copies a portion of the input string into a new owned string.
+ * @param start_inset Number of characters to exclude from the start
+ * @param length Number of characters to include
+ * @return A new owned string that will be freed when the allocator is freed.
+ */
+rbs_string_t rbs_string_copy_slice(rbs_allocator_t *, rbs_string_t *self, size_t start_inset, size_t length);
+
+/**
+ * Drops the leading and trailing whitespace from the given string, in-place.
+ * @returns A new string that provides a view into the original string `self`.
+ */
+rbs_string_t rbs_string_strip_whitespace(rbs_string_t *self);
+
+/**
+ * Returns the length of the string.
+ */
+size_t rbs_string_len(const rbs_string_t self);
+
+/**
+ * Compares two strings for equality.
+ */
+bool rbs_string_equal(const rbs_string_t lhs, const rbs_string_t rhs);
+
+unsigned int rbs_utf8_string_to_codepoint(const rbs_string_t string);
+
+#endif

data/include/rbs/util/rbs_allocator.h

@@ -0,0 +1,38 @@
+#ifndef RBS_ALLOCATOR_H
+#define RBS_ALLOCATOR_H
+
+#include <stddef.h>
+
+#ifndef alignof
+    #if defined(__GNUC__) || defined(__clang__)
+        #define alignof(type) __alignof__(type)
+    #elif defined(_MSC_VER)
+        #define alignof(type) __alignof(type)
+    #else
+        // Fallback using offset trick
+        #define alignof(type) offsetof(struct { char c; type member; }, member)
+    #endif
+#endif
+
+struct rbs_allocator;
+typedef struct rbs_allocator rbs_allocator_t;
+
+rbs_allocator_t *rbs_allocator_init(void);
+void rbs_allocator_free(rbs_allocator_t *);
+void *rbs_allocator_malloc_impl      (rbs_allocator_t *, /*    1    */ size_t size, size_t alignment);
+void *rbs_allocator_malloc_many_impl (rbs_allocator_t *, size_t count, size_t size, size_t alignment);
+void *rbs_allocator_calloc_impl      (rbs_allocator_t *, size_t count, size_t size, size_t alignment);
+
+void *rbs_allocator_realloc_impl     (rbs_allocator_t *, void *ptr, size_t old_size, size_t new_size, size_t alignment);
+
+// Use this when allocating memory for a single instance of a type.
+#define rbs_allocator_alloc(allocator, type)             ((type *) rbs_allocator_malloc_impl((allocator), sizeof(type), alignof(type)))
+// Use this when allocating memory that will be immediately written to in full.
+// Such as allocating strings
+#define rbs_allocator_alloc_many(allocator, count, type) ((type *) rbs_allocator_malloc_many_impl((allocator), (count), sizeof(type), alignof(type)))
+// Use this when allocating memory that will NOT be immediately written to in full.
+// Such as allocating buffers
+#define rbs_allocator_calloc(allocator, count, type)     ((type *) rbs_allocator_calloc_impl((allocator), (count), sizeof(type), alignof(type)))
+#define rbs_allocator_realloc(allocator, ptr, old_size, new_size, type) ((type *) rbs_allocator_realloc_impl((allocator), (ptr), (old_size), (new_size), alignof(type)))
+
+#endif

data/include/rbs/util/rbs_assert.h

@@ -0,0 +1,9 @@
+#ifndef RBS_ASSERT_H
+#define RBS_ASSERT_H
+
+#include "rbs/defines.h"
+#include <stdbool.h>
+
+void rbs_assert(bool condition, const char *fmt, ...) RBS_ATTRIBUTE_FORMAT(2, 3);
+
+#endif

data/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/include/rbs/util/rbs_constant_pool.h

@@ -10,6 +10,8 @@
 #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>
@@ -28,70 +30,6 @@
  */
 typedef uint32_t rbs_constant_id_t;
 
-/**
- * A list of constant IDs. Usually used to represent a set of locals.
- */
-typedef struct {
-    /** The number of constant ids in the list. */
-    size_t size;
-
-    /** The number of constant ids that have been allocated in the list. */
-    size_t capacity;
-
-    /** The constant ids in the list. */
-    rbs_constant_id_t *ids;
-} rbs_constant_id_list_t;
-
-/**
- * Initialize a list of constant ids.
- *
- * @param list The list to initialize.
- */
-void rbs_constant_id_list_init(rbs_constant_id_list_t *list);
-
-/**
- * Initialize a list of constant ids with a given capacity.
- *
- * @param list The list to initialize.
- * @param capacity The initial capacity of the list.
- */
-void rbs_constant_id_list_init_capacity(rbs_constant_id_list_t *list, size_t capacity);
-
-/**
- * Append a constant id to a list of constant ids. Returns false if any
- * potential reallocations fail.
- *
- * @param list The list to append to.
- * @param id The id to append.
- * @return Whether the append succeeded.
- */
-bool rbs_constant_id_list_append(rbs_constant_id_list_t *list, rbs_constant_id_t id);
-
-/**
- * Insert a constant id into a list of constant ids at the specified index.
- *
- * @param list The list to insert into.
- * @param index The index at which to insert.
- * @param id The id to insert.
- */
-void rbs_constant_id_list_insert(rbs_constant_id_list_t *list, size_t index, rbs_constant_id_t id);
-
-/**
- * Checks if the current constant id list includes the given constant id.
- *
- * @param list The list to check.
- * @param id The id to check for.
- * @return Whether the list includes the given id.
- */
-bool rbs_constant_id_list_includes(rbs_constant_id_list_t *list, rbs_constant_id_t id);
-
-/**
- * Free the memory associated with a list of constant ids.
- *
- * @param list The list to free.
- */
-void rbs_constant_id_list_free(rbs_constant_id_list_t *list);
-
 /**
  * The type of bucket in the constant pool hash map. This determines how the
  * bucket should be freed.
@@ -185,6 +123,7 @@ rbs_constant_id_t rbs_constant_pool_find(const rbs_constant_pool_t *pool, const
  * @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