solargraph 0.54.4 → 0.57.0

data/rbs/fills/tuple.rbs

@@ -0,0 +1,149 @@
+# <-- liberally borrowed from
+#     https://github.com/ruby/rbs/blob/master/core/array.rbs, which
+#     was generated from
+#     https://github.com/ruby/ruby/blob/master/array.c
+#     -->
+module Solargraph
+  module Fills
+    class Tuple[unchecked out A,
+                unchecked out B = A,
+                unchecked out C = A | B,
+                unchecked out D = A | B | C,
+                unchecked out E = A | B | C | D,
+                unchecked out F = A | B | C | D | E,
+                unchecked out G = A | B | C | D | E | F,
+                unchecked out H = A | B | C | D | E | F | G,
+                unchecked out I = A | B | C | D | E | F | G | H,
+                unchecked out J = A | B | C | D | E | F | G | H | I] < Array[A | B | C | D | E | F | G | H | I | J]
+      # <!--
+      #   rdoc-file=array.c
+      #   - self[index] -> object or nil
+      # -->
+      # Returns elements from `self`; does not modify `self`.
+      #
+      # In brief:
+      #
+      #     a = [:foo, 'bar', 2]
+      #
+      #     # Single argument index: returns one element.
+      #     a[0]     # => :foo          # Zero-based index.
+      #
+      # When a single integer argument `index` is given, returns the element at offset
+      # `index`:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a[0] # => :foo
+      #     a[2] # => 2
+      #     a # => [:foo, "bar", 2]
+      def []: (0 index) -> A
+            | (1 index) -> B
+            | (2 index) -> C
+            | (3 index) -> D
+            | (4 index) -> E
+            | (5 index) -> F
+            | (6 index) -> G
+            | (7 index) -> H
+            | (8 index) -> I
+            | (9 index) -> J
+            | (int index) -> nil
+
+      # <!--
+      #   rdoc-file=array.c
+      #   - at(index) -> object or nil
+      # -->
+      # Returns the element of `self` specified by the given `index` or `nil` if there
+      # is no such element; `index` must be an [integer-convertible
+      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
+      #
+      # For non-negative `index`, returns the element of `self` at offset `index`:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.at(0)   # => :foo
+      #     a.at(2)   # => 2
+      #     a.at(2.0) # => 2
+      #
+      # Related: Array#[]; see also [Methods for
+      # Fetching](rdoc-ref:Array@Methods+for+Fetching).
+      #
+      def at: (0 index) -> A
+            | (1 index) -> B
+            | (2 index) -> C
+            | (3 index) -> D
+            | (4 index) -> E
+            | (5 index) -> F
+            | (6 index) -> G
+            | (7 index) -> H
+            | (8 index) -> I
+            | (9 index) -> J
+            | (int index) -> nil
+
+      # <!--
+      #   rdoc-file=array.c
+      #   - fetch(index) -> element
+      #   - fetch(index, default_value) -> element or default_value
+      #   - fetch(index) {|index| ... } -> element or block_return_value
+      # -->
+      # Returns the element of `self` at offset `index` if `index` is in range;
+      # `index` must be an [integer-convertible
+      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
+      #
+      # With the single argument `index` and no block, returns the element at offset
+      # `index`:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.fetch(1)   # => "bar"
+      #     a.fetch(1.1) # => "bar"
+      #
+      # With arguments `index` and `default_value` (which may be any object) and no
+      # block, returns `default_value` if `index` is out-of-range:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.fetch(1, nil)  # => "bar"
+      #     a.fetch(3, :foo) # => :foo
+      #
+      # With argument `index` and a block, returns the element at offset `index` if
+      # index is in range (and the block is not called); otherwise calls the block
+      # with index and returns its return value:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.fetch(1) {|index| raise 'Cannot happen' } # => "bar"
+      #     a.fetch(50) {|index| "Value for #{index}" } # => "Value for 50"
+      #
+      # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
+      #
+      def fetch: (0 index) -> A
+               | (1 index) -> B
+               | (2 index) -> C
+               | (3 index) -> D
+               | (4 index) -> E
+               | (5 index) -> F
+               | (6 index) -> G
+               | (7 index) -> H
+               | (8 index) -> I
+               | (9 index) -> J
+               | (int index) -> void
+               | [T] (0 index, T default) -> (A | T)
+               | [T] (1 index, T default) -> (B | T)
+               | [T] (2 index, T default) -> (C | T)
+               | [T] (3 index, T default) -> (D | T)
+               | [T] (4 index, T default) -> (E | T)
+               | [T] (5 index, T default) -> (F | T)
+               | [T] (6 index, T default) -> (G | T)
+               | [T] (7 index, T default) -> (H | T)
+               | [T] (8 index, T default) -> (I | T)
+               | [T] (9 index, T default) -> (J | T)
+               | [T] (int index, T default) -> (A | B | C | D | E | F | G | H | I | J | T)
+               | [T] (0 index) { (int index) -> T } -> (A | T)
+               | [T] (1 index) { (int index) -> T } -> (B | T)
+               | [T] (2 index) { (int index) -> T } -> (C | T)
+               | [T] (3 index) { (int index) -> T } -> (D | T)
+               | [T] (4 index) { (int index) -> T } -> (E | T)
+               | [T] (5 index) { (int index) -> T } -> (F | T)
+               | [T] (6 index) { (int index) -> T } -> (G | T)
+               | [T] (7 index) { (int index) -> T } -> (H | T)
+               | [T] (8 index) { (int index) -> T } -> (I | T)
+               | [T] (9 index) { (int index) -> T } -> (J | T)
+               | [T] (int index) { (int index) -> T } -> (A | B | C | D | E | F | G | H | I | J | T)
+    end
+  end
+end

data/rbs_collection.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+# gems:
+#   # If you want to avoid installing rbs files for gems, you can specify them here.
+#   - name: GEM_NAME
+#     ignore: true

data/sig/shims/parser/3.2.0.1/builders/default.rbs

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Parser
+  ##
+  # Default AST builder. Uses {AST::Node}s.
+  #
+  module Builders
+    class Default
+      ##
+      # AST compatibility attribute; since `-> {}` is not semantically
+      # equivalent to `lambda {}`, all new code should set this attribute
+      # to true.
+      #
+      # If set to false (the default), `-> {}` is emitted as
+      # `s(:block, s(:send, nil, :lambda), s(:args), nil)`.
+      #
+      # If set to true, `-> {}` is emitted as
+      # `s(:block, s(:lambda), s(:args), nil)`.
+      #
+      # @return [Boolean]
+      attr_accessor self.emit_lambda: bool
+
+      ##
+      # AST compatibility attribute; block arguments of `m { |a| }` are
+      # not semantically equivalent to block arguments of `m { |a,| }` or `m { |a, b| }`,
+      # all new code should set this attribute to true.
+      #
+      # If set to false (the default), arguments of `m { |a| }` are emitted as
+      # `s(:args, s(:arg, :a))`.
+      #
+      # If set to true, arguments of `m { |a| }` are emitted as
+      # `s(:args, s(:procarg0, :a)).
+      #
+      # @return [Boolean]
+      attr_accessor self.emit_procarg0: bool
+
+      ##
+      # AST compatibility attribute; locations of `__ENCODING__` are not the same
+      # as locations of `Encoding::UTF_8` causing problems during rewriting,
+      # all new code should set this attribute to true.
+      #
+      # If set to false (the default), `__ENCODING__` is emitted as
+      # ` s(:const, s(:const, nil, :Encoding), :UTF_8)`.
+      #
+      # If set to true, `__ENCODING__` is emitted as
+      # `s(:__ENCODING__)`.
+      #
+      # @return [Boolean]
+      attr_accessor self.emit_encoding: bool
+
+      ##
+      # AST compatibility attribute; indexed assignment, `x[] = 1`, is not
+      # semantically equivalent to calling the method directly, `x.[]=(1)`.
+      # Specifically, in the former case, the expression's value is always 1,
+      # and in the latter case, the expression's value is the return value
+      # of the `[]=` method.
+      #
+      # If set to false (the default), `self[1]` is emitted as
+      # `s(:send, s(:self), :[], s(:int, 1))`, and `self[1] = 2` is
+      # emitted as `s(:send, s(:self), :[]=, s(:int, 1), s(:int, 2))`.
+      #
+      # If set to true, `self[1]` is emitted as
+      # `s(:index, s(:self), s(:int, 1))`, and `self[1] = 2` is
+      # emitted as `s(:indexasgn, s(:self), s(:int, 1), s(:int, 2))`.
+      #
+      # @return [Boolean]
+      attr_accessor self.emit_index: bool
+
+      ##
+      # AST compatibility attribute; causes a single non-mlhs
+      # block argument to be wrapped in s(:procarg0).
+      #
+      # If set to false (the default), block arguments `|a|` are emitted as
+      # `s(:args, s(:procarg0, :a))`
+      #
+      # If set to true, block arguments `|a|` are emitted as
+      # `s(:args, s(:procarg0, s(:arg, :a))`
+      #
+      # @return [Boolean]
+      attr_accessor self.emit_arg_inside_procarg0: bool
+
+      ##
+      # AST compatibility attribute; arguments forwarding initially
+      # didn't have support for leading arguments
+      # (i.e. `def m(a, ...); end` was a syntax error). However, Ruby 3.0
+      # added support for any number of arguments in front of the `...`.
+      #
+      # If set to false (the default):
+      #   1. `def m(...) end` is emitted as
+      #      s(:def, :m, s(:forward_args), nil)
+      #   2. `def m(a, b, ...) end` is emitted as
+      #      s(:def, :m,
+      #        s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg)))
+      #
+      # If set to true it uses a single format:
+      #   1. `def m(...) end` is emitted as
+      #      s(:def, :m, s(:args, s(:forward_arg)))
+      #   2. `def m(a, b, ...) end` is emitted as
+      #      s(:def, :m, s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg)))
+      #
+      # It does't matter that much on 2.7 (because there can't be any leading arguments),
+      # but on 3.0 it should be better enabled to use a single AST format.
+      #
+      # @return [Boolean]
+      attr_accessor self.emit_forward_arg: bool
+
+      ##
+      # AST compatibility attribute; Starting from Ruby 2.7 keyword arguments
+      # of method calls that are passed explicitly as a hash (i.e. with curly braces)
+      # are treated as positional arguments and Ruby 2.7 emits a warning on such method
+      # call. Ruby 3.0 given an ArgumentError.
+      #
+      # If set to false (the default) the last hash argument is emitted as `hash`:
+      #
+      # ```
+      # (send nil :foo
+      #   (hash
+      #     (pair
+      #       (sym :bar)
+      #       (int 42))))
+      # ```
+      #
+      # If set to true it is emitted as `kwargs`:
+      #
+      # ```
+      # (send nil :foo
+      #   (kwargs
+      #     (pair
+      #       (sym :bar)
+      #       (int 42))))
+      # ```
+      #
+      # Note that `kwargs` node is just a replacement for `hash` argument,
+      # so if there's are multiple arguments (or a `kwsplat`) all of them
+      # are wrapped into `kwargs` instead of `hash`:
+      #
+      # ```
+      # (send nil :foo
+      #   (kwargs
+      #     (pair
+      #       (sym :a)
+      #       (int 42))
+      #     (kwsplat
+      #       (send nil :b))
+      #     (pair
+      #       (sym :c)
+      #       (int 10))))
+      # ```
+      attr_accessor self.emit_kwargs: bool
+
+      ##
+      # AST compatibility attribute; Starting from 3.0 Ruby returns
+      # true/false from single-line pattern matching with `in` keyword.
+      #
+      # Before 3.0 there was an exception if given value doesn't match pattern.
+      #
+      # NOTE: This attribute affects only Ruby 2.7 grammar.
+      # 3.0 grammar always emits `match_pattern`/`match_pattern_p`
+      #
+      # If compatibility attribute set to false `foo in bar` is emitted as `in_match`:
+      #
+      # ```
+      # (in-match
+      #   (send nil :foo)
+      #   (match-var :bar))
+      # ```
+      #
+      # If set to true it's emitted as `match_pattern_p`:
+      # ```
+      # (match-pattern-p
+      #   (send nil :foo)
+      #   (match-var :bar))
+      # ```
+      attr_accessor self.emit_match_pattern: bool
+
+      ##
+      # If set to true (the default), `__FILE__` and `__LINE__` are transformed to
+      # literal nodes. For example, `s(:str, "lib/foo.rb")` and `s(:int, 10)`.
+      #
+      # If set to false, `__FILE__` and `__LINE__` are emitted as-is,
+      # i.e. as `s(:__FILE__)` and `s(:__LINE__)` nodes.
+      #
+      # Source maps are identical in both cases.
+      #
+      # @return [Boolean]
+      attr_accessor emit_file_line_as_literals: bool
+
+      def value: (untyped token) -> untyped
+
+      def string_value: (untyped token) -> String
+
+      def loc: (untyped token) -> untyped
+    end
+  end
+end

data/sig/shims/thor/1.2.0.1/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: thor
+version: '1.2'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 98541aabafdf403b16ebae6fe4060d18bee75e93
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/sig/shims/thor/1.2.0.1/manifest.yaml

@@ -0,0 +1,7 @@
+# manifest.yaml describes dependencies which do not appear in the gemspec.
+# If this gem includes such dependencies, comment-out the following lines and
+# declare the dependencies.
+# If all dependencies appear in the gemspec, you should remove this file.
+#
+# dependencies:
+#   - name: pathname

data/sig/shims/thor/1.2.0.1/thor.rbs

@@ -0,0 +1,17 @@
+class Thor
+  class Group
+  end
+
+  module Actions
+    class CreateFile
+    end
+
+    def create_file: (String destination, String data, ?verbose: bool) -> String
+                   | (String destination, ?verbose: bool) { () -> String } -> String
+  end
+
+  class Error
+  end
+
+  def self.start: (Array[String] given_args, ?Hash[Symbol, untyped] config) -> void
+end

data/solargraph.gemspec

@@ -11,7 +11,10 @@ Gem::Specification.new do |s|
   s.authors     = ["Fred Snyder"]
   s.email       = 'admin@castwide.com'
   s.files       = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    # @sg-ignore Need backtick support
+    # @type [String]
+    all_files = `git ls-files -z`
+    all_files.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   s.homepage    = 'https://solargraph.org'
   s.license     = 'MIT'
@@ -34,19 +37,27 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'observer', '~> 0.1'
   s.add_runtime_dependency 'ostruct', '~> 0.6'
   s.add_runtime_dependency 'parser', '~> 3.0'
-  s.add_runtime_dependency 'rbs', '~> 3.3'
+  s.add_runtime_dependency 'prism', '~> 1.4'
+  s.add_runtime_dependency 'rbs', ['>= 3.6.1', '<= 4.0.0.dev.4']
   s.add_runtime_dependency 'reverse_markdown', '~> 3.0'
-  s.add_runtime_dependency 'rubocop', '~> 1.38'
+  s.add_runtime_dependency 'rubocop', '~> 1.76'
   s.add_runtime_dependency 'thor', '~> 1.0'
   s.add_runtime_dependency 'tilt', '~> 2.0'
   s.add_runtime_dependency 'yard', '~> 0.9', '>= 0.9.24'
   s.add_runtime_dependency 'yard-solargraph', '~> 0.1'
+  s.add_runtime_dependency 'yard-activesupport-concern', '~> 0.0'
 
   s.add_development_dependency 'pry', '~> 0.15'
   s.add_development_dependency 'public_suffix', '~> 3.1'
   s.add_development_dependency 'rake', '~> 13.2'
   s.add_development_dependency 'rspec', '~> 3.5'
-  s.add_development_dependency 'simplecov', '~> 0.14'
+  s.add_development_dependency 'rubocop-rake', '~> 0.7'
+  s.add_development_dependency 'rubocop-rspec', '~> 3.6'
+  s.add_development_dependency 'rubocop-yard', '~> 1.0'
+  s.add_development_dependency 'simplecov', '~> 0.21'
+  s.add_development_dependency 'simplecov-lcov', '~> 0.8'
+  s.add_development_dependency 'undercover', '~> 0.7'
+  s.add_development_dependency 'overcommit', '~> 0.68.0'
   s.add_development_dependency 'webmock', '~> 3.6'
   # work around missing yard dependency needed as of Ruby 3.5
   s.add_development_dependency 'irb', '~> 1.15'