rbs 2.5.1 → 2.6.0

data/ext/rbs_extension/lexer.re

@@ -94,8 +94,8 @@ start:
       "untyped"       { return next_token(state, kUNTYPED); }
       "void"          { return next_token(state, kVOID); }
 
-      dqstring = ["] ("\\"["] | [^"\x00])* ["];
-      sqstring = ['] ("\\"['] | [^'\x00])* ['];
+      dqstring = ["] ("\\"[abefnrstv"\\] | [^"\\\x00])* ["];
+      sqstring = ['] ("\\"['\\] | [^'\x00])* ['];
 
       dqstring     { return next_token(state, tDQSTRING); }
       sqstring     { return next_token(state, tSQSTRING); }

data/ext/rbs_extension/rbs_extension.h

@@ -15,7 +15,7 @@
  *   '\\n' => "\n"
  *
  * */
-void rbs_unescape_string(VALUE string);
+void rbs_unescape_string(VALUE string, bool dq_string);
 
 /**
  * Receives `parserstate` and `range`, which represents a string token or symbol token, and returns a string VALUE.

data/ext/rbs_extension/unescape.c

@@ -1,16 +1,23 @@
 #include "rbs_extension.h"
 
-static VALUE REGEXP = 0;
+static VALUE DQ_REGEXP = 0;
+static VALUE SQ_REGEXP = 0;
 static VALUE HASH = 0;
 
-static const char *regexp_str = "\\\\[abefnrstv\"]";
+static const char *dq_regexp_str = "\\\\[abefnrstv\"\\\\]";
+static const char *sq_regexp_str = "\\\\[\'\\\\]";
 
 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);
+void rbs_unescape_string(VALUE string, bool dq_string) {
+  if (!DQ_REGEXP) {
+    DQ_REGEXP = rb_reg_new(dq_regexp_str, strlen(dq_regexp_str), 0);
+    rb_global_variable(&DQ_REGEXP);
+  }
+
+  if (!SQ_REGEXP) {
+    SQ_REGEXP = rb_reg_new(sq_regexp_str, strlen(sq_regexp_str), 0);
+    rb_global_variable(&SQ_REGEXP);
   }
 
   if (!gsub) {
@@ -30,9 +37,11 @@ void rbs_unescape_string(VALUE string) {
     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_hash_aset(HASH, rb_str_new_literal("\\\'"), rb_str_new_literal("'"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\\\"), rb_str_new_literal("\\"));
   }
 
-  rb_funcall(string, gsub, 2, REGEXP, HASH);
+  rb_funcall(string, gsub, 2, dq_string ? DQ_REGEXP : SQ_REGEXP, HASH);
 }
 
 VALUE rbs_unquote_string(parserstate *state, range rg, int offset_bytes) {
@@ -56,9 +65,7 @@ VALUE rbs_unquote_string(parserstate *state, range rg, int offset_bytes) {
   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);
-  }
+  rbs_unescape_string(str, first_char == '\"');
 
   return str;
 }

data/lib/rbs/ast/members.rb

@@ -282,7 +282,8 @@ module RBS
             kind: kind,
             annotations: annotations,
             location: location,
-            comment: comment
+            comment: comment,
+            visibility: visibility
           }.to_json(state)
         end
       end
@@ -299,7 +300,8 @@ module RBS
             kind: kind,
             annotations: annotations,
             location: location,
-            comment: comment
+            comment: comment,
+            visibility: visibility
           }.to_json(state)
         end
       end
@@ -316,7 +318,8 @@ module RBS
             kind: kind,
             annotations: annotations,
             location: location,
-            comment: comment
+            comment: comment,
+            visibility: visibility
           }.to_json(state)
         end
       end

data/lib/rbs/cli.rb

@@ -714,6 +714,8 @@ EOU
           Prototype::RBI.new()
         when "rb"
           Prototype::RB.new()
+        else
+          raise
         end
       end
 

data/lib/rbs/factory.rb

@@ -5,6 +5,8 @@ module RBS
 
       *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
 
+      name or raise
+
       TypeName.new(
         name: name,
         namespace: Namespace.new(path: path, absolute: absolute)

data/lib/rbs/prototype/helpers.rb

@@ -12,10 +12,7 @@ module RBS
 
         if block
           method_block = Types::Block.new(
-            # HACK: The `block` is :& on `def m(...)` syntax.
-            #       In this case the block looks optional in most cases, so it marks optional.
-            #       In other cases, we can't determine which is required or optional, so it marks required.
-            required: block != :&,
+            required: false,
             type: Types::Function.empty(untyped)
           )
         end
@@ -76,7 +73,6 @@ module RBS
         end
       end
 
-
       def any_node?(node, nodes: [], &block)
         if yield(node)
           nodes << node

data/lib/rbs/prototype/rb.rb

@@ -3,7 +3,9 @@ module RBS
     class RB
       include Helpers
 
-      Context = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
+      Context = _ = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
+        # @implements Context
+
         def self.initial(namespace: Namespace.root)
           self.new(module_function: false, singleton: false, namespace: namespace)
         end
@@ -35,9 +37,12 @@ module RBS
       end
 
       def decls
+        # @type var decls: Array[AST::Declarations::t]
         decls = []
 
-        top_decls, top_members = source_decls.partition {|decl| decl.is_a?(AST::Declarations::Base) }
+        # @type var top_decls: Array[AST::Declarations::t]
+        # @type var top_members: Array[AST::Members::t]
+        top_decls, top_members = _ = source_decls.partition {|decl| decl.is_a?(AST::Declarations::Base) }
 
         decls.push(*top_decls)
 
@@ -58,11 +63,18 @@ module RBS
       end
 
       def parse(string)
+        # @type var comments: Hash[Integer, AST::Comment]
         comments = Ripper.lex(string).yield_self do |tokens|
+          code_lines = {}
           tokens.each.with_object({}) do |token, hash|
-            if token[1] == :on_comment
+            case token[1]
+            when :on_sp, :on_ignored_nl
+              # skip
+            when :on_comment
               line = token[0][0]
-              body = token[2][2..-1]
+              # skip like `module Foo # :nodoc:`
+              next if code_lines[line]
+              body = token[2][2..-1] or raise
 
               body = "\n" if body.empty?
 
@@ -74,6 +86,8 @@ module RBS
               else
                 hash[line] = comment
               end
+            else
+              code_lines[token[0][0]] = true
             end
           end
         end
@@ -84,15 +98,18 @@ module RBS
       def process(node, decls:, comments:, context:)
         case node.type
         when :CLASS
-          class_name, super_class, *class_body = node.children
-          super_class_name = const_to_name(super_class)
-          if super_class_name.nil?
-            # Give up detect super class e.g. `class Foo < Struct.new(:bar)`
-            super_class = nil
-          end
+          class_name, super_class_node, *class_body = node.children
+          super_class_name = const_to_name(super_class_node, context: context)
+          super_class =
+            if super_class_name
+              AST::Declarations::Class::Super.new(name: super_class_name, args: [], location: nil)
+            else
+              # Give up detect super class e.g. `class Foo < Struct.new(:bar)`
+              nil
+            end
           kls = AST::Declarations::Class.new(
-            name: const_to_name(class_name),
-            super_class: super_class && AST::Declarations::Class::Super.new(name: super_class_name, args: [], location: nil),
+            name: const_to_name!(class_name),
+            super_class: super_class,
             type_params: [],
             members: [],
             annotations: [],
@@ -112,7 +129,7 @@ module RBS
           module_name, *module_body = node.children
 
           mod = AST::Declarations::Module.new(
-            name: const_to_name(module_name),
+            name: const_to_name!(module_name),
             type_params: [],
             self_types: [],
             members: [],
@@ -144,34 +161,36 @@ module RBS
           decls << accessibility
 
         when :DEFN, :DEFS
-            if node.type == :DEFN
-              def_name, def_body = node.children
-              kind = context.method_kind
-            else
-              _, def_name, def_body = node.children
-              kind = :singleton
-            end
+          # @type var kind: Context::method_kind
 
-            types = [
-              MethodType.new(
-                type_params: [],
-                type: function_type_from_body(def_body, def_name),
-                block: block_from_body(def_body),
-                location: nil
-              )
-            ]
-
-            member = AST::Members::MethodDefinition.new(
-              name: def_name,
-              location: nil,
-              annotations: [],
-              types: types,
-              kind: kind,
-              comment: comments[node.first_lineno - 1],
-              overload: false
+          if node.type == :DEFN
+            def_name, def_body = node.children
+            kind = context.method_kind
+          else
+            _, def_name, def_body = node.children
+            kind = :singleton
+          end
+
+          types = [
+            MethodType.new(
+              type_params: [],
+              type: function_type_from_body(def_body, def_name),
+              block: block_from_body(def_body),
+              location: nil
             )
+          ]
+
+          member = AST::Members::MethodDefinition.new(
+            name: def_name,
+            location: nil,
+            annotations: [],
+            types: types,
+            kind: kind,
+            comment: comments[node.first_lineno - 1],
+            overload: false
+          )
 
-            decls.push member unless decls.include?(member)
+          decls.push member unless decls.include?(member)
 
         when :ALIAS
           new_name, old_name = node.children.map { |c| literal_to_symbol(c) }
@@ -192,7 +211,7 @@ module RBS
           case node.children[0]
           when :include
             args.each do |arg|
-              if (name = const_to_name(arg))
+              if (name = const_to_name(arg, context: context))
                 decls << AST::Members::Include.new(
                   name: name,
                   args: [],
@@ -204,7 +223,7 @@ module RBS
             end
           when :prepend
             args.each do |arg|
-              if (name = const_to_name(arg))
+              if (name = const_to_name(arg, context: context))
                 decls << AST::Members::Prepend.new(
                   name: name,
                   args: [],
@@ -286,8 +305,10 @@ module RBS
               module_func_context = context.dup.tap { |ctx| ctx.module_function = true }
               args.each do |arg|
                 if arg && (name = literal_to_symbol(arg))
-                  if i = find_def_index_by_name(decls, name)
-                    decls[i] = decls[i].update(kind: :singleton_instance)
+                  if (i, defn = find_def_index_by_name(decls, name))
+                    if defn.is_a?(AST::Members::MethodDefinition)
+                      decls[i] = defn.update(kind: :singleton_instance)
+                    end
                   end
                 elsif arg
                   process arg, decls: decls, comments: comments, context: module_func_context
@@ -301,7 +322,7 @@ module RBS
             else
               args.each do |arg|
                 if arg && (name = literal_to_symbol(arg))
-                  if i = find_def_index_by_name(decls, name)
+                  if (i, _ = find_def_index_by_name(decls, name))
                     current = current_accessibility(decls, i)
                     if current != accessibility
                       decls.insert(i + 1, current)
@@ -335,7 +356,7 @@ module RBS
                        when node.children[0].is_a?(Symbol)
                          TypeName.new(name: node.children[0], namespace: Namespace.empty)
                        else
-                         const_to_name(node.children[0])
+                         const_to_name!(node.children[0])
                        end
 
           value_node = node.children.last
@@ -363,13 +384,13 @@ module RBS
         end
       end
 
-      def const_to_name(node, context: nil)
-        case node&.type
+      def const_to_name!(node)
+        case node.type
         when :CONST
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
         when :COLON2
           if node.children[0]
-            namespace = const_to_name(node.children[0]).to_namespace
+            namespace = const_to_name!(node.children[0]).to_namespace
           else
             namespace = Namespace.empty
           end
@@ -377,8 +398,19 @@ module RBS
           TypeName.new(name: node.children[1], namespace: namespace)
         when :COLON3
           TypeName.new(name: node.children[0], namespace: Namespace.root)
-        when :SELF
-          context&.then { |c| c.namespace.to_type_name }
+        else
+          raise
+        end
+      end
+
+      def const_to_name(node, context:)
+        if node
+          case node.type
+          when :SELF
+            context.namespace.to_type_name
+          when :CONST, :COLON2, :COLON3
+            const_to_name!(node)
+          end
         end
       end
 
@@ -561,6 +593,8 @@ module RBS
             value_type = types_to_union_type(value_types)
             BuiltinNames::Hash.instance_type(key_type, value_type)
           end
+        when :SELF
+          Types::Bases::Self.new(location: nil)
         when :CALL
           receiver, method_name, * = node.children
           case method_name
@@ -578,7 +612,9 @@ module RBS
         return untyped if types.empty?
 
         uniq = types.uniq
-        return uniq.first if uniq.size == 1
+        if uniq.size == 1
+          return uniq.first || raise
+        end
 
         Types::Union.new(types: uniq, location: nil)
       end
@@ -597,7 +633,7 @@ module RBS
         end.uniq
 
         if types.size == 1
-          types.first
+          types.first or raise
         else
           untyped
         end
@@ -647,11 +683,17 @@ module RBS
       end
 
       def current_accessibility(decls, index = decls.size)
-        idx = decls.slice(0, index).rindex { |decl| decl == private || decl == public }
-        (idx && decls[idx]) || public
+        slice = decls.slice(0, index) or raise
+        idx = slice.rindex { |decl| decl == private || decl == public }
+        if idx
+          _ = decls[idx]
+        else
+          public
+        end
       end
 
       def remove_unnecessary_accessibility_methods!(decls)
+        # @type var current: decl
         current = public
         idx = 0
 
@@ -673,7 +715,7 @@ module RBS
           idx += 1
         end
 
-        decls.pop while decls.last && is_accessibility?(decls.last)
+        decls.pop while decls.last && is_accessibility?(decls.last || raise)
       end
 
       def is_accessibility?(decl)
@@ -681,14 +723,21 @@ module RBS
       end
 
       def find_def_index_by_name(decls, name)
-        decls.find_index do |decl|
+        index = decls.find_index do |decl|
           case decl
           when AST::Members::MethodDefinition, AST::Members::AttrReader
             decl.name == name
           when AST::Members::AttrWriter
-            decl.name == :"#{name}="
+            :"#{decl.name}=" == name
           end
         end
+
+        if index
+          [
+            index,
+            _ = decls[index]
+          ]
+        end
       end
     end
   end