rbs 4.0.3 → 4.1.3

data/ext/rbs_extension/ast_translation.h

@@ -23,6 +23,10 @@ typedef struct rbs_translation_context {
     rbs_constant_pool_t *constant_pool;
     VALUE buffer;
     rb_encoding *encoding;
+
+    /// A reusable Hash used for calling `rb_class_new_instance_kw()` without allocating a new Hash each time.
+    /// It's vital that the various Nodes' `#initialize` methods take the kwarg values, but don't retain this reusable Hash.
+    VALUE reusable_kwargs_hash;
 } rbs_translation_context_t;
 
 rbs_translation_context_t rbs_translation_context_create(rbs_constant_pool_t *, VALUE buffer_string, rb_encoding *ruby_encoding);

data/ext/rbs_extension/class_constants.c

@@ -54,6 +54,7 @@ VALUE RBS_AST_Ruby_Annotations_DoubleSplatParamTypeAnnotation;
 VALUE RBS_AST_Ruby_Annotations_InstanceVariableAnnotation;
 VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
 VALUE RBS_AST_Ruby_Annotations_ModuleAliasAnnotation;
+VALUE RBS_AST_Ruby_Annotations_ModuleSelfAnnotation;
 VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 VALUE RBS_AST_Ruby_Annotations_ParamTypeAnnotation;
 VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
@@ -147,6 +148,7 @@ void rbs__init_constants(void) {
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_InstanceVariableAnnotation, RBS_AST_Ruby_Annotations, "InstanceVariableAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_MethodTypesAnnotation, RBS_AST_Ruby_Annotations, "MethodTypesAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ModuleAliasAnnotation, RBS_AST_Ruby_Annotations, "ModuleAliasAnnotation");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ModuleSelfAnnotation, RBS_AST_Ruby_Annotations, "ModuleSelfAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_NodeTypeAssertion, RBS_AST_Ruby_Annotations, "NodeTypeAssertion");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ParamTypeAnnotation, RBS_AST_Ruby_Annotations, "ParamTypeAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ReturnTypeAnnotation, RBS_AST_Ruby_Annotations, "ReturnTypeAnnotation");

data/ext/rbs_extension/class_constants.h

@@ -62,6 +62,7 @@ extern VALUE RBS_AST_Ruby_Annotations_DoubleSplatParamTypeAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_InstanceVariableAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_ModuleAliasAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_ModuleSelfAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 extern VALUE RBS_AST_Ruby_Annotations_ParamTypeAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;

data/ext/rbs_extension/extconf.rb

@@ -16,6 +16,7 @@ append_cflags [
   '-Wimplicit-fallthrough',
   '-Wunused-result',
   '-Wc++-compat',
+  '-Wnullable-to-nonnull-conversion',
 ]
 
 if ENV['DEBUG']

data/ext/rbs_extension/legacy_location.c

@@ -91,7 +91,7 @@ static rb_data_type_t location_type = {
     { rbs_loc_mark, (RUBY_DATA_FUNC) rbs_loc_free, rbs_loc_memsize },
     0,
     0,
-    RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE location_s_allocate(VALUE klass) {
@@ -114,10 +114,11 @@ static VALUE location_initialize(VALUE self, VALUE buffer, VALUE start_pos, VALU
     int end = FIX2INT(end_pos);
 
     *loc = (rbs_loc) {
-        .buffer = buffer,
+        .buffer = Qnil,
         .rg = (rbs_loc_range) { start, end },
         .children = NULL,
     };
+    RB_OBJ_WRITE(self, &loc->buffer, buffer);
 
     return Qnil;
 }
@@ -127,10 +128,11 @@ static VALUE location_initialize_copy(VALUE self, VALUE other) {
     rbs_loc *other_loc = rbs_check_location(other);
 
     *self_loc = (rbs_loc) {
-        .buffer = other_loc->buffer,
+        .buffer = Qnil,
         .rg = other_loc->rg,
         .children = NULL,
     };
+    RB_OBJ_WRITE(self, &self_loc->buffer, other_loc->buffer);
 
     if (other_loc->children != NULL) {
         rbs_loc_legacy_alloc_children(self_loc, other_loc->children->cap);
@@ -193,7 +195,8 @@ VALUE rbs_new_location(VALUE buffer, rbs_range_t rg) {
     rbs_loc *loc;
     VALUE obj = TypedData_Make_Struct(RBS_Location, rbs_loc, &location_type, loc);
 
-    rbs_loc_init(loc, buffer, (rbs_loc_range) { rg.start.char_pos, rg.end.char_pos });
+    rbs_loc_init(loc, Qnil, (rbs_loc_range) { rg.start.char_pos, rg.end.char_pos });
+    RB_OBJ_WRITE(obj, &loc->buffer, buffer);
 
     return obj;
 }
@@ -202,7 +205,8 @@ VALUE rbs_new_location2(VALUE buffer, int start_char, int end_char) {
     rbs_loc *loc;
     VALUE obj = TypedData_Make_Struct(RBS_Location, rbs_loc, &location_type, loc);
 
-    rbs_loc_init(loc, buffer, (rbs_loc_range) { .start = start_char, .end = end_char });
+    rbs_loc_init(loc, Qnil, (rbs_loc_range) { .start = start_char, .end = end_char });
+    RB_OBJ_WRITE(obj, &loc->buffer, buffer);
 
     return obj;
 }
@@ -211,7 +215,8 @@ static VALUE rbs_new_location_from_loc_range(VALUE buffer, rbs_loc_range rg) {
     rbs_loc *loc;
     VALUE obj = TypedData_Make_Struct(RBS_Location, rbs_loc, &location_type, loc);
 
-    rbs_loc_init(loc, buffer, rg);
+    rbs_loc_init(loc, Qnil, rg);
+    RB_OBJ_WRITE(obj, &loc->buffer, buffer);
 
     return obj;
 }

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"
@@ -145,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);
 
@@ -162,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);
@@ -285,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;
@@ -457,6 +589,9 @@ void rbs__init_parser(void) {
     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);