rbs 3.10.4 → 4.0.0

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)
+    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)
+      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
@@ -76,7 +79,7 @@ module RBS
     def self.buffer(source)
       case source
       when String
-        Buffer.new(content: source, name: "a.rbs")
+        Buffer.new(content: source, name: Pathname("a.rbs"))
       when Buffer
         source
       end
@@ -115,5 +118,25 @@ module RBS
       ).each_with_object({}) do |keyword, hash| #$ Hash[String, bot]
         hash[keyword] = _ = nil
       end
+
+    def self.parse_inline_leading_annotation(source, range, variables: [])
+      buf = buffer(source)
+      _parse_inline_leading_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
+    end
+
+    def self.parse_inline_trailing_annotation(source, range, variables: [])
+      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
@@ -372,8 +347,8 @@ module RBS
                        end
 
           value_node = node.children.last
-          type = if value_node.nil?
-                  # Give up type prediction when node is MASGN.
+          type = if value_node.nil? || value_node.type == :SELF
+                  # Give up type prediction when node is MASGN or SELF.
                   Types::Bases::Any.new(location: nil)
                 else
                   literal_to_type(value_node)

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
 
@@ -235,6 +216,7 @@ module RBS
                 variance: variance || :invariant,
                 location: nil,
                 upper_bound: nil,
+                lower_bound: nil,
                 default_type: nil
               )
             end
@@ -332,6 +314,7 @@ module RBS
                   name: name,
                   variance: :invariant,
                   upper_bound: nil,
+                  lower_bound: nil,
                   location: nil,
                   default_type: nil
                 )

data/lib/rbs/prototype/runtime.rb

@@ -27,6 +27,10 @@ module RBS
           method_definition = @builder.build_singleton(module_name.absolute!).methods[method.name]
           return false unless method_definition
 
+          return false unless method_definition.defs.any? do |type_def|
+            type_def.implemented_in&.relative!.to_s == method.owner.to_s.delete_prefix("#<Class:").delete_suffix(">")
+          end
+
           method_definition.accessibility == accessibility
         end
 
@@ -36,6 +40,10 @@ module RBS
           method_definition = @builder.build_instance(module_name.absolute!).methods[method.name]
           return false unless method_definition
 
+          return false unless method_definition.defs.any? do |type_def|
+            type_def.implemented_in&.relative!.to_s == method.owner.to_s
+          end
+
           method_definition.accessibility == accessibility
         end
 
@@ -50,8 +58,8 @@ module RBS
           type_name_absolute = type_name.absolute!
           @mixin_decls_cache ||= {} #: Hash[TypeName, Array[AST::Members::Mixin]]
           @mixin_decls_cache.fetch(type_name_absolute) do
-            @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].decls.flat_map do |d|
-              d.decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
+            @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].each_decl.flat_map do |decl|
+              decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
             end
           end
         end

data/lib/rbs/resolver/type_name_resolver.rb

@@ -13,14 +13,6 @@ module RBS
         @cache = {}
       end
 
-      def self.new(*args)
-        if args.size == 1 && args[0].is_a?(Environment)
-          build(args[0])
-        else
-          super
-        end
-      end
-
       def self.build(env)
         all_names = Set.new #: Set[TypeName]
 

data/lib/rbs/source.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RBS
+  module Source
+    class RBS
+      attr_reader :buffer, :directives, :declarations
+
+      def initialize(buffer, directives, decls)
+        @buffer = buffer
+        @directives = directives
+        @declarations = decls
+      end
+
+      def each_type_name(&block)
+        if block
+          set = Set[] #: Set[TypeName]
+          declarations.each do |decl|
+            each_declaration_type_name(set, decl, &block)
+          end
+        else
+          enum_for :each_type_name
+        end
+      end
+
+      def each_declaration_type_name(names, decl, &block)
+        case decl
+        when AST::Declarations::Class
+          decl.each_decl { each_declaration_type_name(names, _1, &block) }
+          type_name = decl.name
+        when AST::Declarations::Module
+          decl.each_decl { each_declaration_type_name(names, _1, &block) }
+          type_name = decl.name
+        when AST::Declarations::Interface
+          type_name = decl.name
+        when AST::Declarations::TypeAlias
+          type_name = decl.name
+        when AST::Declarations::ModuleAlias
+          type_name = decl.new_name
+        when AST::Declarations::ClassAlias
+          type_name = decl.new_name
+        end
+
+        if type_name
+          unless names.include?(type_name)
+            yield type_name
+            names << type_name
+          end
+        end
+      end
+    end
+
+    class Ruby
+      attr_reader :buffer
+      attr_reader :prism_result
+      attr_reader :declarations
+      attr_reader :diagnostics
+
+      def initialize(buffer, prism, declarations, diagnostics)
+        @buffer = buffer
+        @prism_result = prism
+        @declarations = declarations
+        @diagnostics = diagnostics
+      end
+
+      def each_type_name(&block)
+        if block
+          names = Set[] #: Set[TypeName]
+          declarations.each do |decl|
+            each_declaration_type_name(names, decl, &block)
+          end
+        else
+          enum_for :each_type_name
+        end
+      end
+
+      def each_declaration_type_name(names, decl, &block)
+        case decl
+        when AST::Ruby::Declarations::ClassDecl
+          decl.each_decl do |d|
+            each_declaration_type_name(names, d, &block)
+          end
+          type_name = decl.class_name
+        when AST::Ruby::Declarations::ModuleDecl
+          decl.each_decl do |d|
+            each_declaration_type_name(names, d, &block)
+          end
+          type_name = decl.module_name
+        end
+
+        if type_name
+          unless names.include?(type_name)
+            yield type_name
+            names << type_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/subtractor.rb

@@ -131,9 +131,10 @@ module RBS
 
       entry = @subtrahend.class_decls[owner]
       return unless entry
-      decls = entry.decls.map { |d| d.decl }
-
-      decls.each { |d| d.members.each { |m| block.call(m) } }
+      entry.each_decl do |d|
+        next unless d.is_a?(AST::Declarations::Base)
+        d.members.each { |m| block.call(m) }
+      end
     end
 
     private def mixin_exist?(owner, mixin, context:)

data/lib/rbs/test/type_check.rb

@@ -245,7 +245,7 @@ module RBS
         when Types::Bases::Any
           true
         when Types::Bases::Bool
-          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+          Test.call(val, IS_AP, TrueClass) || Test.call(val, IS_AP, FalseClass)
         when Types::Bases::Top
           true
         when Types::Bases::Bottom
@@ -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
@@ -336,7 +339,7 @@ module RBS
                             rescue TypeError
                               return false
                             end
-          val.is_a?(singleton_class)
+          Test.call(val, IS_AP, singleton_class)
         when Types::Interface
           if (definition = builder.build_interface(type.name.absolute!))
             definition.methods.each.all? do |method_name, method|

data/lib/rbs/type_name.rb

@@ -36,7 +36,7 @@ module RBS
       "#{namespace.to_s}#{name}"
     end
 
-    def to_json(state = _ = nil)
+    def to_json(state = nil)
       to_s.to_json(state)
     end
 
@@ -100,10 +100,3 @@ module RBS
     end
   end
 end
-
-module Kernel
-  def TypeName(string)
-    warn "Kernel#TypeName() is deprecated. Use RBS::TypeName.parse instead.", category: :deprecated
-    RBS::TypeName.parse(string)
-  end
-end