rbs 1.6.2 → 1.7.0.beta.4

data/ext/rbs_extension/ruby_objs.c

@@ -0,0 +1,521 @@
+#include "rbs_extension.h"
+
+#ifdef RB_PASS_KEYWORDS
+  // Ruby 2.7 or later
+  #define CLASS_NEW_INSTANCE(klass, argc, argv)\
+          rb_class_new_instance_kw(argc, argv, klass, RB_PASS_KEYWORDS)
+#else
+  // Ruby 2.6
+  #define CLASS_NEW_INSTANCE(receiver, argc, argv)\
+          rb_class_new_instance(argc, argv, receiver)
+#endif
+
+VALUE rbs_base_type(VALUE klass, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    klass,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_namespace(VALUE path, VALUE absolute) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("path")), path);
+  rb_hash_aset(args, ID2SYM(rb_intern("absolute")), absolute);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Namespace,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_type_name(VALUE namespace, VALUE name) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("namespace")), namespace);
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_TypeName,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_class_instance(VALUE typename, VALUE type_args, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), typename);
+  rb_hash_aset(args, ID2SYM(rb_intern("args")), type_args);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_ClassInstance,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_class_singleton(VALUE typename, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), typename);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_ClassSingleton,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_alias(VALUE typename, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), typename);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Alias,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_interface(VALUE typename, VALUE type_args, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), typename);
+  rb_hash_aset(args, ID2SYM(rb_intern("args")), type_args);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Interface,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_union(VALUE types, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("types")), types);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Union,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_intersection(VALUE types, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("types")), types);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Intersection,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_tuple(VALUE types, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("types")), types);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Tuple,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_optional(VALUE type, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Optional,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_block(VALUE type, VALUE required) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("required")), required);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Block,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_function_param(VALUE type, VALUE name, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Function_Param,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_function(
+  VALUE required_positional_params,
+  VALUE optional_positional_params,
+  VALUE rest_positional_param,
+  VALUE trailing_positional_params,
+  VALUE required_keyword_params,
+  VALUE optional_keyword_params,
+  VALUE rest_keyword_param,
+  VALUE return_type
+) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("required_positionals")), required_positional_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("optional_positionals")), optional_positional_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("rest_positionals")), rest_positional_param);
+  rb_hash_aset(args, ID2SYM(rb_intern("trailing_positionals")), trailing_positional_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("required_keywords")), required_keyword_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("optional_keywords")), optional_keyword_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("rest_keywords")), rest_keyword_param);
+  rb_hash_aset(args, ID2SYM(rb_intern("return_type")), return_type);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Function,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_proc(VALUE function, VALUE block, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), function);
+  rb_hash_aset(args, ID2SYM(rb_intern("block")), block);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Proc,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_void(VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Bases_Void,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_literal(VALUE literal, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("literal")), literal);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Literal,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_record(VALUE fields, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("fields")), fields);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Record,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_variable(VALUE name, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_Variable,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_method_type(VALUE type_params, VALUE type, VALUE block, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("type_params")), type_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("block")), block);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_MethodType,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_comment(VALUE string, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("string")), string);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Comment,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_annotation(VALUE string, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("string")), string);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Annotation,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_module_type_params() {
+  return rb_funcall(RBS_AST_Declarations_ModuleTypeParams, rb_intern("new"), 0);
+}
+
+VALUE rbs_ast_decl_module_type_params_param(VALUE name, VALUE variance, VALUE skip_validation, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("variance")), variance);
+  rb_hash_aset(args, ID2SYM(rb_intern("skip_validation")), skip_validation);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_ModuleTypeParams_TypeParam,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Constant,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Global,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_alias(VALUE name, VALUE type, VALUE annotations, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Alias,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE annotations, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type_params")), type_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("members")), members);
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Interface,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location) {
+  VALUE kw_args = rb_hash_new();
+  rb_hash_aset(kw_args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(kw_args, ID2SYM(rb_intern("args")), args);
+  rb_hash_aset(kw_args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Module_Self,
+    1,
+    &kw_args
+  );
+}
+
+VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type_params")), type_params);
+  rb_hash_aset(args, ID2SYM(rb_intern("self_types")), self_types);
+  rb_hash_aset(args, ID2SYM(rb_intern("members")), members);
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Module,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("kind")), kind);
+  rb_hash_aset(args, ID2SYM(rb_intern("types")), types);
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+  rb_hash_aset(args, ID2SYM(rb_intern("overload")), overload);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Members_MethodDefinition,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_variable(VALUE klass, VALUE name, VALUE type, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    klass,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_mixin(VALUE klass, VALUE name, VALUE module_args, VALUE annotations, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("args")), module_args);
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    klass,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
+  rb_hash_aset(args, ID2SYM(rb_intern("ivar_name")), ivar_name);
+  rb_hash_aset(args, ID2SYM(rb_intern("kind")), kind);
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    klass,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_visibility(VALUE klass, VALUE location) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    klass,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_alias(VALUE new_name, VALUE old_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("new_name")), new_name);
+  rb_hash_aset(args, ID2SYM(rb_intern("old_name")), old_name);
+  rb_hash_aset(args, ID2SYM(rb_intern("kind")), kind);
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Members_Alias,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location) {
+  VALUE kwargs = rb_hash_new();
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("args")), args);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Class_Super,
+    1,
+    &kwargs
+  );
+}
+
+VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment) {
+  VALUE kwargs = rb_hash_new();
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("type_params")), type_params);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("super_class")), super_class);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("members")), members);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_Class,
+    1,
+    &kwargs
+  );
+}

data/ext/rbs_extension/ruby_objs.h

@@ -0,0 +1,46 @@
+#ifndef RBS__RUBY_OBJS_H
+#define RBS__RUBY_OBJS_H
+
+#include "ruby.h"
+
+VALUE rbs_alias(VALUE typename, VALUE location);
+VALUE rbs_ast_annotation(VALUE string, VALUE location);
+VALUE rbs_ast_comment(VALUE string, VALUE location);
+VALUE rbs_ast_decl_alias(VALUE name, VALUE type, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
+VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location);
+VALUE rbs_ast_decl_module_type_params_param(VALUE name, VALUE variance, VALUE skip_validation, VALUE location);
+VALUE rbs_ast_decl_module_type_params();
+VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_alias(VALUE new_name, VALUE old_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload);
+VALUE rbs_ast_members_mixin(VALUE klass, VALUE name, VALUE args, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_variable(VALUE klass, VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_members_visibility(VALUE klass, VALUE location);
+VALUE rbs_base_type(VALUE klass, VALUE location);
+VALUE rbs_block(VALUE type, VALUE required);
+VALUE rbs_class_instance(VALUE typename, VALUE type_args, VALUE location);
+VALUE rbs_class_singleton(VALUE typename, VALUE location);
+VALUE rbs_function_param(VALUE type, VALUE name, VALUE location);
+VALUE rbs_function(VALUE required_positional_params, VALUE optional_positional_params, VALUE rest_positional_params, VALUE trailing_positional_params, VALUE required_keywords, VALUE optional_keywords, VALUE rest_keywords, VALUE return_type);
+VALUE rbs_interface(VALUE typename, VALUE type_args, VALUE location);
+VALUE rbs_intersection(VALUE types, VALUE location);
+VALUE rbs_literal(VALUE literal, VALUE location);
+VALUE rbs_method_type(VALUE type_params, VALUE type, VALUE block, VALUE location);
+VALUE rbs_namespace(VALUE path, VALUE absolute);
+VALUE rbs_optional(VALUE type, VALUE location);
+VALUE rbs_proc(VALUE function, VALUE block, VALUE location);
+VALUE rbs_record(VALUE fields, VALUE location);
+VALUE rbs_tuple(VALUE types, VALUE location);
+VALUE rbs_type_name(VALUE namespace, VALUE name);
+VALUE rbs_union(VALUE types, VALUE location);
+VALUE rbs_variable(VALUE name, VALUE location);
+
+void pp(VALUE object);
+
+#endif

data/ext/rbs_extension/unescape.c

@@ -0,0 +1,65 @@
+#include "rbs_extension.h"
+
+static VALUE REGEXP = 0;
+static VALUE HASH = 0;
+
+static const char *regexp_str = "\\\\[abefnrstv\"]";
+
+static ID gsub = 0;
+
+void rbs_unescape_string(VALUE string) {
+  if (!REGEXP) {
+    REGEXP = rb_reg_new(regexp_str, strlen(regexp_str), 0);
+    rb_global_variable(&REGEXP);
+  }
+
+  if (!gsub) {
+    gsub = rb_intern("gsub!");
+  }
+
+  if (!HASH) {
+    HASH = rb_hash_new();
+    rb_hash_aset(HASH, rb_str_new_literal("\\a"), rb_str_new_literal("\a"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\b"), rb_str_new_literal("\b"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\e"), rb_str_new_literal("\e"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\f"), rb_str_new_literal("\f"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\n"), rb_str_new_literal("\n"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\r"), rb_str_new_literal("\r"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\s"), rb_str_new_literal(" "));
+    rb_hash_aset(HASH, rb_str_new_literal("\\t"), rb_str_new_literal("\t"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\v"), rb_str_new_literal("\v"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\\""), rb_str_new_literal("\""));
+    rb_global_variable(&HASH);
+  }
+
+  rb_funcall(string, gsub, 2, REGEXP, HASH);
+}
+
+VALUE rbs_unquote_string(parserstate *state, range rg, int offset_bytes) {
+  VALUE string = state->lexstate->string;
+  rb_encoding *enc = rb_enc_get(string);
+
+  unsigned int first_char = rb_enc_mbc_to_codepoint(
+    RSTRING_PTR(string) + rg.start.byte_pos + offset_bytes,
+    RSTRING_END(string),
+    enc
+  );
+
+  int byte_length = rg.end.byte_pos - rg.start.byte_pos - offset_bytes;
+
+  if (first_char == '"' || first_char == '\'' || first_char == '`') {
+    int bs = rb_enc_codelen(first_char, enc);
+    offset_bytes += bs;
+    byte_length -= 2 * bs;
+  }
+
+  char *buffer = RSTRING_PTR(state->lexstate->string) + rg.start.byte_pos + offset_bytes;
+  VALUE str = rb_enc_str_new(buffer, byte_length, enc);
+
+  if (first_char == '\"') {
+    rbs_unescape_string(str);
+  }
+
+  return str;
+}
+

data/goodcheck.yml

@@ -40,7 +40,7 @@ rules:
     glob:
       - "**/*.rbs"
     justification:
-      - When you strictly want `true | false`.
+      - When you strictly want `true | false`. Use `bool` in this case.
     pass:
       - "(arg: boolish)"
       - "{ () -> boolish }"

data/lib/rbs/ast/comment.rb

@@ -22,18 +22,6 @@ module RBS
       def to_json(state = _ = nil)
         { string: string, location: location }.to_json(state)
       end
-
-      def concat(string:, location:)
-        @string.concat string
-
-        if loc = @location
-          loc.concat location
-        else
-          @location = location
-        end
-
-        self
-      end
     end
   end
 end

data/lib/rbs/buffer.rb

@@ -46,5 +46,9 @@ module RBS
     def last_position
       content.size
     end
+
+    def inspect
+      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{lines.size} lines,>"
+    end
   end
 end

data/lib/rbs/cli.rb

@@ -749,14 +749,11 @@ Examples:
       args.each do |path|
         path = Pathname(path)
         loader.each_file(path, skip_hidden: false, immediate: true) do |file_path|
-          Parser.parse_signature(file_path.read)
-        rescue RBS::Parser::SyntaxError => ex
-          loc = ex.error_value.location
-          stdout.puts "#{file_path}:#{loc.start_line}:#{loc.start_column}: parse error on value: (#{ex.token_str})"
-          syntax_error = true
-        rescue RBS::Parser::SemanticsError => ex
-          loc = ex.location
-          stdout.puts "#{file_path}:#{loc.start_line}:#{loc.start_column}: #{ex.original_message}"
+          RBS.logger.info "Parsing #{file_path}..."
+          buffer = Buffer.new(content: file_path.read, name: file_path)
+          Parser.parse_signature(buffer)
+        rescue RBS::ParsingError => ex
+          stdout.puts ex.message
           syntax_error = true
         end
       end

data/lib/rbs/collection/installer.rb

@@ -11,6 +11,7 @@ module RBS
 
       def install_from_lockfile
         install_to = lockfile.repo_path
+        install_to.mkpath
         lockfile.gems.each do |config_entry|
           source_for(config_entry).install(dest: install_to, config_entry: config_entry, stdout: stdout)
         end