rbs 3.4.4 → 3.5.1

data/lib/rbs/definition_builder.rb

@@ -630,12 +630,12 @@ module RBS
         end
 
         # @type var accessibility: RBS::Definition::accessibility
-        accessibility = if method.name == :initialize
-                          :private
-                        else
-                          method.accessibility
-                        end
-
+        accessibility =
+          if original.instance? && [:initialize, :initialize_copy, :initialize_clone, :initialize_dup, :respond_to_missing?].include?(method.name)
+            :private
+          else
+            method.accessibility
+          end
         # 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
@@ -669,7 +669,7 @@ module RBS
                 ]
               ),
               block: nil,
-              location: nil
+              location: original.location
             )
           else
             # getter
@@ -677,7 +677,7 @@ module RBS
               type_params: [],
               type: Types::Function.empty(attr_type),
               block: nil,
-              location: nil
+              location: original.location
             )
           end
 

data/lib/rbs/diff.rb

@@ -83,7 +83,7 @@ module RBS
         manifest_pathname = dir_pathname / 'manifest.yaml'
         if manifest_pathname.exist?
           manifest = YAML.safe_load(manifest_pathname.read)
-          if manifest['dependencies']
+          if manifest && manifest['dependencies']
             manifest['dependencies'].each do |dependency|
               loader.add(library: dependency['name'], version: nil)
             end

data/lib/rbs/environment_loader.rb

@@ -14,7 +14,8 @@ module RBS
 
     include FileFinder
 
-    Library = _ = Struct.new(:name, :version, keyword_init: true)
+    class Library < Struct.new(:name, :version, keyword_init: true)
+    end
 
     attr_reader :core_root
     attr_reader :repository

data/lib/rbs/errors.rb

@@ -62,20 +62,6 @@ module RBS
 
       super "#{Location.to_string location}: Syntax error: #{error_message}, token=`#{location.source}` (#{token_type})"
     end
-
-    def error_value
-      RBS.print_warning {
-        "#{self.class.name}#error_value is deprecated and will be deleted in RBS 2.0. Consider using `location.source` instead."
-      }
-      location.source
-    end
-
-    def token_str
-      RBS.print_warning {
-        "#{self.class.name}#token_str is deprecated and will be deleted in RBS 2.0. Consider using `token_type` instead."
-      }
-      token_type
-    end
   end
 
   class InvalidTypeApplicationError < DefinitionError

data/lib/rbs/location_aux.rb

@@ -5,7 +5,12 @@ module RBS
     def inspect
       rks = each_required_key.to_a
       ops = each_optional_key.to_a.map {|x| "?#{x}" }
-      "#<#{self.class}:#{self.__id__} buffer=#{buffer.name}, start=#{start_line}:#{start_column}, pos=#{start_pos}...#{end_pos}, children=#{(rks + ops).join(",")} source='#{source.lines.first&.chomp}'>"
+      src = if source.length <= 1
+        source.inspect
+      else
+        source.each_line.first&.chomp&.inspect
+      end
+      "#<#{self.class}:#{self.__id__} buffer=#{buffer.name}, start=#{start_line}:#{start_column}, pos=#{start_pos}...#{end_pos}, children=#{(rks + ops).join(",")} source=#{src}>"
     end
 
     def self.new(buffer_ = nil, start_pos_ = nil, end_pos_ = nil, buffer: nil, start_pos: nil, end_pos: nil)

data/lib/rbs/parser/lex_result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RBS
+  class Parser
+    class LexResult
+      attr_reader :buffer
+      attr_reader :value
+
+      def initialize(buffer:, value:)
+        @buffer = buffer
+        @value = value
+      end
+    end
+  end
+end

data/lib/rbs/parser/token.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RBS
+  class Parser
+    class Token
+      attr_reader :type
+      attr_reader :location
+
+      def initialize(type:, location:)
+        @type = type
+        @location = location
+      end
+
+      def value
+        @location.source
+      end
+
+      def comment?
+        @type == :tCOMMENT || @type == :tLINECOMMENT
+      end
+    end
+  end
+end

data/lib/rbs/parser_aux.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "parser/lex_result"
+require_relative "parser/token"
+
 module RBS
   class Parser
     def self.parse_type(source, range: 0..., variables: [], require_eof: false)
@@ -19,6 +22,15 @@ module RBS
       [buf, dirs, decls]
     end
 
+    def self.lex(source)
+      buf = buffer(source)
+      list = _lex(buf, buf.last_position)
+      value = list.map do |type, location|
+        Token.new(type: type, location: location)
+      end
+      LexResult.new(buffer: buf, value: value)
+    end
+
     def self.buffer(source)
       case source
       when String
@@ -28,11 +40,6 @@ module RBS
       end
     end
 
-    autoload :SyntaxError, "rbs/parser_compat/syntax_error"
-    autoload :SemanticsError, "rbs/parser_compat/semantics_error"
-    autoload :LexerError, "rbs/parser_compat/lexer_error"
-    autoload :LocatedValue, "rbs/parser_compat/located_value"
-
     KEYWORDS = %w(
       bool
       bot

data/lib/rbs/prototype/helpers.rb

@@ -37,13 +37,9 @@ module RBS
             end
           end
 
-          method_block = Types::Block.new(
-            required: required,
-            type: Types::Function.empty(untyped),
-            self_type: nil
-          )
-
           if yields
+            function = Types::Function.empty(untyped)
+
             yields.each do |yield_node|
               array_content = yield_node.children[0]&.children&.compact || []
 
@@ -54,9 +50,9 @@ module RBS
                                         [array_content, nil]
                                       end
 
-              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
+              if (diff = positionals.size - function.required_positionals.size) > 0
                 diff.times do
-                  method_block.type.required_positionals << Types::Function::Param.new(
+                  function.required_positionals << Types::Function::Param.new(
                     type: untyped,
                     name: nil
                   )
@@ -67,7 +63,7 @@ module RBS
                 keywords.children[0].children.each_slice(2) do |key_node, value_node|
                   if key_node
                     key = key_node.children[0]
-                    method_block.type.required_keywords[key] ||=
+                    function.required_keywords[key] ||=
                       Types::Function::Param.new(
                         type: untyped,
                         name: nil
@@ -76,10 +72,13 @@ module RBS
                 end
               end
             end
+          else
+            function = Types::UntypedFunction.new(return_type: untyped)
           end
-        end
 
-        method_block
+
+          Types::Block.new(required: required, type: function, self_type: nil)
+        end
       end
 
       def each_child(node, &block)
@@ -109,7 +108,7 @@ module RBS
       def keyword_hash?(node)
         if node && node.type == :HASH
           node.children[0].children.compact.each_slice(2).all? {|key, _|
-            key.type == :LIT && key.children[0].is_a?(Symbol)
+            symbol_literal_node?(key)
           }
         else
           false
@@ -122,6 +121,17 @@ module RBS
         args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
       end
 
+      def symbol_literal_node?(node)
+        case node.type
+        when :LIT
+          if node.children[0].is_a?(Symbol)
+            node.children[0]
+          end
+        when :SYM
+          node.children[0]
+        end
+      end
+
       def untyped
         @untyped ||= Types::Bases::Any.new(location: nil)
       end

data/lib/rbs/prototype/rb.rb

@@ -5,7 +5,7 @@ module RBS
     class RB
       include Helpers
 
-      Context = _ = Struct.new(:module_function, :singleton, :namespace, :in_def, keyword_init: true) do
+      class Context < Struct.new(:module_function, :singleton, :namespace, :in_def, keyword_init: true)
         # @implements Context
 
         def self.initial(namespace: Namespace.root)
@@ -461,6 +461,8 @@ module RBS
 
       def literal_to_symbol(node)
         case node.type
+        when :SYM
+          node.children[0]
         when :LIT
           node.children[0] if node.children[0].is_a?(Symbol)
         when :STR
@@ -495,7 +497,7 @@ module RBS
         end
 
         if rest
-          rest_name = rest == :* ? nil : rest # # For `def f(...) end` syntax
+          rest_name = rest == :* ? nil : rest # `def f(...)` syntax has `*` name
           fun = fun.update(rest_positionals: Types::Function::Param.new(name: rest_name, type: untyped))
         end
 
@@ -518,7 +520,9 @@ module RBS
         end
 
         if kwrest && kwrest.children.any?
-          fun = fun.update(rest_keywords: Types::Function::Param.new(name: kwrest.children[0], type: untyped))
+          kwrest_name = kwrest.children[0] #: Symbol?
+          kwrest_name = nil if kwrest_name == :** # `def f(...)` syntax has `**` name
+          fun = fun.update(rest_keywords: Types::Function::Param.new(name: kwrest_name, type: untyped))
         end
 
         fun
@@ -574,9 +578,16 @@ module RBS
           end
         when :DSTR, :XSTR
           BuiltinNames::String.instance_type
+        when :SYM
+          lit = node.children[0]
+          if lit.to_s.ascii_only?
+            Types::Literal.new(literal: lit, location: nil)
+          else
+            BuiltinNames::Symbol.instance_type
+          end
         when :DSYM
           BuiltinNames::Symbol.instance_type
-        when :DREGX
+        when :DREGX, :REGX
           BuiltinNames::Regexp.instance_type
         when :TRUE
           Types::Literal.new(literal: true, location: nil)
@@ -584,6 +595,14 @@ module RBS
           Types::Literal.new(literal: false, location: nil)
         when :NIL
           Types::Bases::Nil.new(location: nil)
+        when :INTEGER
+          Types::Literal.new(literal: node.children[0], location: nil)
+        when :FLOAT
+          BuiltinNames::Float.instance_type
+        when :RATIONAL, :IMAGINARY
+          lit = node.children[0]
+          type_name = TypeName.new(name: lit.class.name.to_sym, namespace: Namespace.root)
+          Types::ClassInstance.new(name: type_name, args: [], location: nil)
         when :LIT
           lit = node.children[0]
           case lit
@@ -595,6 +614,11 @@ module RBS
             end
           when Integer
             Types::Literal.new(literal: lit, location: nil)
+          when String
+            # For Ruby <=3.3 which generates `LIT` node for string literals inside Hash literal.
+            # "a"             => STR node
+            # { "a" => nil }  => LIT node
+            Types::Literal.new(literal: lit, location: nil)
           else
             type_name = TypeName.new(name: lit.class.name.to_sym, namespace: Namespace.root)
             Types::ClassInstance.new(name: type_name, args: [], location: nil)
@@ -686,6 +710,14 @@ module RBS
 
       def param_type(node, default: Types::Bases::Any.new(location: nil))
         case node.type
+        when :INTEGER
+          BuiltinNames::Integer.instance_type
+        when :FLOAT
+          BuiltinNames::Float.instance_type
+        when :RATIONAL
+          Types::ClassInstance.new(name: TypeName("::Rational"), args: [], location: nil)
+        when :IMAGINARY
+          Types::ClassInstance.new(name: TypeName("::Complex"), args: [], location: nil)
         when :LIT
           case node.children[0]
           when Symbol
@@ -697,6 +729,8 @@ module RBS
           else
             default
           end
+        when :SYM
+          BuiltinNames::Symbol.instance_type
         when :STR, :DSTR
           BuiltinNames::String.instance_type
         when :NIL

data/lib/rbs/prototype/rbi.rb

@@ -3,6 +3,8 @@
 module RBS
   module Prototype
     class RBI
+      include Helpers
+
       attr_reader :decls
       attr_reader :modules
       attr_reader :last_sig
@@ -218,11 +220,11 @@ module RBS
           if (send = node.children.last) && send.type == :FCALL && send.children[0] == :type_member
             unless each_arg(send.children[1]).any? {|node|
               node.type == :HASH &&
-                each_arg(node.children[0]).each_slice(2).any? {|a, _| a.type == :LIT && a.children[0] == :fixed }
+                each_arg(node.children[0]).each_slice(2).any? {|a, _| symbol_literal_node?(a) == :fixed }
             }
               # @type var variance: AST::TypeParam::variance?
-              if (a0 = each_arg(send.children[1]).to_a[0]) && a0.type == :LIT
-                variance = case a0.children[0]
+              if (a0 = each_arg(send.children[1]).to_a[0]) && (v = symbol_literal_node?(a0))
+                variance = case v
                            when :out
                              :covariant
                            when :in
@@ -315,14 +317,18 @@ module RBS
                 Types::Function::Param.new(name: name, type: type)
               end
 
-              method_type.update(type: method_type.type.update(required_positionals: required_positionals))
+              if method_type.type.is_a?(RBS::Types::Function)
+                method_type.update(type: method_type.type.update(required_positionals: required_positionals))
+              else
+                method_type
+              end
             end
           when :type_parameters
             type_params = []
 
             each_arg args do |node|
-              if node.type == :LIT
-                type_params << node.children[0]
+              if name = symbol_literal_node?(node)
+                type_params << name
               end
             end
 
@@ -444,18 +450,22 @@ module RBS
           end
         end
 
-        method_type.update(
-          type: method_type.type.update(
-            required_positionals: required_positionals,
-            optional_positionals: optional_positionals,
-            rest_positionals: rest_positionals,
-            trailing_positionals: trailing_positionals,
-            required_keywords: required_keywords,
-            optional_keywords: optional_keywords,
-            rest_keywords: rest_keywords
-          ),
-          block: method_block
-        )
+        if method_type.type.is_a?(Types::Function)
+          method_type.update(
+            type: method_type.type.update(
+              required_positionals: required_positionals,
+              optional_positionals: optional_positionals,
+              rest_positionals: rest_positionals,
+              trailing_positionals: trailing_positionals,
+              required_keywords: required_keywords,
+              optional_keywords: optional_keywords,
+              rest_keywords: rest_keywords
+            ),
+            block: method_block
+          )
+        else
+          method_type
+        end
       end
 
       def type_of(type_node, variables:)
@@ -613,8 +623,8 @@ module RBS
           each_arg(node.children[0]).each_slice(2) do |var, type|
             var or raise
 
-            if var.type == :LIT && type
-              hash[var.children[0]] = type
+            if (name = symbol_literal_node?(var)) && type
+              hash[name] = type
             end
           end
 

data/lib/rbs/test/errors.rb

@@ -40,32 +40,37 @@ module RBS
         end
       end
 
-      def self.to_string(error)
-        name = if error.klass.singleton_class?
-          inspect_(error.klass).sub(/\A#<Class:(.*)>\z/, '\1')
+      def self.method_tag(error)
+        if error.klass.singleton_class?
+          name = inspect_(error.klass).sub(/\A#<Class:(.*)>\z/, '\1')
+          method_name = ".#{error.method_name}"
         else
-          error.klass.name
+          name = error.klass.name
+          method_name = "##{error.method_name}"
         end
-        method = "#{name}#{error.method_name}"
+        "[#{name}#{method_name}]"
+      end
+
+      def self.to_string(error)
         case error
         when ArgumentTypeError
-          "[#{method}] ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+          "#{method_tag(error)} ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
         when BlockArgumentTypeError
-          "[#{method}] BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+          "#{method_tag(error)} BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
         when ArgumentError
-          "[#{method}] ArgumentError: expected method type #{error.method_type}"
+          "#{method_tag(error)} ArgumentError: expected method type #{error.method_type}"
         when BlockArgumentError
-          "[#{method}] BlockArgumentError: expected method type #{error.method_type}"
+          "#{method_tag(error)} BlockArgumentError: expected method type #{error.method_type}"
         when ReturnTypeError
-          "[#{method}] ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+          "#{method_tag(error)} ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
         when BlockReturnTypeError
-          "[#{method}] BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+          "#{method_tag(error)} BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
         when UnexpectedBlockError
-          "[#{method}] UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
+          "#{method_tag(error)} UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
         when MissingBlockError
-          "[#{method}] MissingBlockError: required block is missing for `#{error.method_type}`"
+          "#{method_tag(error)} MissingBlockError: required block is missing for `#{error.method_type}`"
         when UnresolvedOverloadingError
-          "[#{method}] UnresolvedOverloadingError: couldn't find a suitable overloading"
+          "#{method_tag(error)} UnresolvedOverloadingError: couldn't find a suitable overloading"
         else
           raise "Unexpected error: #{inspect_(error)}"
         end

data/lib/rbs/test/tester.rb

@@ -149,7 +149,7 @@ module RBS
           method = definition.methods[method_name]
           if method
             RBS.logger.debug { "Type checking `#{self_class}#{format_method_name(method_name)}`..."}
-            errors = check.overloaded_call(method, format_method_name(method_name), trace, errors: [])
+            errors = check.overloaded_call(method, method_name, trace, errors: [])
 
             if errors.empty?
               RBS.logger.debug { "No type error detected 👏" }

data/lib/rbs/test/type_check.rb

@@ -35,22 +35,24 @@ module RBS
         if es.size == 1
           errors.push(*es[0])
         else
+          error = Errors::UnresolvedOverloadingError.new(
+            klass: self_class,
+            method_name: method_name,
+            method_types: method.method_types
+          )
           RBS.logger.warn do
-            message = +"[#{self_class}#{method_name}] UnresolvedOverloadingError "
+            tag = Errors.method_tag(error)
+            message = +"#{tag} UnresolvedOverloadingError "
             message << method.method_types.zip(es).map do |method_type, es|
               msg = +"method_type=`#{method_type}`"
               details = es.map do |e|
-                "\"#{Errors.to_string(e).sub("[#{e.klass.name}#{e.method_name}] ", "") }\""
+                "\"#{Errors.to_string(e).sub("#{tag} ", "") }\""
               end.join(', ')
               msg << " details=[#{details}]"
             end.join(', ')
             message
           end
-          errors << Errors::UnresolvedOverloadingError.new(
-            klass: self_class,
-            method_name: method_name,
-            method_types: method.method_types
-          )
+          errors << error
         end
 
         errors
@@ -281,19 +283,22 @@ module RBS
                 end
               end
 
-              each_sample(values).all? do |v|
+              value_check = values.empty? || each_sample(values).all? do |v|
                 if v.size == 1
                   # Only one block argument.
                   value(v[0], type.args[0]) || value(v, type.args[0])
                 else
                   value(v, type.args[0])
                 end
-              end &&
-                if ret.equal?(self)
-                  type.args[1].is_a?(Types::Bases::Bottom)
-                else
-                  value(ret, type.args[1])
-                end
+              end
+
+              return_check = if ret.equal?(self)
+                type.args[1].is_a?(Types::Bases::Bottom)
+              else
+                value(ret, type.args[1])
+              end
+
+              value_check && return_check
             end
           else
             Test.call(val, IS_AP, klass)
@@ -308,8 +313,15 @@ module RBS
           val.is_a?(singleton_class)
         when Types::Interface
           if (definition = builder.build_interface(type.name.absolute!))
-            definition.methods.each_key.all? do |method_name|
-              Test.call(val, RESPOND_TOP, method_name)
+            definition.methods.each.all? do |method_name, method|
+              next false unless Test.call(val, RESPOND_TOP, method_name)
+
+              meth = Test.call(val, METHOD, method_name)
+              method.defs.all? do |type_def|
+                type_def.member.overloads.all? do |overload|
+                  callable_argument?(meth.parameters, overload.method_type)
+                end
+              end
             end
           end
         when Types::Variable
@@ -336,6 +348,73 @@ module RBS
           false
         end
       end
+
+      private
+
+      def callable_argument?(parameters, method_type)
+        fun = method_type.type
+        take_has_rest = !!parameters.find { |(op, _)| op == :rest }
+
+        fun.required_positionals.each do
+          op, _ = parameters.first
+          return false if op.nil? || op == :keyreq || op == :key || op == :keyrest
+          parameters.shift if op == :req || op == :opt
+        end
+
+        fun.optional_positionals.each do
+          op, _ = parameters.first
+          return false if op.nil? || op == :req || op == :keyreq || op == :key || op == :keyrest
+          parameters.shift if op == :opt
+        end
+
+        if fun.rest_positionals
+          op, _ = parameters.shift
+          return false if op.nil? || op != :rest
+        end
+
+        fun.trailing_positionals.each do
+          op, _ = parameters.first
+          return false if !take_has_rest && (op.nil? || op == :keyreq || op == :key || op == :keyrest)
+          index = parameters.find_index { |(op, _)| op == :req }
+          parameters.delete_at(index) if index
+        end
+
+        if fun.has_keyword?
+          return false if !take_has_rest && parameters.empty?
+
+          fun.required_keywords.each do |name, _|
+            return false if !take_has_rest && parameters.empty?
+            index = parameters.find_index { |(op, n)| (op == :keyreq || op == :key) && n == name }
+            parameters.delete_at(index) if index
+          end
+
+          if !fun.optional_keywords.empty?
+            fun.optional_keywords.each do |name, _|
+              return false if !take_has_rest && parameters.empty?
+              index = parameters.find_index { |(op, n)| op == :key && n == name }
+              parameters.delete_at(index) if index
+            end
+            op, _ = parameters.first
+            return false if op == :req
+          end
+
+          if fun.rest_keywords
+            op, _ = parameters.first
+            return false if (!take_has_rest && op.nil?)
+            # f(a) allows (Integer, a: Integer)
+            return false if op == :req && fun.required_keywords.empty?
+          end
+
+          op, _ = parameters.first
+          return true if (op == :req || op == :opt) && parameters.length == 1
+        end
+
+        # rest required arguments
+        op, _ = parameters.first
+        return false if op == :req || op == :keyreq
+
+        true
+      end
     end
   end
 end