rbs 3.10.0 → 4.0.0.dev.1

data/include/rbs/parser.h

@@ -24,39 +24,39 @@
  * A comment object represents the six lines of comments.
  * */
 typedef struct rbs_comment_t {
-    rbs_position_t start;
-    rbs_position_t end;
+  rbs_position_t start;
+  rbs_position_t end;
 
-    size_t line_tokens_capacity;
-    size_t line_tokens_count;
-    rbs_token_t *line_tokens;
+  size_t line_size;
+  size_t line_count;
+  rbs_token_t *tokens;
 
-    struct rbs_comment_t *next_comment;
+  struct rbs_comment_t *next_comment;
 } rbs_comment_t;
 
 typedef struct rbs_error_t {
-    char *message;
-    rbs_token_t token;
-    bool syntax_error;
+  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 *lexer;
+  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 */
+  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 */
+  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_constant_pool_t constant_pool;
+  rbs_allocator_t *allocator;
+  rbs_error_t *error;
 } rbs_parser_t;
 
 /**
@@ -127,9 +127,25 @@ 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 require_eof);
+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);
 
-bool rbs_parse_type_params(rbs_parser_t *parser, bool module_type_params, rbs_node_list_t **params);
+/**
+ * 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

@@ -6,14 +6,14 @@
 #include "rbs/util/rbs_allocator.h"
 
 typedef struct {
-    const char *start;
-    const char *end;
+  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
@@ -44,4 +44,6 @@ size_t rbs_string_len(const rbs_string_t self);
  */
 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

@@ -3,57 +3,36 @@
 
 #include <stddef.h>
 
-/* Include stdalign.h for C11 and later for alignof support */
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-#include <stdalign.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
 
-/*
- * Define a portable alignment macro that works across all supported environments
- */
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-/* C11 or later - use _Alignof directly (always available in C11+) */
-#define rbs_alignof(type) _Alignof(type)
-#elif defined(__cplusplus) && __cplusplus >= 201103L
-/* C++11 or later has alignof keyword */
-#define rbs_alignof(type) alignof(type)
-#elif defined(__GNUC__) || defined(__clang__)
-/* GCC and Clang provide __alignof__ */
-#define rbs_alignof(type) __alignof__(type)
-#elif defined(_MSC_VER)
-/* MSVC provides __alignof */
-#define rbs_alignof(type) __alignof(type)
-#else
-/* Fallback using offset trick for other compilers */
-#define rbs_alignof(type) offsetof( \
-    struct { char c; type member; },                     \
-    member                          \
-)
-#endif
-
-typedef struct rbs_allocator {
-    // The head of a linked list of pages, starting with the most recently allocated page.
-    struct rbs_allocator_page *page;
-
-    size_t default_page_payload_size;
-} rbs_allocator_t;
+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_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);
+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), rbs_alignof(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), rbs_alignof(type)))
+#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), rbs_alignof(type)))
-#define rbs_allocator_realloc(allocator, ptr, old_size, new_size, type) ((type *) rbs_allocator_realloc_impl((allocator), (ptr), (old_size), (new_size), rbs_alignof(type)))
+#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

@@ -4,17 +4,6 @@
 #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);
+void rbs_assert(bool condition, const char *fmt, ...) RBS_ATTRIBUTE_FORMAT(2, 3);
 
 #endif

data/include/rbs/util/rbs_constant_pool.h

@@ -48,10 +48,10 @@ static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_CONSTANT =
 /** A bucket in the hash map. */
 typedef struct {
     /** The incremental ID used for indexing back into the pool. */
-    unsigned int id : 30;
+    unsigned int id: 30;
 
     /** The type of the bucket, which determines how to free it. */
-    rbs_constant_pool_bucket_type_t type : 2;
+    rbs_constant_pool_bucket_type_t type: 2;
 
     /** The hash of the bucket. */
     uint32_t hash;
@@ -100,7 +100,7 @@ bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity);
  * @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);
+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

data/include/rbs/util/rbs_encoding.h

@@ -6,8 +6,6 @@
 #ifndef RBS_RBS_ENCODING_H
 #define RBS_RBS_ENCODING_H
 
-#include "rbs/defines.h"
-
 #include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -277,6 +275,6 @@ extern const rbs_encoding_t rbs_encodings[RBS_ENCODING_MAXIMUM];
  * @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);
+const rbs_encoding_t * rbs_encoding_find(const uint8_t *start, const uint8_t *end);
 
 #endif

data/include/rbs/util/rbs_unescape.h

@@ -4,7 +4,6 @@
 #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.
@@ -19,6 +18,6 @@
  *
  * @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);
+rbs_string_t rbs_unquote_string(rbs_allocator_t *, const rbs_string_t input);
 
 #endif // RBS_RBS_UNESCAPE_H

data/lib/rbs/ast/ruby/annotations.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Annotations
+        class Base
+          attr_reader :location, :prefix_location
+
+          def initialize(location, prefix_location)
+            @location = location
+            @prefix_location = prefix_location
+          end
+
+          def buffer
+            location.buffer
+          end
+        end
+
+        class NodeTypeAssertion < Base
+          attr_reader :type
+
+          def initialize(location:, prefix_location:, type:)
+            super(location, prefix_location)
+            @type = type
+          end
+
+          def map_type_name
+            self.class.new(
+              location:, prefix_location:,
+              type: type.map_type_name { yield _1 }
+            ) #: self
+          end
+        end
+
+        class ColonMethodTypeAnnotation < Base
+          attr_reader :annotations, :method_type
+
+          def initialize(location:, prefix_location:, annotations:, method_type:)
+            super(location, prefix_location)
+            @annotations = annotations
+            @method_type = method_type
+          end
+
+          def map_type_name
+            self.class.new(
+              location:,
+              prefix_location:,
+              annotations: annotations,
+              method_type: method_type.map_type {|type| type.map_type_name { yield _1 }}
+            ) #: self
+          end
+        end
+
+        class MethodTypesAnnotation < Base
+          Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader :overloads, :vertical_bar_locations
+
+          def initialize(location:, prefix_location:, overloads:, vertical_bar_locations:)
+            super(location, prefix_location)
+            @overloads = overloads
+            @vertical_bar_locations = vertical_bar_locations
+          end
+
+          def map_type_name(&block)
+            ovs = overloads.map do |overload|
+              Overload.new(
+                method_type: overload.method_type.map_type {|type| type.map_type_name { yield _1 } },
+                annotations: overload.annotations
+              )
+            end
+
+            self.class.new(location:, prefix_location:, overloads: ovs, vertical_bar_locations:) #: self
+          end
+        end
+
+        class SkipAnnotation < Base
+          attr_reader :skip_location, :comment_location
+
+          def initialize(location:, prefix_location:, skip_location:, comment_location:)
+            super(location, prefix_location)
+            @skip_location = skip_location
+            @comment_location = comment_location
+          end
+        end
+
+        class ReturnTypeAnnotation < Base
+          attr_reader :return_location
+
+          attr_reader :colon_location
+
+          attr_reader :return_type
+
+          attr_reader :comment_location
+
+          def initialize(location:, prefix_location:, return_location:, colon_location:, return_type:, comment_location:)
+            super(location, prefix_location)
+            @return_location = return_location
+            @colon_location = colon_location
+            @return_type = return_type
+            @comment_location = comment_location
+          end
+
+          def map_type_name(&block)
+            self.class.new(
+              location:,
+              prefix_location:,
+              return_location: return_location,
+              colon_location: colon_location,
+              return_type: return_type.map_type_name { yield _1 },
+              comment_location: comment_location
+            ) #: self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/ruby/comment_block.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      class CommentBlock
+        attr_reader :name, :offsets, :comment_buffer
+
+        def initialize(source_buffer, comments)
+          @name = source_buffer.name
+
+          @offsets = []
+
+          # Assume the comment starts with a prefix whitespace
+          prefix_str = "# "
+
+          ranges = [] #: Array[Range[Integer]]
+
+          comments.each do |comment|
+            tuple = [comment, 2] #: [Prism::Comment, Integer]
+
+            unless comment.location.slice.start_with?(prefix_str)
+              tuple[1] = 1
+            end
+
+            offsets << tuple
+
+            start_char = comment.location.start_character_offset + tuple[1]
+            end_char = comment.location.end_character_offset
+            ranges << (start_char ... end_char)
+          end
+
+          @comment_buffer = source_buffer.sub_buffer(lines: ranges)
+        end
+
+        def leading?
+          comment = offsets[0][0] or raise
+          comment.location.start_line_slice.index(/\S/) ? false : true
+        end
+
+        def trailing?
+          comment = offsets[0][0] or raise
+          comment.location.start_line_slice.index(/\S/) ? true : false
+        end
+
+        def start_line
+          comments[0].location.start_line
+        end
+
+        def end_line
+          comments[-1].location.end_line
+        end
+
+        def line_starts
+          offsets.map do |comment, prefix_size|
+            comment.location.start_character_offset + prefix_size
+          end
+        end
+
+        def self.build(buffer, comments)
+          blocks = [] #: Array[CommentBlock]
+
+          comments = comments.filter {|comment| comment.is_a?(Prism::InlineComment) }
+
+          until comments.empty?
+            block_comments = [] #: Array[Prism::Comment]
+
+            until comments.empty?
+              comment = comments.first or raise
+              last_comment = block_comments.last
+
+              if last_comment
+                if last_comment.location.end_line + 1 == comment.location.start_line
+                  if last_comment.location.start_column == comment.location.start_column
+                    unless comment.location.start_line_slice.index(/\S/)
+                      block_comments << comments.shift
+                      next
+                    end
+                  end
+                end
+
+                break
+              else
+                block_comments << comments.shift
+              end
+            end
+
+            unless block_comments.empty?
+              blocks << CommentBlock.new(buffer, block_comments.dup)
+            end
+          end
+
+          blocks
+        end
+
+        AnnotationSyntaxError = _ = Struct.new(:location, :error)
+
+        def each_paragraph(variables, &block)
+          if block
+            if leading_annotation?(0)
+              yield_annotation(0, 0, 0, variables, &block)
+            else
+              yield_paragraph(0, 0, variables, &block)
+            end
+          else
+            enum_for :each_paragraph, variables
+          end
+        end
+
+        def yield_paragraph(start_line, current_line, variables, &block)
+          # We already know at start_line..current_line are paragraph.
+
+          while true
+            next_line = current_line + 1
+
+            if next_line >= comment_buffer.line_count
+              yield line_location(start_line, current_line)
+              return
+            end
+
+            if leading_annotation?(next_line)
+              yield line_location(start_line, current_line)
+              return yield_annotation(next_line, next_line, next_line, variables, &block)
+            else
+              current_line = next_line
+            end
+          end
+        end
+
+        def yield_annotation(start_line, end_line, current_line, variables, &block)
+          # We already know at start_line..end_line are annotation.
+          while true
+            next_line = current_line + 1
+
+            if next_line >= comment_buffer.line_count
+              annotation = parse_annotation_lines(start_line, end_line, variables)
+              yield annotation
+
+              if end_line > current_line
+                yield_paragraph(end_line + 1, end_line + 1, variables, &block)
+              end
+
+              return
+            end
+
+            line_text = text(next_line)
+            if leading_spaces = line_text.index(/\S/)
+              if leading_spaces == 0
+                # End of annotation
+                yield parse_annotation_lines(start_line, end_line, variables)
+
+                if leading_annotation?(end_line + 1)
+                  yield_annotation(end_line + 1, end_line + 1, end_line + 1, variables, &block)
+                else
+                  yield_paragraph(end_line + 1, end_line + 1, variables, &block)
+                end
+
+                return
+              else
+                current_line = next_line
+                end_line = next_line
+              end
+            else
+              current_line = next_line
+            end
+          end
+        end
+
+        def text(comment_index)
+          range = comment_buffer.ranges[comment_index]
+          comment_buffer.content[range] or raise
+        end
+
+        def line_location(start_line, end_line)
+          start_offset = comment_buffer.ranges[start_line].begin
+          end_offset = comment_buffer.ranges[end_line].end
+          Location.new(comment_buffer, start_offset, end_offset)
+        end
+
+        def parse_annotation_lines(start_line, end_line, variables)
+          start_pos = comment_buffer.ranges[start_line].begin
+          end_pos = comment_buffer.ranges[end_line].end
+          begin
+            Parser.parse_inline_leading_annotation(comment_buffer, start_pos...end_pos, variables: variables)
+          rescue ParsingError => error
+            AnnotationSyntaxError.new(line_location(start_line, end_line), error)
+          end
+        end
+
+        def trailing_annotation(variables)
+          if trailing?
+            comment = comments[0] or raise
+            if comment.location.slice.start_with?(/#[:\[]/)
+              begin
+                Parser.parse_inline_trailing_annotation(comment_buffer, 0...comment_buffer.last_position, variables: variables)
+              rescue ParsingError => error
+                location = line_location(0, offsets.size - 1)
+                AnnotationSyntaxError.new(location, error)
+              end
+            end
+          end
+        end
+
+        def comments
+          offsets.map { _1[0]}
+        end
+
+        def leading_annotation?(index)
+          if index < comment_buffer.line_count
+            text(index).start_with?(/@rbs\b/) and return true
+
+            comment = offsets[index][0]
+            comment.location.slice.start_with?(/\#:/) and return true
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/ruby/declarations.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Declarations
+        class Base
+          attr_reader :buffer
+
+          include Helpers::ConstantHelper
+          include Helpers::LocationHelper
+
+          def initialize(buffer)
+            @buffer = buffer
+          end
+        end
+
+        class ClassDecl < Base
+          attr_reader :class_name
+
+          attr_reader :members
+
+          attr_reader :node
+
+          def initialize(buffer, name, node)
+            super(buffer)
+            @class_name = name
+            @node = node
+            @members = []
+          end
+
+          def each_decl(&block)
+            return enum_for(:each_decl) unless block
+
+            @members.each do |member|
+              if member.is_a?(Base)
+                yield member
+              end
+            end
+          end
+
+          def super_class = nil
+
+          def type_params = []
+
+          def location
+            rbs_location(node.location)
+          end
+        end
+
+        class ModuleDecl < Base
+          attr_reader :module_name
+
+          attr_reader :members
+
+          attr_reader :node
+
+          def initialize(buffer, name, node)
+            super(buffer)
+            @module_name = name
+            @node = node
+            @members = []
+          end
+
+          def each_decl(&block)
+            return enum_for(:each_decl) unless block
+
+            @members.each do |member|
+              if member.is_a?(Base)
+                yield member
+              end
+            end
+          end
+
+          def type_params = []
+
+          def self_types = []
+
+          def location
+            rbs_location(node.location)
+          end
+        end
+      end
+    end
+  end
+end