rbs 1.7.0.beta.2 → 1.7.0

data/lib/rbs/prototype/helpers.rb

@@ -0,0 +1,113 @@
+module RBS
+  module Prototype
+    module Helpers
+      private
+
+      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 = args_from_node(args_node)
+
+        method_block = nil
+
+        if block
+          method_block = Types::Block.new(
+            # HACK: The `block` is :& on `def m(...)` syntax.
+            #       In this case the block looks optional in most cases, so it marks optional.
+            #       In other cases, we can't determine which is required or optional, so it marks required.
+            required: block != :&,
+            type: Types::Function.empty(untyped)
+          )
+        end
+
+        if body_node
+          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
+            method_block = Types::Block.new(
+              required: true,
+              type: Types::Function.empty(untyped)
+            )
+
+            yields.each do |yield_node|
+              array_content = yield_node.children[0]&.children&.compact || []
+
+              positionals, keywords = if keyword_hash?(array_content.last)
+                                        [array_content.take(array_content.size - 1), array_content.last]
+                                      else
+                                        [array_content, nil]
+                                      end
+
+              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
+                diff.times do
+                  method_block.type.required_positionals << Types::Function::Param.new(
+                    type: untyped,
+                    name: nil
+                  )
+                end
+              end
+
+              if keywords
+                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] ||=
+                      Types::Function::Param.new(
+                        type: untyped,
+                        name: nil
+                      )
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        method_block
+      end
+
+      def each_child(node, &block)
+        each_node node.children, &block
+      end
+
+      def each_node(nodes)
+        nodes.each do |child|
+          if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+            yield child
+          end
+        end
+      end
+
+
+      def any_node?(node, nodes: [], &block)
+        if yield(node)
+          nodes << node
+        end
+
+        each_child node do |child|
+          any_node? child, nodes: nodes, &block
+        end
+
+        nodes.empty? ? nil : nodes
+      end
+
+      def keyword_hash?(node)
+        if node
+          if node.type == :HASH
+            node.children[0].children.compact.each_slice(2).all? {|key, _|
+              key.type == :LIT && key.children[0].is_a?(Symbol)
+            }
+          end
+        end
+      end
+
+      # NOTE: args_node may be a nil by a bug
+      #       https://bugs.ruby-lang.org/issues/17495
+      def args_from_node(args_node)
+        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
+      end
+
+      def untyped
+        @untyped ||= Types::Bases::Any.new(location: nil)
+      end
+    end
+  end
+end

data/lib/rbs/prototype/rb.rb

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class RB
+      include Helpers
+
       Context = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
         def self.initial(namespace: Namespace.root)
           self.new(module_function: false, singleton: false, namespace: namespace)
@@ -372,18 +374,6 @@ module RBS
         end
       end
 
-      def each_node(nodes)
-        nodes.each do |child|
-          if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
-            yield child
-          end
-        end
-      end
-
-      def each_child(node, &block)
-        each_node node.children, &block
-      end
-
       def function_type_from_body(node, def_name)
         table_node, args_node, *_ = node.children
 
@@ -568,95 +558,6 @@ module RBS
         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 = args_from_node(args_node)
-
-        method_block = nil
-
-        if block
-          method_block = Types::Block.new(
-            # HACK: The `block` is :& on `def m(...)` syntax.
-            #       In this case the block looks optional in most cases, so it marks optional.
-            #       In other cases, we can't determine which is required or optional, so it marks required.
-            required: block != :&,
-            type: Types::Function.empty(untyped)
-          )
-        end
-
-        if body_node
-          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
-            method_block = Types::Block.new(
-              required: true,
-              type: Types::Function.empty(untyped)
-            )
-
-            yields.each do |yield_node|
-              array_content = yield_node.children[0]&.children&.compact || []
-
-              positionals, keywords = if keyword_hash?(array_content.last)
-                                        [array_content.take(array_content.size - 1), array_content.last]
-                                      else
-                                        [array_content, nil]
-                                      end
-
-              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
-                diff.times do
-                  method_block.type.required_positionals << Types::Function::Param.new(
-                    type: untyped,
-                    name: nil
-                  )
-                end
-              end
-
-              if keywords
-                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] ||=
-                      Types::Function::Param.new(
-                        type: untyped,
-                        name: nil
-                      )
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        method_block
-      end
-
-      # NOTE: args_node may be a nil by a bug
-      #       https://bugs.ruby-lang.org/issues/17495
-      def args_from_node(args_node)
-        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
-      end
-
-      def keyword_hash?(node)
-        if node
-          if node.type == :HASH
-            node.children[0].children.compact.each_slice(2).all? {|key, _|
-              key.type == :LIT && key.children[0].is_a?(Symbol)
-            }
-          end
-        end
-      end
-
-      def any_node?(node, nodes: [], &block)
-        if yield(node)
-          nodes << node
-        end
-
-        each_child node do |child|
-          any_node? child, nodes: nodes, &block
-        end
-
-        nodes.empty? ? nil : nodes
-      end
-
       def node_type(node, default: Types::Bases::Any.new(location: nil))
         case node.type
         when :LIT
@@ -689,10 +590,6 @@ module RBS
         end
       end
 
-      def untyped
-        @untyped ||= Types::Bases::Any.new(location: nil)
-      end
-
       def private
         @private ||= AST::Members::Private.new(location: nil)
       end

data/lib/rbs/prototype/runtime.rb

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class Runtime
+      include Helpers
+
       attr_reader :patterns
       attr_reader :env
       attr_reader :merge
@@ -138,6 +140,8 @@ module RBS
           end
         end
 
+        block ||= block_from_ast_of(method)
+
         return_type = if method.name == :initialize
                         Types::Bases::Void.new(location: nil)
                       else
@@ -522,6 +526,18 @@ module RBS
           []
         end
       end
+
+      def block_from_ast_of(method)
+        return nil if RUBY_VERSION < '3.1'
+
+        begin
+          ast = RubyVM::AbstractSyntaxTree.of(method)
+        rescue ArgumentError
+          return # When the method is defined in eval
+        end
+
+        block_from_body(ast) if ast&.type == :SCOPE
+      end
     end
   end
 end

data/lib/rbs/test/setup.rb

@@ -13,6 +13,7 @@ begin
   filter = ENV.fetch('RBS_TEST_TARGET', "").split(',').map! { |e| e.strip }
   skips = (ENV['RBS_TEST_SKIP'] || '').split(',').map! { |e| e.strip }
   RBS.logger_level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
+  logger.level = RBS.logger_level
   sample_size = get_sample_size(ENV['RBS_TEST_SAMPLE_SIZE'] || '')
   double_class = to_double_class(ENV['RBS_TEST_DOUBLE_SUITE'])
   unchecked_classes = (ENV['RBS_TEST_UNCHECKED_CLASSES'] || '').split(',').map! { |unchecked_class| unchecked_class.strip }.push(*double_class)

data/lib/rbs/types.rb

@@ -433,7 +433,7 @@ module RBS
         return "{ }" if self.fields.empty?
 
         fields = self.fields.map do |key, type|
-          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) && !Parser::KEYWORDS.key?(key)
+          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) && !Parser::KEYWORDS.include?(key)
             "#{key}: #{type}"
           else
             "#{key.inspect} => #{type}"
@@ -690,7 +690,7 @@ module RBS
 
         def to_s
           if name
-            if Parser::KEYWORDS.key?(name)
+            if Parser::KEYWORDS.include?(name)
               "#{type} `#{name}`"
             else
               "#{type} #{name}"

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.7.0.beta.2"
+  VERSION = "1.7.0"
 end

data/lib/rbs.rb

@@ -32,6 +32,7 @@ require "rbs/constant"
 require "rbs/constant_table"
 require "rbs/ast/comment"
 require "rbs/writer"
+require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
 require "rbs/prototype/runtime"
@@ -68,5 +69,16 @@ module RBS
       @logger_level = level
       @logger = nil
     end
+
+    def print_warning()
+      @warnings ||= Set[]
+
+      message = yield()
+
+      unless @warnings.include?(message)
+        @warnings << message
+        logger.warn { message }
+      end
+    end
   end
 end

data/sig/parser.rbs

@@ -6,6 +6,8 @@ module RBS
 
     def self.parse_signature: (Buffer | String, ?line: Integer, ?column: Integer) -> Array[AST::Declarations::t]
 
+    KEYWORDS: Hash[String, bot]
+
     private
 
     def self.buffer: (String | Buffer source) -> Buffer

data/sig/rbs.rbs

@@ -8,6 +8,10 @@ module RBS
   def self.logger_output: () -> IO
 
   def self.logger_output=: (IO) -> IO
+
+  def self.print_warning: () { () -> String } -> void
+
+  self.@warnings: Set[String]
 end
 
 module Ruby

data/stdlib/bigdecimal/0/big_decimal.rbs

@@ -885,3 +885,47 @@ BigDecimal::SIGN_POSITIVE_ZERO: Integer
 # The version of bigdecimal library
 #
 BigDecimal::VERSION: String
+
+module Kernel
+  private
+
+  # Create a new BigDecimal object.
+  #
+  # initial
+  # :   The initial value, as an Integer, a Float, a Rational, a BigDecimal, or a
+  #     String.
+  #
+  #     If it is a String, spaces are ignored and unrecognized characters
+  #     terminate the value.
+  #
+  # digits
+  # :   The number of significant digits, as an Integer. If omitted or 0, the
+  #     number of significant digits is determined from the initial value.
+  #
+  #     The actual number of significant digits used in computation is usually
+  #     larger than the specified number.
+  #
+  # exception
+  # :   Whether an exception should be raised on invalid arguments. `true` by
+  #     default, if passed `false`, just returns `nil` for invalid.
+  #
+  #
+  # #### Exceptions
+  #
+  # TypeError
+  # :   If the `initial` type is neither Integer, Float, Rational, nor BigDecimal,
+  #     this exception is raised.
+  #
+  # TypeError
+  # :   If the `digits` is not an Integer, this exception is raised.
+  #
+  # ArgumentError
+  # :   If `initial` is a Float, and the `digits` is larger than Float::DIG + 1,
+  #     this exception is raised.
+  #
+  # ArgumentError
+  # :   If the `initial` is a Float or Rational, and the `digits` value is
+  #     omitted, this exception is raised.
+  #
+  def self?.BigDecimal: ((real | string | BigDecimal) initial, ?int digits, ?exception: bool) -> BigDecimal
+end

data/stdlib/csv/0/csv.rbs

@@ -360,6 +360,49 @@ class CSV < Object
   # output non-ASCII compatible data.
   #
   def self.generate: (?String str, **untyped options) { (CSV csv) -> void } -> String
+
+  # :call-seq:
+  #   csv.each -> enumerator
+  #   csv.each {|row| ...}
+  #
+  # Calls the block with each successive row.
+  # The data source must be opened for reading.
+  #
+  # Without headers:
+  #   string = "foo,0\nbar,1\nbaz,2\n"
+  #   csv = CSV.new(string)
+  #   csv.each do |row|
+  #     p row
+  #   end
+  # Output:
+  #   ["foo", "0"]
+  #   ["bar", "1"]
+  #   ["baz", "2"]
+  #
+  # With headers:
+  #   string = "Name,Value\nfoo,0\nbar,1\nbaz,2\n"
+  #   csv = CSV.new(string, headers: true)
+  #   csv.each do |row|
+  #     p row
+  #   end
+  # Output:
+  #   <CSV::Row "Name":"foo" "Value":"0">
+  #   <CSV::Row "Name":"bar" "Value":"1">
+  #   <CSV::Row "Name":"baz" "Value":"2">
+  #
+  # ---
+  #
+  # Raises an exception if the source is not opened for reading:
+  #   string = "foo,0\nbar,1\nbaz,2\n"
+  #   csv = CSV.new(string)
+  #   csv.close
+  #   # Raises IOError (not opened for reading)
+  #   csv.each do |row|
+  #     p row
+  #   end
+  def each: () -> Enumerator[untyped, Integer]
+          | () { (untyped) -> void } -> Integer
+
 end
 
 # The options used when no overrides are given by calling code. They are:
@@ -408,7 +451,7 @@ CSV::VERSION: String
 # processing is activated.
 #
 class CSV::Row < Object
-  include Enumerable[untyped]
+  include Enumerable[Array[String]]
   extend Forwardable
 
   # If a two-element Array is provided, it is assumed to be a header and field and
@@ -464,7 +507,8 @@ class CSV::Row < Object
   #
   # Support for Enumerable.
   #
-  def each: () { (*untyped) -> untyped } -> untyped
+  def each: () -> Enumerator[Array[String], self]
+          | () { (Array[String]) -> void } -> self
 
   alias each_pair each
 
@@ -717,7 +761,9 @@ class CSV::Table[out Elem] < Object
   #
   # If no block is given, an Enumerator is returned.
   #
-  def each: () { (*untyped) -> untyped } -> untyped
+  def each: () -> Enumerator[untyped, self]
+          | () { (untyped) -> void } -> self
+          | () { (*untyped) -> void } -> self
 
   def empty?: (*untyped args) { (*untyped) -> untyped } -> untyped
 

data/stdlib/io-console/0/io-console.rbs

@@ -0,0 +1,137 @@
+class IO
+  class ConsoleMode
+    def echo=: (bool) -> bool
+    def raw: (?min: int, ?time: int, ?intr: bool) -> self
+    def raw!: (?min: int, ?time: int, ?intr: bool) -> self
+  end
+
+  # Returns an File instance opened console.
+  #
+  # If `sym` is given, it will be sent to the opened console with `args` and the
+  # result will be returned instead of the console IO itself.
+  def self.console: () -> File?
+                  | (:close) -> nil
+                  | (Symbol sym, *untyped args) -> untyped
+
+  # returns console window size
+  #
+  # You must require 'io/console/size' to use this method.
+  def self.console_size: () -> [Integer, Integer]
+
+  # fallback to console window size
+  #
+  # You must require 'io/console/size' to use this method.
+  def self.default_console_size: -> [Integer, Integer]
+
+  def beep: () -> self
+
+  def check_winsize_changed: () { () -> void } -> self
+  def clear_screen: () -> self
+
+  # Returns a data represents the current console mode.
+  def console_mode: () -> IO::ConsoleMode
+
+  # Sets the console mode to `mode`.
+  def console_mode=: (IO::ConsoleMode mode) -> IO::ConsoleMode
+
+  # Yields `self` within cooked mode.
+  #
+  #     STDIN.cooked(&:gets)
+  #
+  # will read and return a line with echo back and line editing.
+  def cooked: [T] () { (self) -> T } -> T
+
+  # Enables cooked mode.
+  #
+  # If the terminal mode needs to be back, use io.cooked { ... }.
+  def cooked!: () -> self
+
+  def cursor: () -> [Integer, Integer]
+  def cursor=: ([Integer, Integer]) -> [Integer, Integer]
+
+  def cursor_down: (int) -> self
+  def cursor_left: (int) -> self
+  def cursor_right: (int) -> self
+  def cursor_up: (int) -> self
+
+  # Enables/disables echo back. On some platforms, all combinations of this flags
+  # and raw/cooked mode may not be valid.
+  def echo=: (bool flag) -> bool
+
+  # Returns `true` if echo back is enabled.
+  def echo?: () -> bool
+
+  def erase_line: (0 | 1 | 2 | nil) -> self
+  def erase_screen: (0 | 1 | 2 | 3 | nil) -> self
+
+  # Reads and returns a character in raw mode.
+  #
+  # See IO#raw for details on the parameters.
+  def getch: (?min: int, ?time: int, ?intr: bool) -> String
+
+  # Reads and returns a line without echo back.
+  # Prints +prompt+ unless it is +nil+.
+  #
+  # The newline character that terminates the
+  # read line is removed from the returned string,
+  # see String#chomp!.
+  def getpass: (?String) -> String
+
+  def goto: (int, int) -> self
+
+  def goto_column: (int) -> self
+
+  # Flushes input buffer in kernel.
+  def iflush: () -> self
+
+  # Flushes input and output buffers in kernel.
+  def ioflush: () -> self
+
+  # Yields `self` with disabling echo back.
+  #
+  #     STDIN.noecho(&:gets)
+  #
+  # will read and return a line without echo back.
+  def noecho: [T] () { (self) -> T } -> T
+
+  # Flushes output buffer in kernel.
+  def oflush: () -> self
+
+  def pressed?: (Integer | Symbol | String) -> bool
+
+  # Yields `self` within raw mode, and returns the result of the block.
+  #
+  #     STDIN.raw(&:gets)
+  #
+  # will read and return a line without echo back and line editing.
+  #
+  # The parameter `min` specifies the minimum number of bytes that should be
+  # received when a read operation is performed. (default: 1)
+  #
+  # The parameter `time` specifies the timeout in *seconds* with a precision of
+  # 1/10 of a second. (default: 0)
+  #
+  # If the parameter `intr` is `true`, enables break, interrupt, quit, and suspend
+  # special characters.
+  #
+  # Refer to the manual page of termios for further details.
+  def raw: [T] (?min: int, ?time: int, ?intr: bool) { (self) -> T } -> T
+
+  # Enables raw mode, and returns `io`.
+  #
+  # If the terminal mode needs to be back, use `io.raw { ... }`.
+  #
+  # See IO#raw for details on the parameters.
+  def raw!: (?min: int, ?time: int, ?intr: bool) -> self
+
+  def scroll_backward: (int) -> self
+  def scroll_forward: (int) -> self
+
+  # Returns console size.
+  def winsize: () -> [Integer, Integer]
+
+  # Tries to set console size.  The effect depends on the platform and the running
+  # environment.
+  def winsize=: ([Integer, Integer]) -> [Integer, Integer]
+              | ([Integer, Integer, Integer, Integer]) -> [Integer, Integer, Integer, Integer]
+end

data/stdlib/net-http/0/net-http.rbs

@@ -1204,6 +1204,7 @@ module Net
 
   class HTTPRequest < HTTPGenericRequest
     def initialize: (String path, ?Hash[String, untyped] initheader) -> void
+                  | (URI::Generic uri, ?Hash[String, untyped] initheader) -> void
   end
 
   class HTTP::Get < HTTPRequest
@@ -1843,4 +1844,4 @@ module Net
   class HTTPFatalError < ProtoFatalError
     include Net::HTTPExceptions
   end
-end
+end

data/stdlib/tempfile/0/tempfile.rbs

@@ -95,8 +95,8 @@ class Tempfile < File
   #        # ... do something with f ...
   #     end
   #
-  def self.create: (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) -> File
-                 | [A] (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) { (File) -> A } -> A
+  def self.create: (?(String | [String, String]) basename, ?String? tmpdir, ?mode: Integer, **untyped) -> File
+                 | [A] (?(String | [String, String]) basename, ?String? tmpdir, ?mode: Integer, **untyped) { (File) -> A } -> A
 
   # Creates a new Tempfile.
   #
@@ -220,8 +220,6 @@ class Tempfile < File
     def initialize: (::Tempfile tmpfile) -> void
   end
 
-  private
-
   # Creates a temporary file with permissions 0600 (= only readable and writable
   # by the owner) and opens it with mode "w+".
   #
@@ -265,6 +263,6 @@ class Tempfile < File
   # If Tempfile.new cannot find a unique filename within a limited number of
   # tries, then it will raise an exception.
   #
-  def self.new: (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) -> instance
-              | [A] (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) { (instance) -> A } -> A
+  def self.new: (?(String | [String, String]) basename, ?String? tmpdir, ?mode: Integer, **untyped) -> instance
+              | [A] (?(String | [String, String]) basename, ?String? tmpdir, ?mode: Integer, **untyped) { (instance) -> A } -> A
 end