rbs 1.6.0 → 1.7.0.beta.2

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/sources/git.rb

@@ -1,5 +1,6 @@
 require 'digest/sha2'
 require 'open3'
+require 'find'
 
 module RBS
   module Collection
@@ -52,12 +53,26 @@ module RBS
         private def _install(dest:, config_entry:)
           gem_name = config_entry['name']
           version = config_entry['version'] or raise
-          dest = dest.join(gem_name)
+          dest = dest.join(gem_name, version)
           dest.mkpath
           src = gem_repo_dir.join(gem_name, version)
 
-          FileUtils.cp_r(src, dest)
-          dest.join(version, METADATA_FILENAME).write(YAML.dump(config_entry))
+          cp_r(src, dest)
+          dest.join(METADATA_FILENAME).write(YAML.dump(config_entry))
+        end
+
+        private def cp_r(src, dest)
+          Find.find(src) do |file_src|
+            file_src = Pathname(file_src)
+
+            # Skip file if it starts with _, such as _test/
+            Find.prune if file_src.basename.to_s.start_with?('_')
+
+            file_src_relative = file_src.relative_path_from(src)
+            file_dest = dest.join(file_src_relative)
+            file_dest.dirname.mkpath
+            FileUtils.copy_entry(file_src, file_dest, false, true) unless file_src.directory?
+          end
         end
 
         def to_lockfile

data/lib/rbs/errors.rb

@@ -15,10 +15,31 @@ module RBS
   end
 
   class ErrorBase < StandardError; end
-  class ParsingError < ErrorBase; end
   class LoadingError < ErrorBase; end
   class DefinitionError < ErrorBase; end
 
+  class ParsingError < ErrorBase
+    attr_reader :location
+    attr_reader :error_message
+    attr_reader :token_type
+
+    def initialize(location, error_message, token_type)
+      @location = location
+      @error_message = error_message
+      @token_type = token_type
+
+      super "#{Location.to_string location}: Syntax error: #{error_message}, token=`#{location.source}` (#{token_type})"
+    end
+
+    def error_value
+      location.source
+    end
+
+    def token_str
+      token_type
+    end
+  end
+
   class InvalidTypeApplicationError < DefinitionError
     attr_reader :type_name
     attr_reader :args

data/lib/rbs/location.rb

@@ -1,217 +1,221 @@
-module RBS
-  class Location
-    attr_reader :buffer
-    attr_reader :start_pos
-    attr_reader :end_pos
-
-    def initialize(buffer:, start_pos:, end_pos:)
-      @buffer = buffer
-      @start_pos = start_pos
-      @end_pos = end_pos
-    end
-
-    def inspect
-      "#<#{self.class}:#{self.__id__} @buffer=#{buffer.name}, @pos=#{start_pos}...#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
-    end
-
-    def name
-      buffer.name
-    end
-
-    def start_line
-      start_loc[0]
-    end
-
-    def start_column
-      start_loc[1]
-    end
-
-    def end_line
-      end_loc[0]
-    end
-
-    def end_column
-      end_loc[1]
-    end
-
-    def start_loc
-      @start_loc ||= buffer.pos_to_loc(start_pos)
-    end
-
-    def end_loc
-      @end_loc ||= buffer.pos_to_loc(end_pos)
-    end
-
-    def range
-      start_pos...end_pos
-    end
-
-    def source
-      @source ||= buffer.content[start_pos...end_pos] or raise
-    end
-
-    def to_s
-      "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
-    end
-
-    def self.to_string(location, default: "*:*:*...*:*")
-      location&.to_s || default
-    end
-
-    def ==(other)
-      other.is_a?(Location) &&
-        other.buffer == buffer &&
-        other.start_pos == start_pos &&
-        other.end_pos == end_pos
-    end
-
-    def +(other)
-      if other
-        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
-
-        self.class.new(buffer: buffer,
-                       start_pos: start_pos,
-                       end_pos: other.end_pos)
-      else
-        self
-      end
-    end
-
-    def concat(*others)
-      others.each { |other| self << other }
-      self
-    end
-
-    def <<(other)
-      if other
-        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
-        @end_pos = other.end_pos
-        @source = nil
-        @end_loc = nil
-      end
-      self
-    end
-
-    def pred?(loc)
-      loc.is_a?(Location) &&
-        loc.name == name &&
-        loc.start_pos == end_pos
-    end
-
-    def to_json(state = _ = nil)
-      {
-        start: {
-          line: start_line,
-          column: start_column
-        },
-        end: {
-          line: end_line,
-          column: end_column
-        },
-        buffer: {
-          name: name&.to_s
-        }
-      }.to_json(state)
-    end
-
-    def with_children(required: {}, optional: {})
-      # @type var required: Hash[Symbol, Range[Integer] | Location]
-      # @type var optional: Hash[Symbol, Range[Integer] | Location | nil]
-
-      this = WithChildren.new(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
-
-      req = required.transform_values do |value|
-        case value
-        when Location
-          value.range
-        else
-          value
-        end
-      end
-
-      opt = optional.transform_values do |value|
-        case value
-        when Location
-          value.range
-        else
-          value
-        end
-      end
-
-      this.required_children.merge!(req)
-      this.optional_children.merge!(opt)
-
-      this
-    end
-
-    class WithChildren < Location
-      attr_reader :required_children, :optional_children
-
-      def initialize(buffer:, start_pos:, end_pos:)
-        super(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
-
-        @optional_children = {}
-        @required_children = {}
-      end
-
-      def initialize_copy(from)
-        required_children.merge!(from.required_children)
-        optional_children.merge!(from.optional_children)
-        self
-      end
-
-      def [](key)
-        case
-        when required_children.key?(_ = key)
-          range = required_children[_ = key]
-          Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
-        when optional_children.key?(_ = key)
-          range = required_children[_ = key] || optional_children[_ = key]
-          if range
-            Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
-          end
-        else
-          raise "Unknown key given: `#{key}`"
-        end
-      end
-
-      def merge_required(hash)
-        this = dup
-
-        h = hash.transform_values do |value|
-          case value
-          when Range
-            value
-          when Location
-            value.range
-          else
-            raise
-          end
-        end
-
-        this.required_children.merge!(h)
-
-        this
-      end
-
-      def merge_optional(hash)
-        this = dup
-
-        h = hash.transform_values do |value|
-          case value
-          when Range
-            value
-          when Location
-            value.range
-          else
-            nil
-          end
-        end
-
-        this.optional_children.merge!(h)
-
-        this
-      end
-    end
-  end
-end
+# module RBS
+#   class Location
+#     attr_reader :buffer
+#     attr_reader :start_pos
+#     attr_reader :end_pos
+
+#     def initialize(buffer, start_pos, end_pos)
+#       @buffer = buffer
+#       @start_pos = start_pos
+#       @end_pos = end_pos
+#     end
+
+#     # def self.new(buffer_ = nil, start_pos_ = nil, end_pos_ = nil)
+#     #   __skip__ = super(buffer_, start_pos_, end_pos_)
+#     # end
+
+#     # def inspect
+#     #   "#<#{self.class}:#{self.__id__} @buffer=#{buffer.name}, @pos=#{start_pos}...#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
+#     # end
+
+#     def name
+#       buffer.name
+#     end
+
+#     def start_line
+#       start_loc[0]
+#     end
+
+#     def start_column
+#       start_loc[1]
+#     end
+
+#     def end_line
+#       end_loc[0]
+#     end
+
+#     def end_column
+#       end_loc[1]
+#     end
+
+#     def start_loc
+#       @start_loc ||= buffer.pos_to_loc(start_pos)
+#     end
+
+#     def end_loc
+#       @end_loc ||= buffer.pos_to_loc(end_pos)
+#     end
+
+#     def range
+#       start_pos...end_pos
+#     end
+
+#     def source
+#       @source ||= buffer.content[start_pos...end_pos] or raise
+#     end
+
+#     def to_s
+#       "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
+#     end
+
+#     def self.to_string(location, default: "*:*:*...*:*")
+#       location&.to_s || default
+#     end
+
+#     def ==(other)
+#       other.is_a?(Location) &&
+#         other.buffer == buffer &&
+#         other.start_pos == start_pos &&
+#         other.end_pos == end_pos
+#     end
+
+#     def +(other)
+#       if other
+#         raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+
+#         self.class.new(buffer: buffer,
+#                        start_pos: start_pos,
+#                        end_pos: other.end_pos)
+#       else
+#         self
+#       end
+#     end
+
+#     def concat(*others)
+#       others.each { |other| self << other }
+#       self
+#     end
+
+#     def <<(other)
+#       if other
+#         raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+#         @end_pos = other.end_pos
+#         @source = nil
+#         @end_loc = nil
+#       end
+#       self
+#     end
+
+#     def pred?(loc)
+#       loc.is_a?(Location) &&
+#         loc.name == name &&
+#         loc.start_pos == end_pos
+#     end
+
+#     def to_json(state = _ = nil)
+#       {
+#         start: {
+#           line: start_line,
+#           column: start_column
+#         },
+#         end: {
+#           line: end_line,
+#           column: end_column
+#         },
+#         buffer: {
+#           name: name&.to_s
+#         }
+#       }.to_json(state)
+#     end
+
+#     def with_children(required: {}, optional: {})
+#       # @type var required: Hash[Symbol, Range[Integer] | Location]
+#       # @type var optional: Hash[Symbol, Range[Integer] | Location | nil]
+
+#       this = WithChildren.new(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
+
+#       req = required.transform_values do |value|
+#         case value
+#         when Location
+#           value.range
+#         else
+#           value
+#         end
+#       end
+
+#       opt = optional.transform_values do |value|
+#         case value
+#         when Location
+#           value.range
+#         else
+#           value
+#         end
+#       end
+
+#       this.required_children.merge!(req)
+#       this.optional_children.merge!(opt)
+
+#       this
+#     end
+
+#     class WithChildren < Location
+#       attr_reader :required_children, :optional_children
+
+#       def initialize(buffer, start_pos, end_pos)
+#         super(buffer, start_pos, end_pos)
+
+#         @optional_children = {}
+#         @required_children = {}
+#       end
+
+#       def initialize_copy(from)
+#         required_children.merge!(from.required_children)
+#         optional_children.merge!(from.optional_children)
+#         self
+#       end
+
+#       def [](key)
+#         case
+#         when required_children.key?(_ = key)
+#           range = required_children[_ = key]
+#           Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
+#         when optional_children.key?(_ = key)
+#           range = required_children[_ = key] || optional_children[_ = key]
+#           if range
+#             Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
+#           end
+#         else
+#           raise "Unknown key given: `#{key}`"
+#         end
+#       end
+
+#       def merge_required(hash)
+#         this = dup
+
+#         h = hash.transform_values do |value|
+#           case value
+#           when Range
+#             value
+#           when Location
+#             value.range
+#           else
+#             raise
+#           end
+#         end
+
+#         this.required_children.merge!(h)
+
+#         this
+#       end
+
+#       def merge_optional(hash)
+#         this = dup
+
+#         h = hash.transform_values do |value|
+#           case value
+#           when Range
+#             value
+#           when Location
+#             value.range
+#           else
+#             nil
+#           end
+#         end
+
+#         this.optional_children.merge!(h)
+
+#         this
+#       end
+#     end
+#   end
+# end