rbs 4.0.0.dev.4 → 4.1.0.pre.2

data/ext/rbs_extension/main.c

@@ -2,6 +2,7 @@
 #include "rbs/util/rbs_assert.h"
 #include "rbs/util/rbs_allocator.h"
 #include "rbs/util/rbs_constant_pool.h"
+#include "rbs/serialize.h"
 #include "ast_translation.h"
 #include "legacy_location.h"
 #include "rbs_string_bridging.h"
@@ -16,7 +17,7 @@
  * ```
  * */
 static NORETURN(void) raise_error(rbs_error_t *error, VALUE buffer) {
-    rbs_assert(error != NULL, "raise_error() called with NULL error");
+    RBS_ASSERT(error != NULL, "raise_error() called with NULL error");
 
     if (!error->syntax_error) {
         rb_raise(rb_eRuntimeError, "Unexpected error");
@@ -67,10 +68,12 @@ static void declare_type_variables(rbs_parser_t *parser, VALUE variables, VALUE
         }
 
         VALUE name_str = rb_sym2str(symbol);
+        uint8_t *copied_name = (uint8_t *) malloc((size_t) RSTRING_LEN(name_str));
+        memcpy((void *) copied_name, RSTRING_PTR(name_str), RSTRING_LEN(name_str));
 
-        rbs_constant_id_t id = rbs_constant_pool_insert_shared(
+        rbs_constant_id_t id = rbs_constant_pool_insert_owned(
             &parser->constant_pool,
-            (const uint8_t *) RSTRING_PTR(name_str),
+            copied_name,
             RSTRING_LEN(name_str)
         );
 
@@ -85,6 +88,23 @@ struct parse_type_arg {
     rb_encoding *encoding;
     rbs_parser_t *parser;
     VALUE require_eof;
+    VALUE void_allowed;
+    VALUE self_allowed;
+    VALUE classish_allowed;
+};
+
+struct parse_method_type_arg {
+    VALUE buffer;
+    rb_encoding *encoding;
+    rbs_parser_t *parser;
+    VALUE require_eof;
+};
+
+struct parse_signature_arg {
+    VALUE buffer;
+    rb_encoding *encoding;
+    rbs_parser_t *parser;
+    VALUE require_eof;
 };
 
 static VALUE ensure_free_parser(VALUE parser) {
@@ -100,8 +120,12 @@ static VALUE parse_type_try(VALUE a) {
         return Qnil;
     }
 
+    bool void_allowed = RTEST(arg->void_allowed);
+    bool self_allowed = RTEST(arg->self_allowed);
+    bool classish_allowed = RTEST(arg->classish_allowed);
+
     rbs_node_t *type;
-    rbs_parse_type(parser, &type);
+    rbs_parse_type(parser, &type, void_allowed, self_allowed, classish_allowed);
 
     raise_error_if_any(parser, arg->buffer);
 
@@ -122,10 +146,17 @@ static VALUE parse_type_try(VALUE a) {
     return rbs_struct_to_ruby_value(ctx, type);
 }
 
-static rbs_lexer_t *alloc_lexer_from_buffer(rbs_allocator_t *allocator, VALUE string, rb_encoding *encoding, int start_pos, int end_pos) {
+static void validate_position_range(int start_pos, int end_pos) {
     if (start_pos < 0 || end_pos < 0) {
         rb_raise(rb_eArgError, "negative position range: %d...%d", start_pos, end_pos);
     }
+    if (start_pos > end_pos) {
+        rb_raise(rb_eArgError, "invalid position range: %d...%d", start_pos, end_pos);
+    }
+}
+
+static rbs_lexer_t *alloc_lexer_from_buffer(rbs_allocator_t *allocator, VALUE string, rb_encoding *encoding, int start_pos, int end_pos) {
+    validate_position_range(start_pos, end_pos);
 
     const char *encoding_name = rb_enc_name(encoding);
 
@@ -139,9 +170,7 @@ static rbs_lexer_t *alloc_lexer_from_buffer(rbs_allocator_t *allocator, VALUE st
 }
 
 static rbs_parser_t *alloc_parser_from_buffer(VALUE buffer, int start_pos, int end_pos) {
-    if (start_pos < 0 || end_pos < 0) {
-        rb_raise(rb_eArgError, "negative position range: %d...%d", start_pos, end_pos);
-    }
+    validate_position_range(start_pos, end_pos);
 
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
@@ -157,7 +186,7 @@ static rbs_parser_t *alloc_parser_from_buffer(VALUE buffer, int start_pos, int e
     );
 }
 
-static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof) {
+static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof, VALUE void_allowed, VALUE self_allowed, VALUE classish_allowed) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
     rb_encoding *encoding = rb_enc_get(string);
@@ -168,7 +197,10 @@ static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VAL
         .buffer = buffer,
         .encoding = encoding,
         .parser = parser,
-        .require_eof = require_eof
+        .require_eof = require_eof,
+        .void_allowed = void_allowed,
+        .self_allowed = self_allowed,
+        .classish_allowed = classish_allowed
     };
 
     VALUE result = rb_ensure(parse_type_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
@@ -179,7 +211,7 @@ static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VAL
 }
 
 static VALUE parse_method_type_try(VALUE a) {
-    struct parse_type_arg *arg = (struct parse_type_arg *) a;
+    struct parse_method_type_arg *arg = (struct parse_method_type_arg *) a;
     rbs_parser_t *parser = arg->parser;
 
     if (parser->next_token.type == pEOF) {
@@ -187,18 +219,10 @@ static VALUE parse_method_type_try(VALUE a) {
     }
 
     rbs_method_type_t *method_type = NULL;
-    rbs_parse_method_type(parser, &method_type);
+    rbs_parse_method_type(parser, &method_type, RB_TEST(arg->require_eof), true);
 
     raise_error_if_any(parser, arg->buffer);
 
-    if (RB_TEST(arg->require_eof)) {
-        rbs_parser_advance(parser);
-        if (parser->current_token.type != pEOF) {
-            rbs_parser_set_error(parser, parser->current_token, true, "expected a token `%s`", rbs_token_type_str(pEOF));
-            raise_error(parser->error, arg->buffer);
-        }
-    }
-
     rbs_translation_context_t ctx = rbs_translation_context_create(
         &parser->constant_pool,
         arg->buffer,
@@ -215,7 +239,7 @@ static VALUE rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_p
 
     rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
     declare_type_variables(parser, variables, buffer);
-    struct parse_type_arg arg = {
+    struct parse_method_type_arg arg = {
         .buffer = buffer,
         .encoding = encoding,
         .parser = parser,
@@ -230,7 +254,7 @@ static VALUE rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_p
 }
 
 static VALUE parse_signature_try(VALUE a) {
-    struct parse_type_arg *arg = (struct parse_type_arg *) a;
+    struct parse_signature_arg *arg = (struct parse_signature_arg *) a;
     rbs_parser_t *parser = arg->parser;
 
     rbs_signature_t *signature = NULL;
@@ -253,7 +277,7 @@ static VALUE rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE start_pos
     rb_encoding *encoding = rb_enc_get(string);
 
     rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
-    struct parse_type_arg arg = {
+    struct parse_signature_arg arg = {
         .buffer = buffer,
         .encoding = encoding,
         .parser = parser,
@@ -267,6 +291,132 @@ static VALUE rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE start_pos
     return result;
 }
 
+// Serialize a parsed node into a binary Ruby string using the same encoder the
+// WebAssembly build uses. These `_*_to_bytes` entry points exist so the
+// round-trip (parse -> serialize -> deserialize) can be exercised on CRuby,
+// where it can be compared against the direct C -> Ruby translation.
+static VALUE serialized_node_to_string(rbs_parser_t *parser, rbs_node_t *node) {
+    rbs_string_t bytes = rbs_serialize_node(parser->allocator, &parser->constant_pool, node);
+    return rb_str_new(bytes.start, (long) rbs_string_len(bytes));
+}
+
+static VALUE parse_type_to_bytes_try(VALUE a) {
+    struct parse_type_arg *arg = (struct parse_type_arg *) a;
+    rbs_parser_t *parser = arg->parser;
+
+    if (parser->next_token.type == pEOF) {
+        return Qnil;
+    }
+
+    rbs_node_t *type;
+    rbs_parse_type(parser, &type, RTEST(arg->void_allowed), RTEST(arg->self_allowed), RTEST(arg->classish_allowed));
+
+    raise_error_if_any(parser, arg->buffer);
+
+    if (RB_TEST(arg->require_eof)) {
+        rbs_parser_advance(parser);
+        if (parser->current_token.type != pEOF) {
+            rbs_parser_set_error(parser, parser->current_token, true, "expected a token `%s`", rbs_token_type_str(pEOF));
+            raise_error(parser->error, arg->buffer);
+        }
+    }
+
+    return serialized_node_to_string(parser, type);
+}
+
+static VALUE rbsparser_parse_type_to_bytes(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof, VALUE void_allowed, VALUE self_allowed, VALUE classish_allowed) {
+    VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+    StringValue(string);
+    rb_encoding *encoding = rb_enc_get(string);
+
+    rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
+    declare_type_variables(parser, variables, buffer);
+    struct parse_type_arg arg = {
+        .buffer = buffer,
+        .encoding = encoding,
+        .parser = parser,
+        .require_eof = require_eof,
+        .void_allowed = void_allowed,
+        .self_allowed = self_allowed,
+        .classish_allowed = classish_allowed
+    };
+
+    VALUE result = rb_ensure(parse_type_to_bytes_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
+
+    RB_GC_GUARD(string);
+
+    return result;
+}
+
+static VALUE parse_method_type_to_bytes_try(VALUE a) {
+    struct parse_method_type_arg *arg = (struct parse_method_type_arg *) a;
+    rbs_parser_t *parser = arg->parser;
+
+    if (parser->next_token.type == pEOF) {
+        return Qnil;
+    }
+
+    rbs_method_type_t *method_type = NULL;
+    rbs_parse_method_type(parser, &method_type, RB_TEST(arg->require_eof), true);
+
+    raise_error_if_any(parser, arg->buffer);
+
+    return serialized_node_to_string(parser, (rbs_node_t *) method_type);
+}
+
+static VALUE rbsparser_parse_method_type_to_bytes(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof) {
+    VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+    StringValue(string);
+    rb_encoding *encoding = rb_enc_get(string);
+
+    rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
+    declare_type_variables(parser, variables, buffer);
+    struct parse_method_type_arg arg = {
+        .buffer = buffer,
+        .encoding = encoding,
+        .parser = parser,
+        .require_eof = require_eof
+    };
+
+    VALUE result = rb_ensure(parse_method_type_to_bytes_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
+
+    RB_GC_GUARD(string);
+
+    return result;
+}
+
+static VALUE parse_signature_to_bytes_try(VALUE a) {
+    struct parse_signature_arg *arg = (struct parse_signature_arg *) a;
+    rbs_parser_t *parser = arg->parser;
+
+    rbs_signature_t *signature = NULL;
+    rbs_parse_signature(parser, &signature);
+
+    raise_error_if_any(parser, arg->buffer);
+
+    return serialized_node_to_string(parser, (rbs_node_t *) signature);
+}
+
+static VALUE rbsparser_parse_signature_to_bytes(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos) {
+    VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+    StringValue(string);
+    rb_encoding *encoding = rb_enc_get(string);
+
+    rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
+    struct parse_signature_arg arg = {
+        .buffer = buffer,
+        .encoding = encoding,
+        .parser = parser,
+        .require_eof = false
+    };
+
+    VALUE result = rb_ensure(parse_signature_to_bytes_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
+
+    RB_GC_GUARD(string);
+
+    return result;
+}
+
 struct parse_type_params_arg {
     VALUE buffer;
     rb_encoding *encoding;
@@ -429,12 +579,19 @@ static VALUE rbsparser_lex(VALUE self, VALUE buffer, VALUE end_pos) {
 void rbs__init_parser(void) {
     RBS_Parser = rb_define_class_under(RBS, "Parser", rb_cObject);
     rb_gc_register_mark_object(RBS_Parser);
-    VALUE empty_array = rb_obj_freeze(rb_ary_new());
-    rb_gc_register_mark_object(empty_array);
 
-    rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 5);
+    EMPTY_ARRAY = rb_obj_freeze(rb_ary_new());
+    rb_gc_register_mark_object(EMPTY_ARRAY);
+
+    EMPTY_HASH = rb_obj_freeze(rb_hash_new());
+    rb_gc_register_mark_object(EMPTY_HASH);
+
+    rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 8);
     rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 5);
     rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 3);
+    rb_define_singleton_method(RBS_Parser, "_parse_type_to_bytes", rbsparser_parse_type_to_bytes, 8);
+    rb_define_singleton_method(RBS_Parser, "_parse_method_type_to_bytes", rbsparser_parse_method_type_to_bytes, 5);
+    rb_define_singleton_method(RBS_Parser, "_parse_signature_to_bytes", rbsparser_parse_signature_to_bytes, 3);
     rb_define_singleton_method(RBS_Parser, "_parse_type_params", rbsparser_parse_type_params, 4);
     rb_define_singleton_method(RBS_Parser, "_parse_inline_leading_annotation", rbsparser_parse_inline_leading_annotation, 4);
     rb_define_singleton_method(RBS_Parser, "_parse_inline_trailing_annotation", rbsparser_parse_inline_trailing_annotation, 4);
@@ -442,7 +599,6 @@ void rbs__init_parser(void) {
 }
 
 static void Deinit_rbs_extension(ruby_vm_t *_) {
-    rbs_constant_pool_free(RBS_GLOBAL_CONSTANT_POOL);
 }
 
 void Init_rbs_extension(void) {
@@ -453,17 +609,5 @@ void Init_rbs_extension(void) {
     rbs__init_location();
     rbs__init_parser();
 
-    /* Calculated based on the number of unique strings used with the `INTERN` macro in `parser.c`.
-   *
-   * ```bash
-   * grep -o 'INTERN("\([^"]*\)")' ext/rbs_extension/parser.c \
-   *     | sed 's/INTERN("\(.*\)")/\1/' \
-   *     | sort -u \
-   *     | wc -l
-   * ```
-   */
-    const size_t num_uniquely_interned_strings = 26;
-    rbs_constant_pool_init(RBS_GLOBAL_CONSTANT_POOL, num_uniquely_interned_strings);
-
     ruby_vm_at_exit(Deinit_rbs_extension);
 }