rbs 4.0.0.dev.5 → 4.0.1.dev.1

data/lib/rbs/definition_builder.rb

@@ -398,6 +398,19 @@ module RBS
                         .update(type_params: class_params + method_type.type_params)
                     end
 
+                    method_type = method_type.map_type do |type|
+                      case type
+                      when Types::Bases::Self
+                        Types::ClassInstance.new(
+                          name: type_name,
+                          args: entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) },
+                          location: nil
+                        )
+                      else
+                        type
+                      end
+                    end
+
                     method_type = method_type.update(
                       type: method_type.type.with_return_type(
                         Types::ClassInstance.new(
@@ -695,12 +708,14 @@ module RBS
           )
         end
 
+        accessibility = special_accessibility(original.instance?, original.new_name) || original_method.accessibility
+
         method_definition = Definition::Method.new(
           super_method: existing_method,
           defs: original_method.defs.map do |defn|
             defn.update(defined_in: defined_in, implemented_in: implemented_in)
           end,
-          accessibility: original_method.accessibility,
+          accessibility: accessibility,
           alias_of: original_method,
           alias_member: original
         )
@@ -727,13 +742,9 @@ module RBS
           end
         end
 
-        # @type var accessibility: RBS::Definition::accessibility
-        accessibility =
-          if original.instance? && [:initialize, :initialize_copy, :initialize_clone, :initialize_dup, :respond_to_missing?].include?(method.name)
-            :private
-          else
-            method.accessibility
-          end
+        # Respect the visibility of the original method definition.
+        accessibility = original.visibility || special_accessibility(original.instance?, method.name) || method.accessibility
+
         # Skip setting up `super_method` if `implemented_in` is `nil`, that means the type doesn't have implementation.
         # This typically happens if the type is an interface.
         if implemented_in
@@ -786,6 +797,9 @@ module RBS
           super_method = existing_method
         end
 
+        # Respect the visibility of the original method definition.
+        accessibility = original.visibility || special_accessibility(original.kind == :instance, method.name) || method.accessibility
+
         method_definition = Definition::Method.new(
           super_method: super_method,
           defs: [
@@ -796,7 +810,7 @@ module RBS
               implemented_in: implemented_in
             )
           ],
-          accessibility: method.accessibility,
+          accessibility: accessibility,
           alias_of: nil,
           alias_member: nil
         )
@@ -864,27 +878,40 @@ module RBS
           )
         end
 
-        defs = original.overloads.map do |overload|
-          Definition::Method::TypeDef.new(
-            type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
-            member: original,
-            defined_in: defined_in,
-            implemented_in: implemented_in
-          ).tap do |type_def|
-            # Keep the original annotations given to overloads.
-            type_def.overload_annotations.replace(overload.annotations)
+        if original.method_type.empty? && existing_method
+          # Unannotated method with a parent definition → inherit from the parent, like @rbs ...
+          method_definition = Definition::Method.new(
+            super_method: existing_method,
+            defs: existing_method.defs.map { |defn| defn.update(implemented_in: implemented_in) },
+            accessibility: :public,
+            alias_of: existing_method.alias_of,
+            alias_member: nil
+          )
+
+          method_definition.annotations.replace(existing_method.annotations)
+        else
+          defs = original.overloads.map do |overload|
+            Definition::Method::TypeDef.new(
+              type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            ).tap do |type_def|
+              # Keep the original annotations given to overloads.
+              type_def.overload_annotations.replace(overload.annotations)
+            end
           end
-        end
 
-        method_definition = Definition::Method.new(
-          super_method: existing_method,
-          defs: defs,
-          accessibility: :public,
-          alias_of: nil,
-          alias_member: nil
-        )
+          method_definition = Definition::Method.new(
+            super_method: existing_method,
+            defs: defs,
+            accessibility: :public,
+            alias_of: nil,
+            alias_member: nil
+          )
 
-        method_definition.annotations.replace([])
+          method_definition.annotations.replace([])
+        end
 
       when nil
         # Overloading method definition only
@@ -943,6 +970,12 @@ module RBS
       methods[method.name] = method_definition
     end
 
+    def special_accessibility(is_instance, method_name)
+      if is_instance && [:initialize, :initialize_copy, :initialize_clone, :initialize_dup, :respond_to_missing?].include?(method_name)
+        :private
+      end
+    end
+
     def try_cache(type_name, cache:)
       cache[type_name] ||= yield
     end

data/lib/rbs/errors.rb

@@ -611,17 +611,6 @@ module RBS
     end
   end
 
-  class WillSyntaxError < DefinitionError
-    include DetailedMessageable
-
-    attr_reader :location
-
-    def initialize(message, location:)
-      super "#{Location.to_string(location)}: #{message}"
-      @location = location
-    end
-  end
-
   class TypeParamDefaultReferenceError < DefinitionError
     include DetailedMessageable
 

data/lib/rbs/inline_parser.rb

@@ -196,7 +196,7 @@ module RBS
             trailing_block = comments.trailing_block!(end_loc)
           end
 
-          method_type, leading_unuseds, trailing_unused = AST::Ruby::Members::MethodTypeAnnotation.build(leading_block, trailing_block, [])
+          method_type, leading_unuseds, trailing_unused = AST::Ruby::Members::MethodTypeAnnotation.build(leading_block, trailing_block, [], node)
           report_unused_annotation(trailing_unused, *leading_unuseds)
 
           defn = AST::Ruby::Members::DefMember.new(buffer, node.name, node, method_type, leading_block)

data/lib/rbs/parser_aux.rb

@@ -5,14 +5,16 @@ require_relative "parser/token"
 
 module RBS
   class Parser
-    def self.parse_type(source, range: 0..., variables: [], require_eof: false, void_allowed: true, self_allowed: true)
+    def self.parse_type(source, range: nil, byte_range: 0..., variables: [], require_eof: false, void_allowed: true, self_allowed: true, classish_allowed: true)
       buf = buffer(source)
-      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof, void_allowed, self_allowed)
+      byte_range = byte_range(range, buf.content) if range
+      _parse_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof, void_allowed, self_allowed, classish_allowed)
     end
 
-    def self.parse_method_type(source, range: 0..., variables: [], require_eof: false)
+    def self.parse_method_type(source, range: nil, byte_range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
-      _parse_method_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
+      byte_range = byte_range(range, buf.content) if range
+      _parse_method_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof)
     end
 
     def self.parse_signature(source)
@@ -25,7 +27,8 @@ module RBS
         else
           0
         end
-      dirs, decls = _parse_signature(buf, start_pos, buf.last_position)
+      content = buf.content
+      dirs, decls = _parse_signature(buf, start_pos, content.bytesize)
 
       if resolved
         dirs = dirs.dup if dirs.frozen?
@@ -37,7 +40,7 @@ module RBS
 
     def self.parse_type_params(source, module_type_params: true)
       buf = buffer(source)
-      _parse_type_params(buf, 0, buf.last_position, module_type_params)
+      _parse_type_params(buf, 0, buf.content.bytesize, module_type_params)
     end
 
     def self.magic_comment(buf)
@@ -66,7 +69,7 @@ module RBS
 
     def self.lex(source)
       buf = buffer(source)
-      list = _lex(buf, buf.last_position)
+      list = _lex(buf, buf.content.bytesize)
       value = list.map do |type, location|
         Token.new(type: type, location: location)
       end
@@ -125,5 +128,15 @@ module RBS
       buf = buffer(source)
       _parse_inline_trailing_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
     end
+
+    def self.byte_range(char_range, content)
+      start_offset = char_range.begin
+      end_offset = char_range.end
+
+      start_prefix = content[0, start_offset] or raise if start_offset
+      end_prefix = content[0, end_offset] or raise if end_offset
+
+      start_prefix&.bytesize...end_prefix&.bytesize
+    end
   end
 end

data/lib/rbs/prototype/helpers.rb

@@ -5,6 +5,63 @@ module RBS
     module Helpers
       private
 
+      # Prism can't parse Ruby 3.2 code
+      if RUBY_VERSION >= "3.3"
+        def parse_comments(string, include_trailing:)
+          Prism.parse_comments(string, version: "current").yield_self do |prism_comments| # steep:ignore UnexpectedKeywordArgument
+            prism_comments.each_with_object({}) do |comment, hash| #$ Hash[Integer, AST::Comment]
+              # Skip EmbDoc comments
+              next unless comment.is_a?(Prism::InlineComment)
+              # skip like `module Foo # :nodoc:`
+              next if comment.trailing? && !include_trailing
+
+              line = comment.location.start_line
+              body = "#{comment.location.slice}\n"
+              body = body[2..-1] or raise
+              body = "\n" if body.empty?
+
+              comment = AST::Comment.new(string: body, location: nil)
+              if prev_comment = hash.delete(line - 1)
+                hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
+                                              location: nil)
+              else
+                hash[line] = comment
+              end
+            end
+          end
+        end
+      else
+        require "ripper"
+        def parse_comments(string, include_trailing:)
+          Ripper.lex(string).yield_self do |tokens|
+            code_lines = {} #: Hash[Integer, bool]
+            tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
+              case token[1]
+              when :on_sp, :on_ignored_nl
+                # skip
+              when :on_comment
+                line = token[0][0]
+                # skip like `module Foo # :nodoc:`
+                next if code_lines[line] && !include_trailing
+                body = token[2][2..-1] or raise
+
+                body = "\n" if body.empty?
+
+                comment = AST::Comment.new(string: body, location: nil)
+                if prev_comment = hash.delete(line - 1)
+                  hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
+                                                location: nil)
+                else
+                  hash[line] = comment
+                end
+              else
+                code_lines[token[0][0]] = true
+              end
+            end
+          end
+        end
+      end
+
       def block_from_body(node)
         _, args_node, body_node = node.children
         _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block_var = args_from_node(args_node)

data/lib/rbs/prototype/rb.rb

@@ -74,32 +74,7 @@ module RBS
 
       def parse(string)
         # @type var comments: Hash[Integer, AST::Comment]
-        comments = Ripper.lex(string).yield_self do |tokens|
-          code_lines = {} #: Hash[Integer, bool]
-          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
-            case token[1]
-            when :on_sp, :on_ignored_nl
-              # skip
-            when :on_comment
-              line = token[0][0]
-              # skip like `module Foo # :nodoc:`
-              next if code_lines[line]
-              body = token[2][2..-1] or raise
-
-              body = "\n" if body.empty?
-
-              comment = AST::Comment.new(string: body, location: nil)
-              if prev_comment = hash.delete(line - 1)
-                hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
-                                              location: nil)
-              else
-                hash[line] = comment
-              end
-            else
-              code_lines[token[0][0]] = true
-            end
-          end
-        end
+        comments = parse_comments(string, include_trailing: false)
 
         process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, context: Context.initial
       end

data/lib/rbs/prototype/rbi.rb

@@ -16,26 +16,7 @@ module RBS
       end
 
       def parse(string)
-        comments = Ripper.lex(string).yield_self do |tokens|
-          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
-            if token[1] == :on_comment
-              line = token[0][0]
-              body = token[2][2..-1] or raise
-
-              body = "\n" if body.empty?
-
-              comment = AST::Comment.new(string: body, location: nil)
-              if (prev_comment = hash.delete(line - 1))
-                hash[line] = AST::Comment.new(
-                  string: prev_comment.string + comment.string,
-                  location: nil
-                )
-              else
-                hash[line] = comment
-              end
-            end
-          end
-        end
+        comments = parse_comments(string, include_trailing: true)
         process RubyVM::AbstractSyntaxTree.parse(string), comments: comments
       end
 

data/lib/rbs/test/type_check.rb

@@ -264,6 +264,9 @@ module RBS
           klass = get_class(type.name) or return false
           if params = builder.env.normalized_module_class_entry(type.name.absolute!)&.type_params
             args = AST::TypeParam.normalize_args(params, type.args)
+            if args.size != params.size
+              return false
+            end
             unless args == type.args
               type = Types::ClassInstance.new(name: type.name, args: args, location: type.location)
             end

data/lib/rbs/types.rb

@@ -199,58 +199,6 @@ module RBS
       end
     end
 
-    class ClassSingleton
-      attr_reader :name
-      attr_reader :location
-
-      def initialize(name:, location:)
-        @name = name
-        @location = location
-      end
-
-      def ==(other)
-        other.is_a?(ClassSingleton) && other.name == name
-      end
-
-      alias eql? ==
-
-      def hash
-        self.class.hash ^ name.hash
-      end
-
-      include NoFreeVariables
-      include NoSubst
-
-      def to_json(state = nil)
-        { class: :class_singleton, name: name, location: location }.to_json(state)
-      end
-
-      def to_s(level = 0)
-        "singleton(#{name})"
-      end
-
-      include EmptyEachType
-
-      def map_type_name(&)
-        ClassSingleton.new(
-          name: yield(name, location, self),
-          location: location
-        )
-      end
-
-      def has_self_type?
-        false
-      end
-
-      def has_classish_type?
-        false
-      end
-
-      def with_nonreturn_void?
-        false
-      end
-    end
-
     module Application
       attr_reader :name
       attr_reader :args
@@ -309,6 +257,68 @@ module RBS
       end
     end
 
+    class ClassSingleton
+      attr_reader :location
+
+      include Application
+
+      def initialize(name:, location:, args: [])
+        @name = name
+        @location = location
+        @args = args
+      end
+
+      def ==(other)
+        other.is_a?(ClassSingleton) && other.name == name && other.args == args
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ name.hash ^ args.hash
+      end
+
+      def sub(s)
+        return self if s.empty?
+
+        self.class.new(name: name,
+                       args: args.map {|ty| ty.sub(s) },
+                       location: location)
+      end
+
+      def to_json(state = _ = nil)
+        { class: :class_singleton, name: name, args: args, location: location }.to_json(state)
+      end
+
+      def to_s(level = 0)
+        if args.empty?
+          "singleton(#{name})"
+        else
+          "singleton(#{name})[#{args.join(", ")}]"
+        end
+      end
+
+      def map_type_name(&block)
+        ClassSingleton.new(
+          name: yield(name, location, self),
+          args: args.map {|type| type.map_type_name(&block) },
+          location: location
+        )
+      end
+
+      def map_type(&block)
+        if block
+          ClassSingleton.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
+    end
+
     class Interface
       attr_reader :location
 

data/lib/rbs/unit_test/type_assertions.rb

@@ -192,6 +192,31 @@ module RBS
         end
       end
 
+      ruby2_keywords def assert_send_type_error(method_type, error_type, receiver, method, *args, &block)
+        send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
+          typecheck = RBS::Test::TypeCheck.new(
+            self_class: receiver.class,
+            builder: builder,
+            sample_size: 100,
+            unchecked_classes: [],
+            instance_class: instance_class,
+            class_class: class_class
+          )
+          errors = typecheck.method_call(method, method_type, trace, errors: [])
+
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
+
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
+          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+
+          # Use `instnace_of?` instead of `is_a?` as we want to check for _the exact exception class_.
+          assert exception.instance_of? error_type
+
+          result
+        end
+      end
+
       ruby2_keywords def refute_send_type(method_type, receiver, method, *args, &block)
         send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
           method_type = method_type.update(
@@ -231,15 +256,17 @@ module RBS
         type, definition = target
 
         case type
-        when Types::ClassInstance
-          subst = RBS::Substitution.build(definition.type_params, type.args)
-          definition.methods[method].defs.map do |type_def|
-            type_def.update(
-              type: type_def.type.sub(subst)
-            )
+        when Types::ClassInstance, Types::ClassSingleton
+          if type.is_a?(Types::ClassSingleton) && type.args.empty?
+            definition.methods[method].defs
+          else
+            subst = RBS::Substitution.build(definition.type_params, type.args)
+            definition.methods[method].defs.map do |type_def|
+              type_def.update(
+                type: type_def.type.sub(subst)
+              )
+            end
           end
-        when Types::ClassSingleton
-          definition.methods[method].defs
         else
           raise
         end

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "4.0.0.dev.5"
+  VERSION = "4.0.1.dev.1"
 end

data/lib/rbs.rb

@@ -6,7 +6,6 @@ require "set"
 require "json"
 require "pathname" unless defined?(Pathname)
 require "pp"
-require "ripper"
 require "logger"
 require "tsort"
 require "strscan"

data/rbs.gemspec

@@ -46,6 +46,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.required_ruby_version = ">= 3.2"
   spec.add_dependency "logger"
-  spec.add_dependency "prism", ">= 1.3.0"
+  spec.add_dependency "prism", ">= 1.6.0"
   spec.add_dependency "tsort"
 end

data/rust/.gitignore

@@ -0,0 +1 @@
+/target/