steep 0.13.0 → 0.14.0

data/lib/steep/project/file.rb

@@ -44,45 +44,55 @@ module Steep
         end
       end
 
+      def self.parse(source_code, path:, factory:)
+        Source.parse(source_code, path: path.to_s, factory: factory, labeling: ASTUtils::Labeling.new)
+      end
+
+      def self.type_check(source, subtyping:)
+        typing = Typing.new
+
+        if source
+          annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
+          const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: nil)
+          type_env = TypeInference::TypeEnv.build(annotations: annotations,
+                                                  subtyping: subtyping,
+                                                  const_env: const_env,
+                                                  signatures: subtyping.factory.env)
+
+          construction = TypeConstruction.new(
+            checker: subtyping,
+            annotations: annotations,
+            source: source,
+            context: TypeInference::Context.new(
+              block_context: nil,
+              module_context: TypeInference::Context::ModuleContext.new(
+                instance_type: nil,
+                module_type: nil,
+                implement_name: nil,
+                current_namespace: AST::Namespace.root,
+                const_env: const_env,
+                class_name: nil
+              ),
+              method_context: nil,
+              break_context: nil,
+              self_type: AST::Builtin::Object.instance_type,
+              type_env: type_env
+            ),
+            typing: typing
+          )
+
+          construction.synthesize(source.node)
+        end
+
+        typing
+      end
+
       def type_check(subtyping, env_updated_at)
         # skip type check
         return false if status.is_a?(TypeCheckStatus) && env_updated_at <= status.timestamp
 
         parse(subtyping.factory) do |source|
-          typing = Typing.new
-
-          if source
-            annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
-            const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: nil)
-            type_env = TypeInference::TypeEnv.build(annotations: annotations,
-                                                    subtyping: subtyping,
-                                                    const_env: const_env,
-                                                    signatures: subtyping.factory.env)
-
-            construction = TypeConstruction.new(
-              checker: subtyping,
-              annotations: annotations,
-              source: source,
-              context: TypeInference::Context.new(
-                block_context: nil,
-                module_context: TypeInference::Context::ModuleContext.new(
-                  instance_type: nil,
-                  module_type: nil,
-                  implement_name: nil,
-                  current_namespace: AST::Namespace.root,
-                  const_env: const_env,
-                  class_name: nil
-                ),
-                method_context: nil,
-                break_context: nil,
-                self_type: AST::Builtin::Object.instance_type,
-                type_env: type_env
-              ),
-              typing: typing
-            )
-
-            construction.synthesize(source.node)
-          end
+          typing = self.class.type_check(source, subtyping: subtyping)
 
           @status = TypeCheckStatus.new(
             typing: typing,
@@ -100,7 +110,7 @@ module Steep
         if status.is_a?(TypeCheckStatus)
           yield status.source
         else
-          yield Source.parse(content, path: path.to_s, factory: factory, labeling: ASTUtils::Labeling.new)
+          yield self.class.parse(content, path: path, factory: factory)
         end
       rescue AnnotationParser::SyntaxError => exn
         Steep.logger.warn { "Annotation syntax error on #{path}: #{exn.inspect}" }

data/lib/steep/type_construction.rb

@@ -708,8 +708,15 @@ module Steep
         when :return
           yield_self do
             if node.children.size > 0
+              method_return_type = expand_alias(method_context&.return_type)
+
               return_types = node.children.map do |value|
-                synthesize(value)
+                synthesize(value,
+                           hint: if method_return_type.is_a?(AST::Types::Void)
+                                   nil
+                                 else
+                                   method_return_type
+                                 end)
               end
 
               value_type = if return_types.size == 1
@@ -718,9 +725,9 @@ module Steep
                              AST::Builtin::Array.instance_type(union_type(*return_types))
                            end
 
-              if (ret_type = expand_alias(method_context&.return_type))
-                unless ret_type.is_a?(AST::Types::Void)
-                  result = check_relation(sub_type: value_type, super_type: ret_type)
+              if method_return_type
+                unless method_return_type.is_a?(AST::Types::Void)
+                  result = check_relation(sub_type: value_type, super_type: method_return_type)
 
                   if result.failure?
                     typing.add_error(Errors::ReturnTypeMismatch.new(node: node,
@@ -941,9 +948,9 @@ module Steep
               if constructor.module_context&.implement_name && !namespace_module?(node)
                 constructor.validate_method_definitions(node, constructor.module_context.implement_name)
               end
-            end
 
-            typing.add_typing(node, AST::Builtin.nil_type, context)
+              typing.add_typing(node, AST::Builtin.nil_type, constructor.context)
+            end
           end
 
         when :module
@@ -954,9 +961,9 @@ module Steep
               if constructor.module_context&.implement_name && !namespace_module?(node)
                 constructor.validate_method_definitions(node, constructor.module_context.implement_name)
               end
-            end
 
-            typing.add_typing(node, AST::Builtin.nil_type, context)
+              typing.add_typing(node, AST::Builtin.nil_type, constructor.context)
+            end
           end
 
         when :self

data/lib/steep/typing.rb

@@ -1,5 +1,16 @@
 module Steep
   class Typing
+    class UnknownNodeError < StandardError
+      attr_reader :op
+      attr_reader :node
+
+      def initialize(op, node:)
+        @op = op
+        @node = node
+        super "Unknown node for #{op}: #{node.inspect}"
+      end
+    end
+
     attr_reader :errors
     attr_reader :typing
     attr_reader :parent
@@ -48,7 +59,7 @@ module Steep
         if parent
           parent.type_of(node: node)
         else
-          raise "Unknown node for typing: #{node.inspect}"
+          raise UnknownNodeError.new(:type, node: node)
         end
       end
     end
@@ -62,7 +73,7 @@ module Steep
         if parent
           parent.context_of(node: node)
         else
-          raise "Unknown node for context: #{node.inspect}"
+          raise UnknownNodeError.new(:context, node: node)
         end
       end
     end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end

data/smoke/alias/a.rb

@@ -1,7 +1,7 @@
 # @type var x: foo
 x = ""
 
-# !expects ArgumentTypeMismatch: receiver=(::Integer | ::String), expected=::String, actual=::Integer
+# !expects ArgumentTypeMismatch: receiver=(::Integer | ::String), expected=::string, actual=::Integer
 x + 123
 
 # @type var y: bar

data/smoke/regexp/b.rb

@@ -12,11 +12,11 @@
   match_ref_3.foo
 
   match_ref_4 = match[0, 1]
-  # !expects NoMethodError: type=::Array[::String], method=foo
+  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   match_ref_4.foo
 
   match_ref_5 = match[0..1]
-  # !expects NoMethodError: type=::Array[::String], method=foo
+  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   match_ref_5.foo
 
   begin_1 = match.begin(0)
@@ -32,7 +32,7 @@
   begin_3.foo
 
   captures_1 = match.captures
-  # !expects NoMethodError: type=::Array[::String], method=foo
+  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   captures_1.foo
 
   end_1 = match.end(0)
@@ -92,7 +92,7 @@
   string_1.foo
 
   to_a_1 = match.to_a
-  # !expects NoMethodError: type=::Array[::String], method=foo
+  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   to_a_1.foo
 
   values_at_1 = match.values_at

data/vendor/ruby-signature/Rakefile

@@ -9,16 +9,17 @@ Rake::TestTask.new(:test) do |t|
   end
 end
 
-task :default => [:test, :stdlib_test, :rubocop, :validate]
+multitask :default => [:test, :stdlib_test, :rubocop, :validate]
 
-task :validate do
+task :validate => :parser do
   sh "rbs validate"
 end
 
-task :stdlib_test do
-  FileList["test/stdlib/*_test.rb"].each do |test|
+FileList["test/stdlib/*_test.rb"].each do |test|
+  multitask test => :parser do
     sh "ruby bin/test_runner.rb #{test}"
   end
+  multitask stdlib_test: test
 end
 
 task :rubocop do

data/vendor/ruby-signature/docs/CONTRIBUTING.md

@@ -20,8 +20,8 @@
     - Use `bin/annotate-with-rdoc stdlib/path/to/signature.rbs` to annotate the RBS files.
     - Committing the generated annotations is recommended.
 6. Fix method types and comments.
-    - The auto generated RDoc comments include `argslist` section, which we don't expect to be included the RBS files.
-    - Delete the `argslist` sections.
+    - The auto generated RDoc comments include `arglists` section, which we don't expect to be included the RBS files.
+    - Delete the `arglists` sections.
     - Give methods correct types.
     - Write tests, if possible. (If it is too difficult to write test, skip it.)
 
@@ -50,7 +50,7 @@ You may find the *Good for first contributor* column where you can find some cla
   * You can use --method-owner if you want to print method of other classes too, for documentation purpose.
 * `bin/annotate-with-rdoc stdlib/builtin/string.rbs`
   * Write comments using RDoc.
-  * It contains argslist section, but I don't think we should have it in RBS files.
+  * It contains arglists section, but I don't think we should have it in RBS files.
 * `bin/query-rdoc String#initialize`
   * Print RDoc documents in the format you can copy-and-paste to RBS.
 * `bin/sort stdlib/builtin/string.rbs`

data/vendor/ruby-signature/lib/ruby/signature/cli.rb

@@ -23,7 +23,7 @@ module Ruby
             loader.add(path: Pathname(dir))
           end
 
-          loader.no_builtin! nil if no_stdlib
+          loader.no_builtin! if no_stdlib
 
           loader
         end
@@ -37,7 +37,7 @@ module Ruby
         @stderr = stderr
       end
 
-      COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :version]
+      COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :version, :parse]
 
       def library_parse(opts, options:)
         opts.on("-r LIBRARY") do |lib|
@@ -523,6 +523,27 @@ module Ruby
         end
       end
 
+      def run_parse(args, options)
+        loader = EnvironmentLoader.new()
+
+        syntax_error = false
+        args.each do |path|
+          path = Pathname(path)
+          loader.each_signature(path) do |sig_path|
+            Parser.parse_signature(sig_path.read)
+          rescue Ruby::Signature::Parser::SyntaxError => ex
+            loc = ex.error_value.location
+            stdout.puts "#{sig_path}:#{loc.start_line}:#{loc.start_column}: parse error on value: (#{ex.token_str})"
+            syntax_error = true
+          rescue Ruby::Signature::Parser::SemanticsError => ex
+            loc = ex.location
+            stdout.puts "#{sig_path}:#{loc.start_line}:#{loc.start_column}: #{ex.original_message}"
+            syntax_error = true
+          end
+        end
+        exit 1 if syntax_error
+      end
+
       def parse_type_name(string)
         Namespace.parse(string).yield_self do |namespace|
           last = namespace.path.last

data/vendor/ruby-signature/lib/ruby/signature/parser.y

@@ -1330,11 +1330,12 @@ class SyntaxError < StandardError
 end
 
 class SemanticsError < StandardError
-  attr_reader :subject
+  attr_reader :subject, :location, :original_message
 
   def initialize(message, subject:, location:)
     @subject = subject
     @location = location
+    @original_message = message
 
     super "parse error on #{location}: #{message}"
   end

data/vendor/ruby-signature/lib/ruby/signature/prototype/rb.rb

@@ -210,6 +210,9 @@ module Ruby
                 end
               end
             end
+            each_child node do |child|
+              process child, namespace: namespace, current_module: current_module, comments: comments, singleton: singleton
+            end
 
           when :CDECL
             type_name = case

data/vendor/ruby-signature/lib/ruby/signature/test/spy.rb

@@ -59,6 +59,7 @@ module Ruby
             spy = self
 
             object.singleton_class.class_eval do
+              remove_method spy.method_name
               define_method spy.method_name, spy.spy()
             end
           end
@@ -154,6 +155,7 @@ module Ruby
             spy = self
 
             mod.class_eval do
+              remove_method spy.method_name
               define_method spy.method_name, spy.spy()
             end
           end
@@ -162,6 +164,7 @@ module Ruby
             spy = self
 
             mod.class_eval do
+              remove_method spy.method_name
               define_method spy.method_name, spy.original_method
             end
           end

data/vendor/ruby-signature/stdlib/builtin/match_data.rbs

@@ -1,141 +1,271 @@
-class MatchData < Object
-  def ==: (untyped arg0) -> bool
+# MatchData encapsulates the result of matching a Regexp against string. It is
+# returned by Regexp#match and String#match, and also stored in a global
+# variable returned by Regexp.last_match.
+#
+# Usage:
+#
+#     url = 'https://docs.ruby-lang.org/en/2.5.0/MatchData.html'
+#     m = url.match(/(\d\.?)+/)   # => #<MatchData "2.5.0" 1:"0">
+#     m.string                    # => "https://docs.ruby-lang.org/en/2.5.0/MatchData.html"
+#     m.regexp                    # => /(\d\.?)+/
+#     # entire matched substring:
+#     m[0]                        # => "2.5.0"
+#
+#     # Working with unnamed captures
+#     m = url.match(%r{([^/]+)/([^/]+)\.html$})
+#     m.captures                  # => ["2.5.0", "MatchData"]
+#     m[1]                        # => "2.5.0"
+#     m.values_at(1, 2)           # => ["2.5.0", "MatchData"]
+#
+#     # Working with named captures
+#     m = url.match(%r{(?<version>[^/]+)/(?<module>[^/]+)\.html$})
+#     m.captures                  # => ["2.5.0", "MatchData"]
+#     m.named_captures            # => {"version"=>"2.5.0", "module"=>"MatchData"}
+#     m[:version]                 # => "2.5.0"
+#     m.values_at(:version, :module)
+#                                 # => ["2.5.0", "MatchData"]
+#     # Numerical indexes are working, too
+#     m[1]                        # => "2.5.0"
+#     m.values_at(1, 2)           # => ["2.5.0", "MatchData"]
+#
+# ## Global variables equivalence
+#
+# Parts of last MatchData (returned by Regexp.last_match) are also aliased as
+# global variables:
+#
+# *   `$~` is Regexp.last_match;
+# *   `$&` is [Regexp.last_match](0);
+# *   `$1`, `$2`, and so on are [Regexp.last_match](i) (captures by number);
+# *   `$`` is Regexp.last_match`.pre_match`;
+# *   `$'` is Regexp.last_match`.post_match`;
+# *   `$+` is [Regexp.last_match](-1) (the last capture).
+#
+#
+# See also "Special global variables" section in Regexp documentation.
+#
+class MatchData
+  public
 
-  def []: (Integer i_or_start_or_range_or_name) -> String?
-        | (Integer i_or_start_or_range_or_name, ?Integer length) -> ::Array[String]
-        | (::Range[Integer] i_or_start_or_range_or_name) -> ::Array[String]
-        | (String | Symbol i_or_start_or_range_or_name) -> String?
+  # Equality---Two matchdata are equal if their target strings, patterns, and
+  # matched positions are identical.
+  #
+  def ==: (untyped other) -> bool
 
-  def begin: (Integer | String | Symbol n) -> Integer?
+  # Match Reference -- MatchData acts as an array, and may be accessed using the
+  # normal array indexing techniques.  `mtch[0]` is equivalent to the special
+  # variable `$&`, and returns the entire matched string.  `mtch[1]`, `mtch[2]`,
+  # and so on return the values of the matched backreferences (portions of the
+  # pattern between parentheses).
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m          #=> #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
+  #     m[0]       #=> "HX1138"
+  #     m[1, 2]    #=> ["H", "X"]
+  #     m[1..3]    #=> ["H", "X", "113"]
+  #     m[-3, 2]   #=> ["X", "113"]
+  #
+  #     m = /(?<foo>a+)b/.match("ccaaab")
+  #     m          #=> #<MatchData "aaab" foo:"aaa">
+  #     m["foo"]   #=> "aaa"
+  #     m[:foo]    #=> "aaa"
+  #
+  def []: (Integer idx) -> String?
+        | (Integer start, Integer length) -> ::Array[String?]
+        | (::Range[Integer] range) -> ::Array[String?]
+        | (String | Symbol name) -> String?
 
-  # Returns the array of captures; equivalent to `mtch.to_a[1..-1]` .
-  # 
-  # ```ruby
-  # f1,f2,f3,f4 = /(.)(.)(\d+)(\d)/.match("THX1138.").captures
-  # f1    #=> "H"
-  # f2    #=> "X"
-  # f3    #=> "113"
-  # f4    #=> "8"
-  # ```
-  def captures: () -> ::Array[String]
+  # Returns the offset of the start of the *n*th element of the match array in the
+  # string. *n* can be a string or symbol to reference a named capture.
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.begin(0)       #=> 1
+  #     m.begin(2)       #=> 2
+  #
+  #     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
+  #     p m.begin(:foo)  #=> 0
+  #     p m.begin(:bar)  #=> 2
+  #
+  def begin: (Integer | String | Symbol n_or_name) -> Integer?
 
-  def `end`: (Integer | String | Symbol n) -> Integer?
+  # Returns the array of captures; equivalent to `mtch.to_a[1..-1]`.
+  #
+  #     f1,f2,f3,f4 = /(.)(.)(\d+)(\d)/.match("THX1138.").captures
+  #     f1    #=> "H"
+  #     f2    #=> "X"
+  #     f3    #=> "113"
+  #     f4    #=> "8"
+  #
+  def captures: () -> ::Array[String?] 
 
+  # Returns the offset of the character immediately following the end of the *n*th
+  # element of the match array in the string. *n* can be a string or symbol to
+  # reference a named capture.
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.end(0)         #=> 7
+  #     m.end(2)         #=> 3
+  #
+  #     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
+  #     p m.end(:foo)    #=> 1
+  #     p m.end(:bar)    #=> 3
+  #
+  def `end`: (Integer | String | Symbol n_or_name) -> Integer?
+
+  # Equality---Two matchdata are equal if their target strings, patterns, and
+  # matched positions are identical.
+  #
   def eql?: (untyped other) -> bool
 
-  # Produce a hash based on the target string, regexp and matched positions
-  # of this matchdata.
-  # 
-  # See also Object\#hash.
+  # Produce a hash based on the target string, regexp and matched positions of
+  # this matchdata.
+  #
+  # See also Object#hash.
+  #
   def hash: () -> Integer
 
+  # Returns a printable version of *mtch*.
+  #
+  #     puts /.$/.match("foo").inspect
+  #     #=> #<MatchData "o">
+  #
+  #     puts /(.)(.)(.)/.match("foo").inspect
+  #     #=> #<MatchData "foo" 1:"f" 2:"o" 3:"o">
+  #
+  #     puts /(.)(.)?(.)/.match("fo").inspect
+  #     #=> #<MatchData "fo" 1:"f" 2:nil 3:"o">
+  #
+  #     puts /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").inspect
+  #     #=> #<MatchData "hog" foo:"h" bar:"o" baz:"g">
+  #
   def inspect: () -> String
 
   # Returns the number of elements in the match array.
-  # 
-  # ```ruby
-  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  # m.length   #=> 5
-  # m.size     #=> 5
-  # ```
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.length   #=> 5
+  #     m.size     #=> 5
+  #
   def length: () -> Integer
 
-  # Returns a [Hash](https://ruby-doc.org/core-2.6.3/Hash.html) using named
-  # capture.
-  # 
-  # A key of the hash is a name of the named captures. A value of the hash
-  # is a string of last successful capture of corresponding group.
-  # 
-  # ```ruby
-  # m = /(?.)(?.)/.match("01")
-  # m.named_captures #=> {"a" => "0", "b" => "1"}
-  # 
-  # m = /(?.)(?.)?/.match("0")
-  # m.named_captures #=> {"a" => "0", "b" => nil}
-  # 
-  # m = /(?.)(?.)/.match("01")
-  # m.named_captures #=> {"a" => "1"}
-  # 
-  # m = /(?x)|(?y)/.match("x")
-  # m.named_captures #=> {"a" => "x"}
-  # ```
+  # Returns a Hash using named capture.
+  #
+  # A key of the hash is a name of the named captures. A value of the hash is a
+  # string of last successful capture of corresponding group.
+  #
+  #     m = /(?<a>.)(?<b>.)/.match("01")
+  #     m.named_captures #=> {"a" => "0", "b" => "1"}
+  #
+  #     m = /(?<a>.)(?<b>.)?/.match("0")
+  #     m.named_captures #=> {"a" => "0", "b" => nil}
+  #
+  #     m = /(?<a>.)(?<a>.)/.match("01")
+  #     m.named_captures #=> {"a" => "1"}
+  #
+  #     m = /(?<a>x)|(?<a>y)/.match("x")
+  #     m.named_captures #=> {"a" => "x"}
+  #
   def named_captures: () -> ::Hash[String, String?]
 
+  # Returns a list of names of captures as an array of strings. It is same as
+  # mtch.regexp.names.
+  #
+  #     /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").names
+  #     #=> ["foo", "bar", "baz"]
+  #
+  #     m = /(?<x>.)(?<y>.)?/.match("a") #=> #<MatchData "a" x:"a" y:nil>
+  #     m.names                          #=> ["x", "y"]
+  #
   def names: () -> ::Array[String]
 
-  def offset: (Integer | Symbol | String n) -> ([Integer, Integer] | [nil, nil])
+  # Returns a two-element array containing the beginning and ending offsets of the
+  # *n*th match. *n* can be a string or symbol to reference a named capture.
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.offset(0)      #=> [1, 7]
+  #     m.offset(4)      #=> [6, 7]
+  #
+  #     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
+  #     p m.offset(:foo) #=> [0, 1]
+  #     p m.offset(:bar) #=> [2, 3]
+  #
+  def offset: (Integer | Symbol | String n_or_name) -> ([ Integer, Integer ] | [ nil, nil ])
 
-  # Returns the portion of the original string after the current match.
-  # Equivalent to the special variable `$'` .
-  # 
-  # ```ruby
-  # m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie")
-  # m.post_match   #=> ": The Movie"
-  # ```
+  # Returns the portion of the original string after the current match. Equivalent
+  # to the special variable `$'`.
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie")
+  #     m.post_match   #=> ": The Movie"
+  #
   def post_match: () -> String
 
   # Returns the portion of the original string before the current match.
-  # Equivalent to the special variable `` $` `` .
-  # 
-  # ```ruby
-  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  # m.pre_match   #=> "T"
-  # ```
+  # Equivalent to the special variable `$``.
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.pre_match   #=> "T"
+  #
   def pre_match: () -> String
 
   # Returns the regexp.
-  # 
-  # ```ruby
-  # m = /a.*b/.match("abc")
-  # m.regexp #=> /a.*b/
-  # ```
+  #
+  #     m = /a.*b/.match("abc")
+  #     m.regexp #=> /a.*b/
+  #
   def regexp: () -> Regexp
 
   # Returns the number of elements in the match array.
-  # 
-  # ```ruby
-  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  # m.length   #=> 5
-  # m.size     #=> 5
-  # ```
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.length   #=> 5
+  #     m.size     #=> 5
+  #
   def size: () -> Integer
 
-  # Returns a frozen copy of the string passed in to `match` .
-  # 
-  # ```ruby
-  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  # m.string   #=> "THX1138."
-  # ```
+  # Returns a frozen copy of the string passed in to `match`.
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.string   #=> "THX1138."
+  #
   def string: () -> String
 
   # Returns the array of matches.
-  # 
-  # ```ruby
-  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  # m.to_a   #=> ["HX1138", "H", "X", "113", "8"]
-  # ```
-  # 
-  # Because `to_a` is called when expanding `*` *variable* , there’s a
-  # useful assignment shortcut for extracting matched fields. This is
-  # slightly slower than accessing the fields directly (as an intermediate
-  # array is generated).
-  # 
-  # ```ruby
-  # all,f1,f2,f3 = * /(.)(.)(\d+)(\d)/.match("THX1138.")
-  # all   #=> "HX1138"
-  # f1    #=> "H"
-  # f2    #=> "X"
-  # f3    #=> "113"
-  # ```
-  def to_a: () -> ::Array[String]
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.to_a   #=> ["HX1138", "H", "X", "113", "8"]
+  #
+  # Because `to_a` is called when expanding `*`*variable*, there's a useful
+  # assignment shortcut for extracting matched fields. This is slightly slower
+  # than accessing the fields directly (as an intermediate array is generated).
+  #
+  #     all,f1,f2,f3 = * /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     all   #=> "HX1138"
+  #     f1    #=> "H"
+  #     f2    #=> "X"
+  #     f3    #=> "113"
+  #
+  def to_a: () -> ::Array[String?]
 
   # Returns the entire matched string.
-  # 
-  # ```ruby
-  # m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-  # m.to_s   #=> "HX1138"
-  # ```
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  #     m.to_s   #=> "HX1138"
+  #
   def to_s: () -> String
 
-  def values_at: (*Integer | Symbol | String indexes) -> ::Array[String?]
+  # Uses each *index* to access the matching values, returning an array of the
+  # corresponding matches.
+  #
+  #     m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie")
+  #     m.to_a               #=> ["HX1138", "H", "X", "113", "8"]
+  #     m.values_at(0, 2, -2)   #=> ["HX1138", "X", "113"]
+  #
+  #     m = /(?<a>\d+) *(?<op>[+\-*\/]) *(?<b>\d+)/.match("1 + 2")
+  #     m.to_a               #=> ["1 + 2", "1", "+", "2"]
+  #     m.values_at(:a, :b, :op) #=> ["1", "2", "+"]
+  #
+  def values_at: (*Integer | Symbol | String n_or_name) -> ::Array[String?]
+
+  private
+
+  def initialize_copy: (self object) -> void
 end