rbs 3.4.4 → 3.5.0.pre.1

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

data/lib/rbs/types.rb

@@ -515,22 +515,34 @@ module RBS
     end
 
     class Record
-      attr_reader :fields
+      attr_reader :all_fields, :fields, :optional_fields
       attr_reader :location
 
-      def initialize(fields:, location:)
-        @fields = fields
+      def initialize(all_fields: nil, fields: nil, location:)
+        case
+        when fields && all_fields.nil?
+          @all_fields = fields.map { |k, v| [k, [v, true]] }.to_h
+          @fields = fields
+          @optional_fields = {}
+        when all_fields && fields.nil?
+          @all_fields = all_fields
+          @fields = all_fields.filter_map { |k, (v, required)| [k, v] if required }.to_h
+          @optional_fields = all_fields.filter_map { |k, (v, required)| [k, v] unless required }.to_h
+        else
+          raise ArgumentError, "only one of `:fields` or `:all_fields` is requireds"
+        end
+
         @location = location
       end
 
       def ==(other)
-        other.is_a?(Record) && other.fields == fields
+        other.is_a?(Record) && other.fields == fields && other.optional_fields == optional_fields
       end
 
       alias eql? ==
 
       def hash
-        self.class.hash ^ fields.hash
+        self.class.hash ^ all_fields.hash
       end
 
       def free_variables(set = Set.new)
@@ -538,27 +550,35 @@ module RBS
           fields.each_value do |type|
             type.free_variables set
           end
+          optional_fields.each_value do |type|
+            type.free_variables set
+          end
         end
       end
 
       def to_json(state = _ = nil)
-        { class: :record, fields: fields, location: location }.to_json(state)
+        { class: :record, fields: fields, optional_fields: optional_fields, location: location }.to_json(state)
       end
 
       def sub(s)
-        self.class.new(fields: fields.transform_values {|ty| ty.sub(s) },
-                       location: location)
+        self.class.new(
+          all_fields: all_fields.transform_values {|ty, required| [ty.sub(s), required] },
+          location: location
+        )
       end
 
       def to_s(level = 0)
-        return "{ }" if self.fields.empty?
+        return "{ }" if all_fields.empty?
 
-        fields = self.fields.map do |key, type|
-          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_0-9]*\z/)
+        fields = all_fields.map do |key, (type, required)|
+          field = if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_0-9]*\z/)
             "#{key}: #{type}"
           else
             "#{key.inspect} => #{type}"
           end
+
+          field = "?#{field}" unless required
+          field
         end
         "{ #{fields.join(", ")} }"
       end
@@ -566,6 +586,7 @@ module RBS
       def each_type(&block)
         if block
           fields.each_value(&block)
+          optional_fields.each_value(&block)
         else
           enum_for :each_type
         end
@@ -573,7 +594,7 @@ module RBS
 
       def map_type_name(&block)
         Record.new(
-          fields: fields.transform_values {|ty| ty.map_type_name(&block) },
+          all_fields: all_fields.transform_values {|ty, required| [ty.map_type_name(&block), required] },
           location: location
         )
       end
@@ -581,7 +602,7 @@ module RBS
       def map_type(&block)
         if block
           Record.new(
-            fields: fields.transform_values {|type| yield type },
+            all_fields: all_fields.transform_values {|type, required| [yield(type), required] },
             location: location
           )
         else
@@ -1181,6 +1202,84 @@ module RBS
       end
     end
 
+    class UntypedFunction
+      attr_reader :return_type
+
+      def initialize(return_type:)
+        @return_type = return_type
+      end
+
+      def free_variables(acc = Set.new)
+        return_type.free_variables(acc)
+      end
+
+      def map_type(&block)
+        if block
+          update(return_type: yield(return_type))
+        else
+          enum_for :map_type
+        end
+      end
+
+      def each_type(&block)
+        if block
+          yield return_type
+        else
+          enum_for :each_type
+        end
+      end
+
+      def each_param(&block)
+        if block
+          # noop
+        else
+          enum_for :each_param
+        end
+      end
+
+      def to_json(state = _ = nil)
+        {
+          return_type: return_type
+        }.to_json(state)
+      end
+
+      def sub(subst)
+        map_type { _1.sub(subst) }
+      end
+
+      def with_return_type(ty)
+        update(return_type: ty)
+      end
+
+      def update(return_type: self.return_type)
+        UntypedFunction.new(return_type: return_type)
+      end
+
+      def empty?
+        true
+      end
+
+      def has_self_type?
+        return_type.has_self_type?
+      end
+
+      def has_classish_type?
+        return_type.has_classish_type?
+      end
+
+      def with_nonreturn_void
+        false
+      end
+
+      def param_to_s
+        "?"
+      end
+
+      def return_to_s
+        return_type.to_s(1)
+      end
+    end
+
     class Block
       attr_reader :type
       attr_reader :required

data/lib/rbs/unit_test/spy.rb

@@ -128,7 +128,7 @@ module RBS
                 end
               end.ruby2_keywords
             )
-          end.new()
+          end.allocate()
         end
       end
     end

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.4.4"
+  VERSION = "3.5.0.pre.1"
 end

data/rbs.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin|steep)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin|steep|benchmark)/}) }
   end
   spec.extensions = %w{ext/rbs_extension/extconf.rb}
 

data/sig/environment_loader.rbs

@@ -30,7 +30,7 @@ module RBS
       def initialize: (lib: Library) -> void
     end
 
-    class Library < Struct[String | String?]
+    class Library
       attr_reader name: String
       attr_reader version: String?
 

data/sig/errors.rbs

@@ -363,6 +363,6 @@ module RBS
 
     def initialize: (String message, location: Location[untyped, untyped]?) -> void
 
-    def location: () -> Location[untyped, untyped]?
+    attr_reader location: Location[untyped, untyped]?
   end
 end

data/sig/method_types.rbs

@@ -14,11 +14,11 @@ module RBS
     type loc = def_loc | attr_loc
 
     attr_reader type_params: Array[AST::TypeParam]
-    attr_reader type: Types::Function
+    attr_reader type: Types::function
     attr_reader block: Types::Block?
     attr_reader location: loc?
 
-    def initialize: (type_params: Array[AST::TypeParam], type: Types::Function, block: Types::Block?, location: loc?) -> void
+    def initialize: (type_params: Array[AST::TypeParam], type: Types::function, block: Types::Block?, location: loc?) -> void
 
     def ==: (untyped other) -> bool
 
@@ -29,7 +29,7 @@ module RBS
     #
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[AST::TypeParam], ?type: Types::Function, ?block: Types::Block?, ?location: loc?) -> MethodType
+    def update: (?type_params: Array[AST::TypeParam], ?type: Types::function, ?block: Types::Block?, ?location: loc?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]