steep 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c1966d8fc74abea789649fe945211c56d81da2fc655860d22849aacc7feae9f
-  data.tar.gz: f4b9793cb25421d5a9e031b78df1c29f1350f9d7cd184f12c772065607664afc
+  metadata.gz: d90e7067b0b17caaae304fa3de1e80e73a5a3cc8081270c338c291ec572a08d6
+  data.tar.gz: 15ab7f0d9168a6be10c0688fd8af60b4d85786a41f4648206287e04d737e690b
 SHA512:
-  metadata.gz: 4d3309eb83780ad4f157a7c7cc9b4bfb1763aac6ff6a2f905838b5f9bebb462ff7fb7bb2d381af5dc6698287b57ee097301d60143e9385804ca2a4700b5f3466
-  data.tar.gz: 1e142225c3dfe0d2ed47831f97840ded1a24c5348e734b3767ce1784546a71bcf5bbb1fd57bfc0baad9ec51b6a3002dacc41535ae451a06b8d6a6e4931ec7e9d
+  metadata.gz: 5a0c188bee7427b97ef8a57b88dd0ab6f5b77cade4287951010bf0318e97b33bcb642530763faf2494666261fceac63f72113cad9a38b7ecaa2f8c3f984e8a72
+  data.tar.gz: aae9a7653b739e11a9ebec676698b0a1dc4af22ab67a9701e6c4615ffe0466da7907bd0a5980c6f4285c25d63aa12b0ff02185425a03087ecdb0f45e6da3bf64

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 0.8.0 (2018-10-29)
+
+* Load types from gems (#64, #66)
+* Fix exit status (#65)
+* Fix `--version` handling (#57 @ybiquitous, #58)
+* Add `Regexp` and `MatchData` (#58 @ybiquitous)
+
 ## 0.7.1 (2018-10-22)
 
 * Rename *hash type* to *record type* (#60)

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in steep.gemspec
 gemspec
+
+gem "with_steep_types", path: "test/gems/with_steep_types"
+gem "without_steep_types", path: "test/gems/without_steep_types"

data/README.md

@@ -208,10 +208,39 @@ Use `--dump-all-types` for that.
 
     $ steep check --dump-all-types test.rb
 
-### Verbose option
+### Verbose Option
 
 Try `-v` option to report more information about type checking.
 
+### Loading Type definitions from Gems
+
+You can pass `-G` option to specify name of gems to load type definitions.
+
+```
+$ steep check -G strong_json lib
+```
+
+When you are using bundler, Steep load type definitions from bundled gems automatically.
+
+```
+$ bundle exec steep check lib
+```
+
+To disable automatic gem detection from bundler, you can specify `--no-bundler` option.
+
+```
+$ bundle exec steep check --no-bundler -G strong_json lib
+```
+
+## Making a Gem with Type Definition
+
+Put your type definition file in a directory, ship that in your gem, and let `metadata` of the gemspec to contain `"steep_types" => dir_name`.
+
+```rb
+spec.metadata = { "steep_types" => "sig" }
+```
+
+We recommend using `sig` as a name of the directory for type definitions, but you can use any directory.
 
 ## Examples
 

data/exe/steep

@@ -8,7 +8,7 @@ require 'steep'
 require 'steep/cli'
 
 begin
-  Steep::CLI.new(argv: ARGV.dup, stdout: STDOUT, stderr: STDERR, stdin: STDIN).run
+  exit Steep::CLI.new(argv: ARGV.dup, stdout: STDOUT, stderr: STDERR, stdin: STDIN).run
 rescue => exn
   STDERR.puts exn.inspect
   exn.backtrace.each do |t|

data/lib/steep/cli.rb

@@ -2,6 +2,122 @@ require 'optparse'
 
 module Steep
   class CLI
+    BUILTIN_PATH = Pathname(__dir__).join("../../stdlib").realpath
+
+    class SignatureOptions
+      class MissingGemError < StandardError
+        attr_reader :name
+        attr_reader :version
+
+        def initialize(name:, version:)
+          @name = name
+          @version = version
+          super "Requested gem not found: name=#{name}, version=#{version}"
+        end
+      end
+
+      class NoTypeDefinitionFromGemError < StandardError
+        attr_reader :gemspec
+
+        def initialize(gemspec:)
+          @gemspec = gemspec
+          super "Gem does not provide Steep type: gem=#{gemspec.name}"
+        end
+      end
+
+      attr_reader :no_builtin
+      attr_reader :no_bundler
+
+      def initialize
+        @options = []
+      end
+
+      def no_builtin!
+        @no_builtin = true
+      end
+
+      def no_bundler!
+        @no_bundler = true
+      end
+
+      def <<(option)
+        @options << option
+      end
+
+      def find_gem_dir(gem)
+        name, version = gem.split(/:/)
+        spec =
+          begin
+            Gem::Specification.find_by_name(name, version)
+          rescue Gem::MissingSpecError
+            raise MissingGemError.new(name: name, version: version)
+          end
+
+        dirs_from_spec(spec).tap do |dirs|
+          if dirs.empty?
+            raise NoTypeDefinitionFromGemError.new(gemspec: spec)
+          end
+        end
+      end
+
+      def dirs_from_spec(spec)
+        type_dirs = spec.metadata["steep_types"].yield_self do |types|
+          case types
+          when nil
+            []
+          when String
+            types.split(/:/).map do |type|
+              Pathname(type)
+            end
+          end
+        end
+
+        base_dir = Pathname(spec.gem_dir)
+        type_dirs.map do |dir|
+          base_dir + dir
+        end.select(&:directory?)
+      end
+
+      def add_bundler_gems(options)
+        if defined?(Bundler)
+          Steep.logger.info "Bundler detected!"
+          Bundler.load.gems.each do |spec|
+            dirs = dirs_from_spec(spec)
+            options.unshift *dirs
+          end
+        end
+      end
+
+      def paths
+        options = if @options.none? {|option| option.is_a?(Pathname) }
+                    @options + [Pathname("sig")]
+                  else
+                    @options
+                  end
+
+        unless no_bundler
+          add_bundler_gems(options)
+        end
+
+        paths = options.flat_map do |option|
+          case option
+          when Pathname
+            # Dir
+            [option]
+          when String
+            # gem name
+            find_gem_dir(option)
+          end
+        end
+
+        unless no_builtin
+          paths.unshift BUILTIN_PATH
+        end
+
+        paths
+      end
+    end
+
     attr_reader :argv
     attr_reader :stdout
     attr_reader :stdin
@@ -16,10 +132,17 @@ module Steep
     end
 
     def self.available_commands
-      [:check, :validate, :annotations, :scaffold, :interface, :version]
+      [:check, :validate, :annotations, :scaffold, :interface, :version, :paths]
     end
 
-    def setup_global_options
+    def process_global_options
+      OptionParser.new do |opts|
+        opts.on("--version") do
+          process_version
+          exit 0
+        end
+      end.order!
+
       true
     end
 
@@ -35,101 +158,114 @@ module Steep
     end
 
     def run
-      setup_global_options or return 1
+      process_global_options or return 1
       setup_command or return 1
 
       __send__(:"process_#{command}")
     end
 
+    def handle_dir_options(opts, options)
+      opts.on("-I [PATH]") {|path| options << Pathname(path) }
+      opts.on("-G [GEM]") {|gem| options << gem }
+      opts.on("--no-builtin") { options.no_builtin! }
+      opts.on("--no-bundler") { options.no_bundler! }
+    end
+
+    def with_signature_options
+      yield SignatureOptions.new
+    rescue SignatureOptions::MissingGemError => exn
+      stderr.puts Rainbow("Gem not found: name=#{exn.name}, version=#{exn.version}").red
+      1
+    rescue SignatureOptions::NoTypeDefinitionFromGemError => exn
+      stderr.puts Rainbow("Type definition directory not found: #{exn.gemspec.name} (#{exn.gemspec.version})").red
+      1
+    end
+
     def process_check
-      signature_dirs = []
-      verbose = false
-      no_builtin = false
-      dump_all_types = false
-      fallback_any_is_error = false
-      strict = false
+      with_signature_options do |signature_options|
+        verbose = false
+        dump_all_types = false
+        fallback_any_is_error = false
+        strict = false
 
-      OptionParser.new do |opts|
-        opts.on("-I [PATH]") {|path| signature_dirs << Pathname(path) }
-        opts.on("--no-builtin") { no_builtin = true }
-        opts.on("--verbose") { verbose = true }
-        opts.on("--dump-all-types") { dump_all_types = true }
-        opts.on("--strict") { strict = true }
-        opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
-      end.parse!(argv)
-
-      if signature_dirs.empty?
-        signature_dirs << Pathname("sig")
-      end
+        OptionParser.new do |opts|
+          handle_dir_options opts, signature_options
+          opts.on("--verbose") { verbose = true }
+          opts.on("--dump-all-types") { dump_all_types = true }
+          opts.on("--strict") { strict = true }
+          opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
+        end.parse!(argv)
 
-      unless no_builtin
-        signature_dirs.unshift Pathname(__dir__).join("../../stdlib").realpath
-      end
+        source_paths = argv.map {|path| Pathname(path) }
+        if source_paths.empty?
+          source_paths << Pathname(".")
+        end
 
-      source_paths = argv.map {|path| Pathname(path) }
-      if source_paths.empty?
-        source_paths << Pathname(".")
+        Drivers::Check.new(source_paths: source_paths, signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).tap do |check|
+          check.verbose = verbose
+          check.dump_all_types = dump_all_types
+          check.fallback_any_is_error = fallback_any_is_error || strict
+          check.allow_missing_definitions = false if strict
+        end.run
       end
-
-      Drivers::Check.new(source_paths: source_paths, signature_dirs: signature_dirs, stdout: stdout, stderr: stderr).tap do |check|
-        check.verbose = verbose
-        check.dump_all_types = dump_all_types
-        check.fallback_any_is_error = fallback_any_is_error || strict
-        check.allow_missing_definitions = false if strict
-      end.run
     end
 
     def process_validate
-      verbose = false
-      no_builtin = false
+      with_signature_options do |signature_options|
+        verbose = false
 
-      OptionParser.new do |opts|
-        opts.on("--verbose") { verbose = true }
-        opts.on("--no-builtin") { no_builtin = true }
-      end.parse!(argv)
+        OptionParser.new do |opts|
+          handle_dir_options opts, signature_options
+          opts.on("--verbose") { verbose = true }
+        end.parse!(argv)
 
-      signature_dirs = argv.map {|path| Pathname(path) }
-      if signature_dirs.empty?
-        signature_dirs << Pathname(".")
+        Drivers::Validate.new(signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).tap do |validate|
+          validate.verbose = verbose
+        end.run
       end
-
-      unless no_builtin
-        signature_dirs.unshift Pathname(__dir__).join("../../stdlib").realpath
-      end
-
-      Drivers::Validate.new(signature_dirs: signature_dirs, stdout: stdout, stderr: stderr).tap do |validate|
-        validate.verbose = verbose
-      end.run
     end
 
     def process_annotations
       source_paths = argv.map {|file| Pathname(file) }
       Drivers::Annotations.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
+      0
     end
 
     def process_scaffold
       source_paths = argv.map {|file| Pathname(file) }
       Drivers::Scaffold.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
+      0
     end
 
     def process_interface
-      signature_dirs = []
-      no_builtin = false
+      with_signature_options do |signature_options|
+        OptionParser.new do |opts|
+          handle_dir_options opts, signature_options
+        end.parse!(argv)
 
-      OptionParser.new do |opts|
-        opts.on("-I [PATH]") {|path| signature_dirs << Pathname(path) }
-        opts.on("--no-builtin") { no_builtin = true }
-      end.parse!(argv)
+        Drivers::PrintInterface.new(type_name: argv.first, signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).run
 
-      unless no_builtin
-        signature_dirs.unshift Pathname(__dir__).join("../../stdlib").realpath
+        0
       end
-
-      Drivers::PrintInterface.new(type_name: argv.first, signature_dirs: signature_dirs, stdout: stdout, stderr: stderr).run
     end
 
     def process_version
       stdout.puts Steep::VERSION
+      0
+    end
+
+    def process_paths
+      with_signature_options do |signature_options|
+        OptionParser.new do |opts|
+          handle_dir_options opts, signature_options
+        end.parse!(argv)
+
+        signature_options.paths.each do |path|
+          stdout.puts path
+        end
+
+        0
+      end
     end
   end
 end

data/lib/steep/drivers/annotations.rb

@@ -26,6 +26,8 @@ module Steep
             end
           end
         end
+
+        0
       end
     end
   end

data/lib/steep/drivers/check.rb

@@ -111,11 +111,22 @@ module Steep
           end
         end
 
-        typing.errors.each do |error|
-          next if error.is_a?(Errors::FallbackAny) && !fallback_any_is_error
-          next if error.is_a?(Errors::MethodDefinitionMissing) && allow_missing_definitions
+        errors = typing.errors.select do |error|
+          case
+          when error.is_a?(Errors::FallbackAny) && !fallback_any_is_error
+            false
+          when error.is_a?(Errors::MethodDefinitionMissing) && allow_missing_definitions
+            false
+          else
+            true
+          end
+        end
+
+        errors.each do |error|
           error.print_to stdout
         end
+
+        errors.empty? ? 0 : 1
       end
     end
   end

data/lib/steep/drivers/print_interface.rb

@@ -48,11 +48,14 @@ module Steep
                 puts "    - #{Rainbow(method_type.to_s).red} (#{loc})"
               end
             end
+            0
           rescue Steep::Subtyping::Check::CannotResolveError
             stderr.puts "🤔 #{Rainbow(type.to_s).red} cannot be resolved to interface"
+            1
           end
         else
           stderr.puts "Pass a type name to command line"
+          1
         end
       end
     end

data/lib/steep/drivers/scaffold.rb

@@ -20,6 +20,7 @@ module Steep
         each_ruby_source(source_paths, false) do |source|
           Generator.new(source: source, stderr: stderr).write(io: stdout)
         end
+        0
       end
 
       class Generator

data/lib/steep/drivers/validate.rb

@@ -32,7 +32,7 @@ module Steep
 
         validator.run(env: env, builder: builder, check: check) do |sig|
           stderr.puts "Validating #{sig.name} (#{sig.location.name}:#{sig.location.start_line})..." if verbose
-        end
+        end ? 0 : 1
       end
     end
   end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/smoke/regexp/a.rb

@@ -0,0 +1,147 @@
+# ALLOW FAILURE
+
+new_1 = Regexp.new("a")
+# !expects NoMethodError: type=::Regexp, method=foo
+new_1.foo
+
+new_2 = Regexp.new("a", true)
+# !expects NoMethodError: type=::Regexp, method=foo
+new_2.foo
+
+new_3 = Regexp.new("a", Regexp::EXTENDED | Regexp::IGNORECASE)
+# !expects NoMethodError: type=::Regexp, method=foo
+new_3.foo
+
+new_4 = Regexp.new(/a/)
+# !expects NoMethodError: type=::Regexp, method=foo
+new_4.foo
+
+compile_1 = Regexp.compile("a")
+# !expects NoMethodError: type=::Regexp, method=foo
+compile_1.foo
+
+compile_2 = Regexp.compile("a", true)
+# !expects NoMethodError: type=::Regexp, method=foo
+compile_2.foo
+
+compile_3 = Regexp.compile("a", Regexp::EXTENDED | Regexp::IGNORECASE)
+# !expects NoMethodError: type=::Regexp, method=foo
+compile_3.foo
+
+compile_4 = Regexp.compile(/a/)
+# !expects NoMethodError: type=::Regexp, method=foo
+compile_4.foo
+
+escape_1 = Regexp.escape("a")
+# !expects NoMethodError: type=::String, method=foo
+escape_1.foo
+
+last_match_1 = Regexp.last_match
+# !expects NoMethodError: type=(::MatchData | nil), method=foo
+last_match_1.foo
+
+last_match_2 = Regexp.last_match(1)
+# !expects NoMethodError: type=(::String | nil), method=foo
+last_match_2.foo
+
+quote_1 = Regexp.quote("a")
+# !expects NoMethodError: type=::String, method=foo
+quote_1.foo
+
+try_convert_1 = Regexp.try_convert(Object.new)
+# !expects NoMethodError: type=(::Regexp | nil), method=foo
+try_convert_1.foo
+
+union_1 = Regexp.union
+# !expects NoMethodError: type=::Regexp, method=foo
+union_1.foo
+
+union_2 = Regexp.union("a")
+# !expects NoMethodError: type=::Regexp, method=foo
+union_2.foo
+
+union_3 = Regexp.union("a", "b")
+# !expects NoMethodError: type=::Regexp, method=foo
+union_3.foo
+
+union_4 = Regexp.union(["a", "b"])
+# !expects NoMethodError: type=::Regexp, method=foo
+union_4.foo
+
+union_5 = Regexp.union(/a/)
+# !expects NoMethodError: type=::Regexp, method=foo
+union_5.foo
+
+union_6 = Regexp.union(/a/, /b/)
+# !expects NoMethodError: type=::Regexp, method=foo
+union_6.foo
+
+union_7 = Regexp.union([/a/, /b/])
+# !expects NoMethodError: type=::Regexp, method=foo
+union_7.foo
+
+op_eqeqeq_1 = /a/ === "a"
+# !expects NoMethodError: type=bool, method=foo
+op_eqeqeq_1.foo
+
+op_match_1 = /a/ =~ "a"
+# !expects NoMethodError: type=::Integer, method=foo
+op_match_1.foo
+
+casefold_1 = /a/.casefold?
+# !expects NoMethodError: type=bool, method=foo
+casefold_1.foo
+
+encoding_1 = /a/.encoding
+# !expects NoMethodError: type=::Encoding, method=foo
+encoding_1.foo
+
+fixed_encoding_1 = /a/.fixed_encoding?
+# !expects NoMethodError: type=bool, method=foo
+fixed_encoding_1.foo
+
+match_1 = /a/.match("a")
+# !expects NoMethodError: type=(::MatchData | nil), method=foo
+match_1.foo
+
+match_2 = /a/.match("a", 0)
+# !expects NoMethodError: type=(::MatchData | nil), method=foo
+match_2.foo
+
+/a/.match("a") do |m|
+  # !expects NoMethodError: type=::MatchData, method=foo
+  m.foo
+end
+
+/a/.match("a", 0) do |m|
+  # !expects NoMethodError: type=::MatchData, method=foo
+  m.foo
+end
+
+match_q_1 = /a/.match?("a")
+# !expects NoMethodError: type=bool, method=foo
+match_q_1.foo
+
+match_q_2 = /a/.match?("a", 0)
+# !expects NoMethodError: type=bool, method=foo
+match_q_2.foo
+
+named_captures_1 = /(?<foo>.)/.named_captures
+# !expects NoMethodError: type=::Hash<::String, ::Array<::Integer>>, method=foo
+named_captures_1.foo
+
+names_1 = /(?<foo>.)/.names
+# !expects NoMethodError: type=::Array<::String>, method=foo
+names_1.foo
+
+options_1 = /a/ix.options
+# !expects NoMethodError: type=::Integer, method=foo
+options_1.foo
+
+source_1 = /a/ix.source
+# !expects NoMethodError: type=::String, method=foo
+source_1.foo
+
+op_unary_match_1 = ~ /a/
+# !expects NoMethodError: type=(::Integer | nil), method=foo
+op_unary_match_1.foo

data/smoke/regexp/b.rb

@@ -0,0 +1,105 @@
+/(?<foo>a)/.match("a") do |match|
+  match_ref_1 = match[0]
+  # !expects NoMethodError: type=(::String | nil), method=foo
+  match_ref_1.foo
+
+  match_ref_2 = match["foo"]
+  # !expects NoMethodError: type=(::String | nil), method=foo
+  match_ref_2.foo
+
+  match_ref_3 = match[:foo]
+  # !expects NoMethodError: type=(::String | nil), method=foo
+  match_ref_3.foo
+
+  match_ref_4 = match[0, 1]
+  # !expects NoMethodError: type=::Array<::String>, method=foo
+  match_ref_4.foo
+
+  match_ref_5 = match[0..1]
+  # !expects NoMethodError: type=::Array<::String>, method=foo
+  match_ref_5.foo
+
+  begin_1 = match.begin(0)
+  # !expects NoMethodError: type=(::Integer | nil), method=foo
+  begin_1.foo
+
+  begin_2 = match.begin("foo")
+  # !expects NoMethodError: type=::Integer, method=foo
+  begin_2.foo
+
+  begin_3 = match.begin(:foo)
+  # !expects NoMethodError: type=::Integer, method=foo
+  begin_3.foo
+
+  captures_1 = match.captures
+  # !expects NoMethodError: type=::Array<::String>, method=foo
+  captures_1.foo
+
+  end_1 = match.end(0)
+  # !expects NoMethodError: type=::Integer, method=foo
+  end_1.foo
+
+  end_2 = match.end("foo")
+  # !expects NoMethodError: type=::Integer, method=foo
+  end_2.foo
+
+  end_3 = match.end(:foo)
+  # !expects NoMethodError: type=::Integer, method=foo
+  end_3.foo
+
+  length_1 = match.length
+  # !expects NoMethodError: type=::Integer, method=foo
+  length_1.foo
+
+  named_captures_1 = match.named_captures
+  # !expects NoMethodError: type=::Hash<::String, (::String | nil)>, method=foo
+  named_captures_1.foo
+
+  names_1 = match.names
+  # !expects NoMethodError: type=::Array<::String>, method=foo
+  names_1.foo
+
+  offset_1 = match.offset(0)
+  # !expects NoMethodError: type=[::Integer, ::Integer], method=foo
+  offset_1.foo
+
+  offset_2 = match.offset("foo")
+  # !expects NoMethodError: type=[::Integer, ::Integer], method=foo
+  offset_2.foo
+
+  offset_3 = match.offset(:foo)
+  # !expects NoMethodError: type=[::Integer, ::Integer], method=foo
+  offset_3.foo
+
+  post_match_1 = match.post_match
+  # !expects NoMethodError: type=::String, method=foo
+  post_match_1.foo
+
+  pre_match_1 = match.pre_match
+  # !expects NoMethodError: type=::String, method=foo
+  pre_match_1.foo
+
+  regexp_1 = match.regexp
+  # !expects NoMethodError: type=::Regexp, method=foo
+  regexp_1.foo
+
+  size_1 = match.size
+  # !expects NoMethodError: type=::Integer, method=foo
+  size_1.foo
+
+  string_1 = match.string
+  # !expects NoMethodError: type=::String, method=foo
+  string_1.foo
+
+  to_a_1 = match.to_a
+  # !expects NoMethodError: type=::Array<::String>, method=foo
+  to_a_1.foo
+
+  values_at_1 = match.values_at
+  # !expects NoMethodError: type=::Array<(::String | nil)>, method=foo
+  values_at_1.foo
+
+  values_at_2 = match.values_at(0, "foo", :foo)
+  # !expects NoMethodError: type=::Array<(::String | nil)>, method=foo
+  values_at_2.foo
+end

data/stdlib/builtin.rbi

@@ -560,10 +560,65 @@ class Enumerator<'a, 'b>
                 | -> Enumerator<['a, Integer], 'b>
 end
 
+class Encoding
+end
+
 class Regexp
-  def self.compile: (String, *any) -> Regexp
+  def self.compile: (String) -> Regexp
+                  | (String, Integer) -> Regexp
+                  | (String, bool) -> Regexp
+                  | (Regexp) -> Regexp
   def self.escape: (String) -> String
+  def self.last_match: -> MatchData?
+                     | (Integer) -> String?
+  def self.quote: (String) -> String
+  def self.try_convert: (any) -> Regexp?
+  def self.union: (*String) -> Regexp
+                | (Array<String>) -> Regexp
+                | (*Regexp) -> Regexp
+                | (Array<Regexp>) -> Regexp
+
+  def initialize: (String) -> any
+                | (String, Integer) -> any
+                | (String, bool) -> any
+                | (Regexp) -> any
+  def ===: (String) -> bool
+  def =~: (String) -> Integer?
+  def casefold?: -> bool
+  def encoding: -> Encoding
+  def fixed_encoding?: -> bool
+  def match: (String) -> MatchData?
+           | (String, Integer) -> MatchData?
+           | <'a> (String) { (MatchData) -> 'a } -> ('a | nil)
+           | <'a> (String, Integer) { (MatchData) -> 'a } -> ('a | nil)
+  def match?: (String) -> bool
+            | (String, Integer) -> bool
+  def named_captures: -> Hash<String, Array<Integer>>
+  def names: -> Array<String>
+  def options: -> Integer
   def source: -> String
+  def ~: -> Integer?
+end
+
+class MatchData
+  def []: (Integer | String | Symbol) -> String?
+        | (Integer, Integer) -> Array<String>
+        | (Range<Integer>) -> Array<String>
+  def begin: (Integer) -> Integer?
+           | (String | Symbol) -> Integer
+  def captures: -> Array<String>
+  def end: (Integer | String | Symbol) -> Integer
+  def length: -> Integer
+  def named_captures: -> Hash<String, String?>
+  def names: -> Array<String>
+  def offset: (Integer | String | Symbol) -> [Integer, Integer]
+  def post_match: -> String
+  def pre_match: -> String
+  def regexp: -> Regexp
+  def size: -> Integer
+  def string: -> String
+  def to_a: -> Array<String>
+  def values_at: (*(Integer | String | Symbol)) -> Array<String?>
 end
 
 class IO

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-25 00:00:00.000000000 Z
+date: 2018-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -292,6 +292,8 @@ files:
 - smoke/module/d.rb
 - smoke/module/e.rb
 - smoke/module/f.rb
+- smoke/regexp/a.rb
+- smoke/regexp/b.rb
 - smoke/regression/array.rb
 - smoke/regression/hash.rb
 - smoke/regression/set_divide.rb