rbs 3.4.4 → 3.5.1

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.1"
 end

data/rbs.gemspec

@@ -28,7 +28,12 @@ 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 do |f|
+      [
+        %r{^(test|spec|features|bin|steep|benchmark)/},
+        /Gemfile/
+      ].any? {|r| f.match(r) }
+    end
   end
   spec.extensions = %w{ext/rbs_extension/extconf.rb}
 
@@ -36,5 +41,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.required_ruby_version = ">= 3.0"
-  spec.add_dependency "abbrev"
+  spec.add_dependency "logger"
 end

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/manifest.yaml

@@ -5,4 +5,3 @@ dependencies:
   - name: optparse
   - name: tsort
   - name: rdoc
-  - name: abbrev

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]
 

data/sig/parser.rbs

@@ -1,5 +1,23 @@
 module RBS
   class Parser
+    # Result of `Parser.lex`
+    class LexResult
+      attr_reader buffer: Buffer
+      attr_reader value: Array[Token]
+
+      def initialize: (buffer: Buffer, value: Array[Token]) -> void
+    end
+
+    # Represents a token per result of `Parser.lex`.
+    class Token
+      attr_reader type: Symbol
+      attr_reader location: Location[untyped, untyped]
+
+      def initialize: (type: Symbol, location: Location[untyped, untyped]) -> void
+      def value: () -> String
+      def comment?: () -> bool
+    end
+
     # Parse a method type and return it
     #
     # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
@@ -50,6 +68,14 @@ module RBS
     #
     def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
 
+    # Parse whole RBS file and return result.
+    #
+    # ```ruby
+    # RBS::Parser.lex("# Comment\nmodule A\nend\n").value.map(&:type)
+    # # => [:tLINECOMMENT, :kMODULE, :tUIDENT, :kEND, :pEOF]
+    # ```
+    def self.lex: (Buffer | String) -> LexResult
+
     KEYWORDS: Hash[String, bot]
 
     private
@@ -62,6 +88,8 @@ module RBS
 
     def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
+    def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
+
     class LocatedValue
     end
   end

data/sig/prototype/helpers.rbs

@@ -13,6 +13,10 @@ module RBS
 
       def keyword_hash?: (node) -> bool
 
+      # Returns a symbol if the node is a symbol literal node
+      # 
+      def symbol_literal_node?: (node) -> Symbol?
+
       def args_from_node: (node?) -> Array[untyped]
 
       def untyped: () -> Types::Bases::Any

data/sig/prototype/rbi.rbs

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class RBI
+      include Helpers
+      
       attr_reader decls: Array[AST::Declarations::t]
 
       type module_decl = AST::Declarations::Class | AST::Declarations::Module

data/sig/types.rbs

@@ -301,11 +301,16 @@ module RBS
     end
 
     class Record
+      attr_reader all_fields: Hash[Symbol, [t, bool]]
+
       attr_reader fields: Hash[Symbol, t]
 
+      attr_reader optional_fields: Hash[Symbol, t]
+
       type loc = Location[bot, bot]
 
       def initialize: (fields: Hash[Symbol, t], location: loc?) -> void
+                    | (all_fields: Hash[Symbol, [t, bool]], location: loc?) -> void
 
       include _TypeBase
 
@@ -443,13 +448,58 @@ module RBS
       def with_nonreturn_void?: () -> bool
     end
 
+    # Function type without type checking arguments
+    #
+    class UntypedFunction
+      attr_reader return_type: t
+
+      def initialize: (return_type: t) -> void
+
+      def free_variables: (?Set[Symbol]) -> Set[Symbol]
+
+      def map_type: { (t) -> t } -> UntypedFunction
+                  | -> Enumerator[t, UntypedFunction]
+
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> UntypedFunction
+
+      def each_type: () { (t) -> void } -> void
+                   | -> Enumerator[t, void]
+
+      def each_param: () { (Function::Param) -> void } -> void
+                    | -> Enumerator[Function::Param, void]
+
+      include _ToJson
+
+      def sub: (Substitution) -> UntypedFunction
+
+      def with_return_type: (t) -> UntypedFunction
+
+      def update: (?return_type: t) -> UntypedFunction
+
+      def empty?: () -> bool
+
+      def has_self_type?: () -> bool
+
+      def has_classish_type?: () -> bool
+
+      def with_nonreturn_void?: () -> bool
+
+      # Returns `?`
+      def param_to_s: () -> String
+
+      # Returns `return_type.to_s(1)`
+      def return_to_s: () -> String
+    end
+
+    type function = Types::Function | Types::UntypedFunction
+
     class Block
-      attr_reader type: Types::Function
+      attr_reader type: function
       attr_reader required: bool
 
       attr_reader self_type: t?
 
-      def initialize: (type: Types::Function, ?self_type: t?, required: boolish) -> void
+      def initialize: (type: function, ?self_type: t?, required: boolish) -> void
 
       def ==: (untyped other) -> bool
 
@@ -465,14 +515,14 @@ module RBS
     end
 
     class Proc
-      attr_reader type: Function
+      attr_reader type: function
       attr_reader block: Block?
 
       attr_reader self_type: t?
 
       type loc = Location[bot, bot]
 
-      def initialize: (location: loc?, type: Function, ?self_type: t?, block: Block?) -> void
+      def initialize: (location: loc?, type: function, ?self_type: t?, block: Block?) -> void
 
       include _TypeBase
 

data/sig/variance_calculator.rbs

@@ -73,14 +73,14 @@ module RBS
     def in_inherit: (name: TypeName, args: Array[Types::t], variables: Array[Symbol]) -> Result
 
     # The type name must be normalized
-    # 
+    #
     def in_type_alias: (name: TypeName) -> Result
 
     private
 
     def type: (Types::t, result: Result, context: variance) -> void
 
-    def function: (Types::Function, result: Result, context: variance) -> void
+    def function: (Types::function, result: Result, context: variance) -> void
 
     def negate: (variance) -> variance
   end

data/stdlib/csv/0/csv.rbs

@@ -1722,7 +1722,10 @@ class CSV < Object
   #     would read `UTF-32BE` data from the file but transcode it to `UTF-8`
   #     before parsing.
   #
-  def self.foreach: [U] (String | IO | StringIO path, ?::Hash[Symbol, U] options) { (::Array[String?] arg0) -> void } -> void
+  def self.foreach: (String | IO path, ?String mode, headers: true, **untyped options) { (::CSV::Row arg0) -> void } -> void
+                  | (String | IO path, ?String mode, headers: true, **untyped options) -> Enumerator[::CSV::Row, void]
+                  | (String | IO path, ?String mode, **untyped options) { (::Array[String?] arg0) -> void } -> void
+                  | (String | IO path, ?String mode, **untyped options) -> Enumerator[::Array[String?], void]
 
   # <!--
   #   rdoc-file=lib/csv.rb

data/stdlib/fileutils/0/fileutils.rbs

@@ -1771,5 +1771,5 @@ module FileUtils
   #
   # Related: FileUtils.touch.
   #
-  def self?.uptodate?: (path new, pathlist old_list) -> bool
+  def self?.uptodate?: (path new, _Each[path] old_list) -> bool
 end