rbs 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be247bc7ef91a934ace7a51d77b2c9070a0b8928427221e60bc848cb3158ebaf
-  data.tar.gz: becf4b84e220f43ead96eb742cbf8cbbfec0e0fc5dce3c6837c2a5ff3a95467a
+  metadata.gz: 8d03121b9d58454590a45862ba1d479305feae4f2b4d10707ae8e1a3c24d4aba
+  data.tar.gz: f147d99859cfc7e18b41a751587f7b2cba484bf397d5b306b9fe69f15dd4b452
 SHA512:
-  metadata.gz: 2c200273bbcf2e454082377a0e5e1c9b4fba0f9328c44e026b0eba2a7c3175d98b2cd11b5c8267792e54e207581aea9a46cd30472a3aec640ae7aff89e9e8ebe
-  data.tar.gz: 67038167fef41256ed56262aa4b1df3a6099c82687498c7921cd869a79c927c86abd19134bd228c78abda04aed9af3b4b3ccbac38548d74c6cfba650965380d0
+  metadata.gz: 2e325492bc73b6d9f2f62660c4e4821f7d3853780f39a957e02ad4b30fc44ca1e687fbde9d0b2843be786e51126fbb5473e1d5ae5c9c719f255bfc50fe2f7cde
+  data.tar.gz: '03995c9d63b9db359744338497985952eed7608729cb4a259b20af6e68de5eecdf3c996404701e2821f35d4bebfdb1e2c7c8e6289f9b5a7875fd4c6c507bde27'

data/.github/workflows/ruby.yml

@@ -12,8 +12,8 @@ jobs:
     strategy:
       matrix:
         container_tag:
-        - master-nightly-bionic
-        - 2.6-bionic
+        - master-nightly-focal
+        - 3.0-focal
         - 2.7-bionic
         job:
         - test
@@ -27,12 +27,18 @@ jobs:
       run: |
         apt-get update
         apt-get install -y libdb-dev
-    - name: Install
+    - name: Install bundler
       run: |
         ruby -v
         gem install bundler
+    - name: bundle config set with
+      run: |
+        echo "NO_MINITEST=true" >> $GITHUB_ENV
+        bundle config set --local without 'minitest'
+      if: "contains(matrix.container_tag, 'master-nightly')"
+    - name: bin/setup
+      run: |
         bin/setup
     - name: Run test
       run: |
         bundle exec rake ${{ matrix.job }}
-      if: "!(matrix.job == 'stdlib_test' && contains(matrix.container_tag, '2.6'))"

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## master
 
+## 1.0.1 (2021-01-27)
+
+* Signature Updates
+  * PrettyPrint ([\#573](https://github.com/ruby/rbs/pull/573))
+  * FileUtils ([\#576](https://github.com/ruby/rbs/pull/576))
+  * UnboundMethod ([\#555](https://github.com/ruby/rbs/pull/555))
+  * IO ([\#571](https://github.com/ruby/rbs/pull/571))
+  * Kernel ([\#549](https://github.com/ruby/rbs/pull/549), [\#569](https://github.com/ruby/rbs/pull/569))
+  * File ([\#552](https://github.com/ruby/rbs/pull/552))
+  * Data is removed ([\#570](https://github.com/ruby/rbs/pull/570))
+  * Module ([\#568](https://github.com/ruby/rbs/pull/568))
+  * Object ([\#557](https://github.com/ruby/rbs/pull/557))
+* Renew test sample code ([#581](https://github.com/ruby/rbs/pull/581))
+* Add description to `generate:stdlib_test` Rake task ([\#578](https://github.com/ruby/rbs/pull/578))
+* Declare supported ruby version >= 2.6 ([\#548](https://github.com/ruby/rbs/pull/548))
+* Fix module self-type override ([\#577](https://github.com/ruby/rbs/pull/577))
+* Fix parser to support all operator symbols ([\#550](https://github.com/ruby/rbs/pull/550))
+* Migrate from Minitest to Test::Unit ([\#556](https://github.com/ruby/rbs/pull/556))
+* Fix type alias parsing ([\#565](https://github.com/ruby/rbs/pull/565))
+* Support end-less method definition in `prototype rb` ([\#561](https://github.com/ruby/rbs/pull/561))
+* Support method argument forwarding in `prototype rb` ([\#560](https://github.com/ruby/rbs/pull/560))
+
 ## 1.0.0 (2020-12-24)
 
 * Signature updates for `URI`, `IO`, `File`, `Pathname`, `Module`, and `Time` ([#529](https://github.com/ruby/rbs/pull/529), [#521](https://github.com/ruby/rbs/pull/521), [#520](https://github.com/ruby/rbs/pull/520), [#511](https://github.com/ruby/rbs/pull/511), [#517](https://github.com/ruby/rbs/pull/517), [#542](https://github.com/ruby/rbs/pull/542), [#546](https://github.com/ruby/rbs/pull/546), [#540](https://github.com/ruby/rbs/pull/540), [#538](https://github.com/ruby/rbs/pull/538))

data/Gemfile

@@ -5,12 +5,12 @@ gemspec
 
 # Development dependencies
 gem "rake"
-gem "minitest"
+gem "test-unit"
+gem "test-unit-rr"
 gem "rspec"
 gem "racc"
 gem "rubocop"
 gem "rubocop-rubycw"
-gem "minitest-reporters"
 gem "json"
 gem "json-schema"
 gem 'stackprof'
@@ -22,4 +22,9 @@ gem "rbs-amber", path: "test/assets/test-gem"
 
 group :ide, optional: true do
   gem "ruby-debug-ide"
+  gem "debase", ">= 0.2.5.beta2"
+end
+
+group :minitest do
+  gem "minitest"
 end

data/README.md

@@ -107,7 +107,7 @@ instance = builder.build_instance(string)
 
 # Print the types of `gsub` method:
 puts instance.methods[:gsub].method_types.join("\n")
-# Ouputs =>
+# Outputs =>
 #  (::Regexp | ::string pattern, ::string replacement) -> ::String
 #  (::Regexp | ::string pattern, ::Hash[::String, ::String] hash) -> ::String
 #  (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String

data/Rakefile

@@ -28,8 +28,6 @@ task :validate => :parser do
   sh "#{ruby} #{rbs} validate --silent"
 
   FileList["stdlib/*"].each do |path|
-    next if path =~ %r{stdlib/builtin}
-
     lib = [File.basename(path).to_s]
 
     if lib == ["bigdecimal-math"]
@@ -84,6 +82,7 @@ task :confirm_parser do
 end
 
 namespace :generate do
+  desc "Generate a test file for a stdlib class signatures"
   task :stdlib_test, [:class] do |_task, args|
     klass = args.fetch(:class) do
       raise "Class name is necessary. e.g. rake 'generate:stdlib_test[String]'"
@@ -115,7 +114,7 @@ namespace :generate do
           require_relative "test_helper"
 
           <%- unless class_methods.empty? -%>
-          class <%= klass %>SingletonTest < Minitest::Test
+          class <%= klass %>SingletonTest < Test::Unit::TestCase
             include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load
@@ -133,7 +132,7 @@ namespace :generate do
           <%- end -%>
 
           <%- unless instance_methods.empty? -%>
-          class <%= klass %>Test < Minitest::Test
+          class <%= klass %>Test < Test::Unit::TestCase
             include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load

data/bin/test_runner.rb

@@ -4,13 +4,12 @@ $LOAD_PATH << File.join(__dir__, "../lib")
 
 require "set"
 
-IS_RUBY_27 = Gem::Version.new(RUBY_VERSION).yield_self do |ruby_version|
-  Gem::Version.new('2.7.0') <= ruby_version &&
-    ruby_version <= Gem::Version.new('2.8.0')
+IS_LATEST_RUBY = Gem::Version.new(RUBY_VERSION).yield_self do |ruby_version|
+  Gem::Version.new('3.0.0') <= ruby_version && ruby_version < Gem::Version.new('3.1.0')
 end
 
-unless IS_RUBY_27
-  STDERR.puts "⚠️⚠️⚠️⚠️ stdlib test assumes Ruby 2.7 but RUBY_VERSION==#{RUBY_VERSION} ⚠️⚠️⚠️⚠️"
+unless IS_LATEST_RUBY
+  STDERR.puts "⚠️⚠️⚠️⚠️ stdlib test assumes Ruby 3.0 but RUBY_VERSION==#{RUBY_VERSION} ⚠️⚠️⚠️⚠️"
 end
 
 KNOWN_FAILS = %w(dbm).map do |lib|

data/core/encoding.rbs

@@ -567,7 +567,7 @@ Encoding::Windows_31J: Encoding
 
 Encoding::Windows_874: Encoding
 
-class Encoding::Converter < Data
+class Encoding::Converter < Object
 end
 
 Encoding::Converter::AFTER_OUTPUT: Integer

data/core/file.rbs

@@ -533,6 +533,7 @@ class File < IO
 
   # Alias of `File.new`.
   def self.open: (string | _ToPath | int file_name, ?(string | int) mode, ?int perm) -> instance
+               | [T] (string | _ToPath | int file_name, ?(string | int) mode, ?int perm) { (File) -> T } -> T
 
   # Returns `true` if the named file exists and the effective used id of the
   # calling process is the owner of the file.

data/core/io.rbs

@@ -107,14 +107,85 @@ class IO < Object
 
   include Enumerable[String]
 
-  def <<: (untyped arg0) -> self
+  # String Output---Writes *obj* to *ios*. *obj* will be converted to a string
+  # using `to_s`.
+  #
+  #     $stdout << "Hello " << "world!\n"
+  #
+  # *produces:*
+  #
+  #     Hello world!
+  #
+  def <<: (_ToS obj) -> self
 
-  def advise: (Symbol arg0, ?Integer offset, ?Integer len) -> NilClass
+  # Announce an intention to access data from the current file in a specific
+  # pattern. On platforms that do not support the *posix_fadvise(2)* system call,
+  # this method is a no-op.
+  #
+  # *advice* is one of the following symbols:
+  #
+  # :normal
+  # :   No advice to give; the default assumption for an open file.
+  # :sequential
+  # :   The data will be accessed sequentially with lower offsets read before
+  #     higher ones.
+  # :random
+  # :   The data will be accessed in random order.
+  # :willneed
+  # :   The data will be accessed in the near future.
+  # :dontneed
+  # :   The data will not be accessed in the near future.
+  # :noreuse
+  # :   The data will only be accessed once.
+  #
+  #
+  # The semantics of a piece of advice are platform-dependent. See *man 2
+  # posix_fadvise* for details.
+  #
+  # "data" means the region of the current file that begins at *offset* and
+  # extends for *len* bytes. If *len* is 0, the region ends at the last byte of
+  # the file. By default, both *offset* and *len* are 0, meaning that the advice
+  # applies to the entire file.
+  #
+  # If an error occurs, one of the following exceptions will be raised:
+  #
+  # IOError
+  # :   The IO stream is closed.
+  # Errno::EBADF
+  # :   The file descriptor of the current file is invalid.
+  # Errno::EINVAL
+  # :   An invalid value for *advice* was given.
+  # Errno::ESPIPE
+  # :   The file descriptor of the current file refers to a FIFO or pipe. (Linux
+  #     raises Errno::EINVAL in this case).
+  # TypeError
+  # :   Either *advice* was not a Symbol, or one of the other arguments was not an
+  #     Integer.
+  # RangeError
+  # :   One of the arguments given was too big/small.
+  #
+  # This list is not exhaustive; other Errno
+  # :   exceptions are also possible.
+  #
+  def advise: ((:normal | :sequential | :random | :willneed | :dontneed | :noreuse) advise, ?Integer offset, ?Integer len) -> nil
 
-  def autoclose=: (boolish) -> bool
+  # Sets auto-close flag.
+  #
+  #     f = open("/dev/null")
+  #     IO.for_fd(f.fileno)
+  #     # ...
+  #     f.gets # may cause Errno::EBADF
+  #
+  #     f = open("/dev/null")
+  #     IO.for_fd(f.fileno).autoclose = false
+  #     # ...
+  #     f.gets # won't cause Errno::EBADF
+  #
+  def autoclose=: (bool) -> bool
 
   # Returns `true` if the underlying file descriptor of *ios* will be closed
-  # automatically at its finalization, otherwise `false` .
+  # automatically at its finalization, otherwise `false`.
+  #
   def autoclose?: () -> bool
 
   # Puts *ios* into binary mode. Once a stream is in binary mode, it cannot

data/core/kernel.rbs

@@ -13,14 +13,14 @@
 module Kernel : BasicObject
   private
 
-  def caller: (?Integer start_or_range, ?Integer length) -> ::Array[String]?
+  def self?.caller: (?Integer start_or_range, ?Integer length) -> ::Array[String]?
             | (?::Range[Integer] start_or_range) -> ::Array[String]?
             | () -> ::Array[String]
 
-  def caller_locations: (?Integer start_or_range, ?Integer length) -> ::Array[Thread::Backtrace::Location]?
+  def self?.caller_locations: (?Integer start_or_range, ?Integer length) -> ::Array[Thread::Backtrace::Location]?
                       | (?::Range[Integer] start_or_range) -> ::Array[Thread::Backtrace::Location]?
 
-  def catch: [T] (T tag) { (T tag) -> untyped } -> untyped
+  def self?.catch: [T] (T tag) { (T tag) -> untyped } -> untyped
            | () { (Object tag) -> untyped } -> untyped
 
   # In a perfect world this should be:
@@ -38,10 +38,9 @@ module Kernel : BasicObject
   def define_singleton_method: (Symbol | String symbol, ?Proc | Method | UnboundMethod method) -> Symbol
                              | (Symbol | String symbol) { () -> untyped } -> Symbol
 
-  def eval: (String arg0, ?Binding arg1, ?String filename, ?Integer lineno) -> untyped
+  def self?.eval: (String arg0, ?Binding arg1, ?String filename, ?Integer lineno) -> untyped
 
   # Returns `true` if `yield` would execute a block in the current context.
-  # The `iterator?` form is mildly deprecated.
   #
   # ```ruby
   # def try
@@ -55,8 +54,7 @@ module Kernel : BasicObject
   # try { "hello" }      #=> "hello"
   # try do "hello" end   #=> "hello"
   # ```
-  def iterator?: () -> bool
-  alias block_given? iterator?
+  def self.block_given?: () -> bool
 
   # Returns the names of the current local variables.
   #
@@ -67,9 +65,9 @@ module Kernel : BasicObject
   # end
   # local_variables   #=> [:fred, :i]
   # ```
-  def local_variables: () -> ::Array[Symbol]
+  def self?.local_variables: () -> ::Array[Symbol]
 
-  def srand: (?Numeric number) -> Numeric
+  def self?.srand: (?Numeric number) -> Numeric
 
   # Creates a subprocess. If a block is specified, that block is run in the
   # subprocess, and the subprocess terminates with a status of zero.
@@ -88,7 +86,7 @@ module Kernel : BasicObject
   #
   # Note that fork(2) is not available on some platforms like Windows and
   # NetBSD 4. Therefore you should use spawn() instead of fork().
-  def fork: () -> Integer?
+  def self?.fork: () -> Integer?
           | () { () -> untyped } -> Integer?
 
   def initialize_copy: (self object) -> self
@@ -112,50 +110,50 @@ module Kernel : BasicObject
   # Array(nil)         #=> []
   # Array(1)           #=> [1]
   # ```
-  def Array: (NilClass x) -> [ ]
+  def self?.Array: (NilClass x) -> [ ]
            | [T] (::Array[T] x) -> ::Array[T]
            | [T] (::Range[T] x) -> ::Array[T]
            | [K, V] (::Hash[K, V] x) -> ::Array[[K, V]]
            | [T] (T x) -> ::Array[T]
 
-  def Complex: (Numeric | String x, ?Numeric | String y, ?exception: bool exception) -> Complex
+  def self?.Complex: (Numeric | String x, ?Numeric | String y, ?exception: bool exception) -> Complex
 
-  def Float: (Numeric | String x, ?exception: bool exception) -> Float
+  def self?.Float: (Numeric | String x, ?exception: bool exception) -> Float
 
-  def Hash: [K, V] (Object x) -> ::Hash[K, V]
+  def self?.Hash: [K, V] (Object x) -> ::Hash[K, V]
 
-  def Integer: (Numeric | String arg, ?exception: bool exception) -> Integer
+  def self?.Integer: (Numeric | String arg, ?exception: bool exception) -> Integer
              | (String arg, ?Integer base, ?exception: bool exception) -> Integer
 
-  def Rational: (Numeric | String | Object x, ?Numeric | String y, ?exception: bool exception) -> Rational
+  def self?.Rational: (Numeric | String | Object x, ?Numeric | String y, ?exception: bool exception) -> Rational
 
-  def String: (Object x) -> String
+  def self?.String: (Object x) -> String
 
   # Returns the called name of the current method as a
   # [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html). If called
   # outside of a method, it returns `nil` .
-  def __callee__: () -> Symbol?
+  def self?.__callee__: () -> Symbol?
 
   # Returns the canonicalized absolute path of the directory of the file
   # from which this method is called. It means symlinks in the path is
   # resolved. If `__FILE__` is `nil`, it returns `nil` . The return value
   # equals to `File.dirname(File.realpath(__FILE__))` .
-  def __dir__: () -> String?
+  def self?.__dir__: () -> String?
 
   # Returns the name at the definition of the current method as a
   # [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html). If called
   # outside of a method, it returns `nil` .
-  def __method__: () -> Symbol?
+  def self?.__method__: () -> Symbol?
 
-  def `: (String arg0) -> String
+  def self?.`: (String arg0) -> String
 
-  def abort: (?String msg) -> bot
+  def self?.abort: (?String msg) -> bot
 
-  def at_exit: () { () -> untyped } -> Proc
+  def self?.at_exit: () { () -> untyped } -> Proc
 
-  def autoload: (String | Symbol _module, String filename) -> NilClass
+  def self?.autoload: (String | Symbol _module, String filename) -> NilClass
 
-  def autoload?: (Symbol | String name) -> String?
+  def self?.autoload?: (Symbol | String name) -> String?
 
   # Returns a `Binding` object, describing the variable and method bindings
   # at the point of call. This object can be used when calling `eval` to
@@ -169,7 +167,7 @@ module Kernel : BasicObject
   # b = get_binding("hello")
   # eval("param", b)   #=> "hello"
   # ```
-  def binding: () -> Binding
+  def self?.binding: () -> Binding
 
   # Initiates the termination of the Ruby script by raising the `SystemExit`
   # exception. This exception may be caught. The optional parameter is used
@@ -207,10 +205,10 @@ module Kernel : BasicObject
   #
   #     at_exit function
   #     in finalizer
-  def exit: () -> bot
+  def self?.exit: () -> bot
           | (?Integer | TrueClass | FalseClass status) -> bot
 
-  def exit!: (Integer | TrueClass | FalseClass status) -> bot
+  def self?.exit!: (Integer | TrueClass | FalseClass status) -> bot
 
   # With no arguments, raises the exception in `$!` or raises a
   # `RuntimeError` if `$!` is `nil` . With a single `String` argument,
@@ -230,24 +228,26 @@ module Kernel : BasicObject
   # “current” exception ( `$!` ) if any. An alternative value, either an
   # `Exception` object or `nil`, can be specified via the `:cause`
   # argument.
-  def fail: () -> bot
+  def self?.fail: () -> bot
           | (String arg0) -> bot
           | (_Exception arg0, ?untyped arg1, ?::Array[String] arg2) -> bot
   alias raise fail
+  alias self.raise self.fail
 
-  def format: (String format, *untyped args) -> String
+  def self?.format: (String format, *untyped args) -> String
   alias sprintf format
+  alias self.sprintf self.format
 
-  def gets: (?String arg0, ?Integer arg1) -> String?
+  def self?.gets: (?String arg0, ?Integer arg1) -> String?
 
   # Returns an array of the names of global variables.
   #
   # ```ruby
   # global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
   # ```
-  def global_variables: () -> ::Array[Symbol]
+  def self?.global_variables: () -> ::Array[Symbol]
 
-  def load: (String filename, ?boolish) -> bool
+  def self?.load: (String filename, ?boolish) -> bool
 
   # Repeatedly executes the block.
   #
@@ -277,10 +277,10 @@ module Kernel : BasicObject
   #   puts enum.next
   # } #=> :ok
   # ```
-  def loop: () { (nil) -> untyped } -> bot
+  def self?.loop: () { (nil) -> untyped } -> bot
           | () -> ::Enumerator[nil, bot]
 
-  def open: (String name, ?String mode, ?Integer perm) -> IO?
+  def self?.open: (String name, ?String mode, ?Integer perm) -> IO?
           | [T] (String name, ?String mode, ?Integer perm) { (IO) -> T } -> T
 
   # Prints each object in turn to `$stdout` . If the output field separator
@@ -300,25 +300,25 @@ module Kernel : BasicObject
   #
   #     cat12399
   #     cat, 1, 2, 3, 99
-  def print: (*Kernel args) -> nil
+  def self?.print: (*Kernel args) -> nil
 
-  def printf: (IO arg0, String arg1, *untyped args) -> nil
+  def self?.printf: (IO arg0, String arg1, *untyped args) -> nil
             | (String arg1, *untyped args) -> nil
             | -> nil
 
-  def proc: () { () -> untyped } -> Proc
+  def self?.proc: () { () -> untyped } -> Proc
 
-  def lambda: () { () -> untyped } -> Proc
+  def self?.lambda: () { () -> untyped } -> Proc
 
-  def putc: (Integer arg0) -> Integer
+  def self?.putc: (Integer arg0) -> Integer
           | (String arg0) -> String
 
-  def puts: (*untyped arg0) -> NilClass
+  def self?.puts: (*untyped arg0) -> NilClass
 
-  def p: [T] (T arg0) -> T
+  def self?.p: [T] (T arg0) -> T
        | (*untyped arg0) -> Array[untyped]
 
-  def pp: [T] (T arg0) -> T
+  def self?.pp: [T] (T arg0) -> T
         | (*untyped arg0) -> Array[untyped]
 
   # If called without an argument, or if `max.to_i.abs == 0`, rand returns
@@ -356,31 +356,31 @@ module Kernel : BasicObject
   # See also
   # [Random\#rand](https://ruby-doc.org/core-2.6.3/Random.html#method-i-rand)
   # .
-  def rand: () -> Float
+  def self?.rand: () -> Float
           | (Integer arg0) -> Integer
           | (::Range[Integer] arg0) -> Integer
           | (::Range[Float] arg0) -> Float
 
-  def readline: (?String arg0, ?Integer arg1) -> String
+  def self?.readline: (?String arg0, ?Integer arg1) -> String
 
-  def readlines: (?String arg0, ?Integer arg1) -> ::Array[String]
+  def self?.readlines: (?String arg0, ?Integer arg1) -> ::Array[String]
 
-  def require: (String path) -> bool
+  def self?.require: (String path) -> bool
 
-  def require_relative: (String feature) -> bool
+  def self?.require_relative: (String feature) -> bool
 
-  def select: (::Array[IO] read, ?::Array[IO] write, ?::Array[IO] error, ?Integer timeout) -> ::Array[String]
+  def self?.select: (::Array[IO] read, ?::Array[IO] write, ?::Array[IO] error, ?Integer timeout) -> ::Array[String]
 
-  def sleep: () -> bot
+  def self?.sleep: () -> bot
            | (Numeric duration) -> Integer
 
-  def syscall: (Integer num, *untyped args) -> untyped
+  def self?.syscall: (Integer num, *untyped args) -> untyped
 
-  def test: (String | Integer cmd, String | IO file1, ?String | IO file2) -> (TrueClass | FalseClass | Time | nil | Integer)
+  def self?.test: (String | Integer cmd, String | IO file1, ?String | IO file2) -> (TrueClass | FalseClass | Time | nil | Integer)
 
-  def throw: (Object tag, ?untyped obj) -> bot
+  def self?.throw: (Object tag, ?untyped obj) -> bot
 
-  def warn: (*untyped msg, ?uplevel: Integer | nil) -> NilClass
+  def self?.warn: (*untyped msg, ?uplevel: Integer | nil) -> NilClass
 
   # Replaces the current process by running the given external *command* ,
   # which can take one of the following forms:
@@ -461,7 +461,7 @@ module Kernel : BasicObject
   # exec "echo", "*"    # echoes an asterisk
   # # never get here
   # ```
-  def exec: (*String args) -> bot
+  def self?.exec: (*String args) -> bot
 
   # Executes *command…* in a subshell. *command…* is one of following forms.
   #
@@ -488,7 +488,7 @@ module Kernel : BasicObject
   #     *
   #
   # See `Kernel.exec` for the standard shell.
-  def system: (*String args) -> (NilClass | FalseClass | TrueClass)
+  def self?.system: (*String args) -> (NilClass | FalseClass | TrueClass)
 end
 
 Kernel::RUBYGEMS_ACTIVATION_MONITOR: untyped