solargraph 0.58.3 → 0.59.2

data/lib/solargraph/yard_map/helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   class YardMap
     module Helpers
@@ -5,7 +7,7 @@ module Solargraph
 
       # @param code_object [YARD::CodeObjects::Base]
       # @param spec [Gem::Specification, nil]
-      # @return [Solargraph::Location, nil]
+      # @return [Solargraph::Location]
       def object_location code_object, spec
         if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
           if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
@@ -14,6 +16,7 @@ module Solargraph
           end
           return Solargraph::Location.new(__FILE__, Solargraph::Range.from_to(__LINE__ - 1, 0, __LINE__ - 1, 0))
         end
+        # @sg-ignore flow sensitive typing should be able to identify more blocks that always return
         file = File.join(spec.full_gem_path, code_object.file)
         Solargraph::Location.new(file, Solargraph::Range.from_to(code_object.line - 1, 0, code_object.line - 1, 0))
       end
@@ -21,10 +24,12 @@ module Solargraph
       # @param code_object [YARD::CodeObjects::Base]
       # @param spec [Gem::Specification, nil]
       # @return [Solargraph::Pin::Namespace]
-      def create_closure_namespace_for(code_object, spec)
+      def create_closure_namespace_for code_object, spec
         code_object_for_location = code_object
         # code_object.namespace is sometimes a YARD proxy object pointing to a method path ("Object#new")
-        code_object_for_location = code_object.namespace if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+        if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+          code_object_for_location = code_object.namespace
+        end
         namespace_location = object_location(code_object_for_location, spec)
         ns_name = code_object.namespace.to_s
         if ns_name.empty?

data/lib/solargraph/yard_map/mapper/to_constant.rb

@@ -1,28 +1,28 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToConstant
-        extend YardMap::Helpers
-
-        # @param code_object [YARD::CodeObjects::Base]
-        # @param closure [Pin::Closure, nil]
-        # @param spec [Gem::Specification, nil]
-        # @return [Pin::Constant]
-        def self.make code_object, closure = nil, spec = nil
-          closure ||= create_closure_namespace_for(code_object, spec)
-
-          Pin::Constant.new(
-            location: object_location(code_object, spec),
-            closure: closure,
-            name: code_object.name.to_s,
-            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
-            visibility: code_object.visibility,
-            source: :yardoc
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToConstant
+        extend YardMap::Helpers
+
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param closure [Pin::Closure, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Pin::Constant]
+        def self.make code_object, closure = nil, spec = nil
+          closure ||= create_closure_namespace_for(code_object, spec)
+
+          Pin::Constant.new(
+            location: object_location(code_object, spec),
+            closure: closure,
+            name: code_object.name.to_s,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
+            visibility: code_object.visibility,
+            source: :yardoc
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -6,10 +6,11 @@ module Solargraph
       module ToMethod
         extend YardMap::Helpers
 
+        # @type [Hash{Array<String, Symbol, String> => Symbol}]
         VISIBILITY_OVERRIDE = {
           # YARD pays attention to 'private' statements prior to class methods but shouldn't
-          ["Rails::Engine", :class, "find_root_with_flag"] => :public
-        }
+          ['Rails::Engine', :class, 'find_root_with_flag'] => :public
+        }.freeze
 
         # @param code_object [YARD::CodeObjects::MethodObject]
         # @param name [String, nil]
@@ -25,10 +26,15 @@ module Solargraph
           return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
           final_scope = scope || code_object.scope
+          # @sg-ignore Need to add nil check here
           override_key = [closure.path, final_scope, name]
           final_visibility = VISIBILITY_OVERRIDE[override_key]
+          # @sg-ignore Need to add nil check here
           final_visibility ||= VISIBILITY_OVERRIDE[[closure.path, final_scope]]
-          final_visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
+          # @sg-ignore Need to add nil check here
+          if closure.path == 'Kernel' && Kernel.private_method_defined?(name.to_sym, false)
+            final_visibility ||= :private
+          end
           final_visibility ||= visibility
           final_visibility ||= :private if code_object.module_function? && final_scope == :instance
           final_visibility ||= :public if code_object.module_function? && final_scope == :class
@@ -46,9 +52,10 @@ module Solargraph
               explicit: code_object.is_explicit?,
               return_type: return_type,
               parameters: [],
-              source: :yardoc,
+              source: :yardoc
             )
           else
+            # @sg-ignore Need to add nil check here
             pin = Pin::Method.new(
               location: location,
               closure: closure,
@@ -61,7 +68,7 @@ module Solargraph
               return_type: return_type,
               attribute: code_object.is_attribute?,
               parameters: [],
-              source: :yardoc,
+              source: :yardoc
             )
             pin.parameters.concat get_parameters(code_object, location, comments, pin)
             pin.parameters.freeze
@@ -85,7 +92,6 @@ module Solargraph
             # HACK: Skip `nil` and `self` parameters that are sometimes emitted
             # for methods defined in C
             # See https://github.com/castwide/solargraph/issues/345
-            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
             code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
               Solargraph::Pin::Parameter.new(
                 location: location,
@@ -95,7 +101,7 @@ module Solargraph
                 presence: nil,
                 decl: arg_type(a),
                 asgn_code: a[1],
-                source: :yardoc,
+                source: :yardoc
               )
             end
           end

data/lib/solargraph/yard_map/mapper/to_namespace.rb

@@ -21,8 +21,9 @@ module Solargraph
             type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
             visibility: code_object.visibility,
             closure: closure,
+            # @sg-ignore need to add a nil check here
             gates: closure.gates,
-            source: :yardoc,
+            source: :yardoc
           )
         end
       end

data/lib/solargraph/yard_map/mapper.rb

@@ -24,6 +24,7 @@ module Solargraph
         end
         # Some yardocs contain documentation for dependencies that can be
         # ignored here. The YardMap will load dependencies separately.
+        # @sg-ignore Need to add nil check here
         @pins.keep_if { |pin| pin.location.nil? || File.file?(pin.location.filename) } if @spec
         @pins
       end
@@ -34,24 +35,27 @@ module Solargraph
       # @return [Array<Pin::Base>]
       def generate_pins code_object
         result = []
-        if code_object.is_a?(YARD::CodeObjects::NamespaceObject)
+        case code_object
+        when YARD::CodeObjects::NamespaceObject
           nspin = ToNamespace.make(code_object, @spec, @namespace_pins[code_object.namespace.to_s])
           @namespace_pins[code_object.path] = nspin
           result.push nspin
-          if code_object.is_a?(YARD::CodeObjects::ClassObject) and !code_object.superclass.nil?
+          if code_object.is_a?(YARD::CodeObjects::ClassObject) && !code_object.superclass.nil?
             # This method of superclass detection is a bit of a hack. If
             # the superclass is a Proxy, it is assumed to be undefined in its
             # yardoc and converted to a fully qualified namespace.
             superclass = if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
-              "::#{code_object.superclass}"
-            else
-              code_object.superclass.to_s
-            end
+                           "::#{code_object.superclass}"
+                         else
+                           code_object.superclass.to_s
+                         end
             result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin, source: :yard_map)
           end
+          # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
           code_object.class_mixins.each do |m|
             result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path, source: :yard_map)
           end
+          # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
           code_object.instance_mixins.each do |m|
             result.push Solargraph::Pin::Reference::Include.new(
               closure: nspin, # @todo Fix this
@@ -59,8 +63,9 @@ module Solargraph
               source: :yard_map
             )
           end
-        elsif code_object.is_a?(YARD::CodeObjects::MethodObject)
+        when YARD::CodeObjects::MethodObject
           closure = @namespace_pins[code_object.namespace.to_s]
+          # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
           if code_object.name == :initialize && code_object.scope == :instance
             # @todo Check the visibility of <Class>.new
             result.push ToMethod.make(code_object, 'new', :class, :public, closure, @spec)
@@ -68,7 +73,7 @@ module Solargraph
           else
             result.push ToMethod.make(code_object, nil, nil, nil, closure, @spec)
           end
-        elsif code_object.is_a?(YARD::CodeObjects::ConstantObject)
+        when YARD::CodeObjects::ConstantObject
           closure = @namespace_pins[code_object.namespace]
           result.push ToConstant.make(code_object, closure, @spec)
         end

data/lib/solargraph/yard_map.rb

@@ -1,18 +1,17 @@
-# frozen_string_literal: true
-
-require 'yard'
-require 'solargraph/yard_tags'
-
-module Solargraph
-  # The YardMap provides access to YARD documentation for the Ruby core, the
-  # stdlib, and gems.
-  #
-  class YardMap
-    class NoYardocError < StandardError; end
-
-    autoload :Cache,       'solargraph/yard_map/cache'
-    autoload :Mapper,      'solargraph/yard_map/mapper'
-    autoload :Helpers,     'solargraph/yard_map/helpers'
-    autoload :ToMethod,    'solargraph/yard_map/to_method'
-  end
-end
+# frozen_string_literal: true
+
+require 'yard'
+require 'solargraph/yard_tags'
+
+module Solargraph
+  # The YardMap provides access to YARD documentation for the Ruby core, the
+  # stdlib, and gems.
+  #
+  class YardMap
+    class NoYardocError < StandardError; end
+
+    autoload :Cache,       'solargraph/yard_map/cache'
+    autoload :Mapper,      'solargraph/yard_map/mapper'
+    autoload :Helpers,     'solargraph/yard_map/helpers'
+  end
+end

data/lib/solargraph/yard_tags.rb

@@ -14,7 +14,7 @@ module Solargraph
 end
 
 # Define a @type tag for documenting variables
-YARD::Tags::Library.define_tag("Type", :type, :with_types_and_name)
+YARD::Tags::Library.define_tag('Type', :type, :with_types_and_name)
 
 # Define an @!override directive for overriding method tags
-YARD::Tags::Library.define_directive("override", :with_name, Solargraph::DomainDirective)
+YARD::Tags::Library.define_directive('override', :with_name, Solargraph::DomainDirective)

data/lib/solargraph/yardoc.rb

@@ -14,7 +14,7 @@ module Solargraph
     # @param yard_plugins [Array<String>] The names of YARD plugins to use.
     # @param gemspec [Gem::Specification]
     # @return [String] The path to the cached yardoc.
-    def cache(yard_plugins, gemspec)
+    def cache yard_plugins, gemspec
       path = PinCache.yardoc_path gemspec
       return path if cached?(gemspec)
 
@@ -32,6 +32,8 @@ module Solargraph
       yard_plugins.each { |plugin| cmd << " --plugin #{plugin}" }
       Solargraph.logger.debug { "Running: #{cmd}" }
       # @todo set these up to run in parallel
+      # @todo Is the chdir argument being used here?
+      # @sg-ignore Unrecognized keyword argument chdir to Open3.capture2e
       stdout_and_stderr_str, status = Open3.capture2e(current_bundle_env_tweaks, cmd, chdir: gemspec.gem_dir)
       unless status.success?
         Solargraph.logger.warn { "YARD failed running #{cmd.inspect} in #{gemspec.gem_dir}" }
@@ -43,7 +45,7 @@ module Solargraph
     # True if the gem yardoc is cached.
     #
     # @param gemspec [Gem::Specification]
-    def cached?(gemspec)
+    def cached? gemspec
       yardoc = File.join(PinCache.yardoc_path(gemspec), 'complete')
       File.exist?(yardoc)
     end
@@ -51,7 +53,7 @@ module Solargraph
     # True if another process is currently building the yardoc cache.
     #
     # @param gemspec [Gem::Specification]
-    def processing?(gemspec)
+    def processing? gemspec
       yardoc = File.join(PinCache.yardoc_path(gemspec), 'processing')
       File.exist?(yardoc)
     end
@@ -62,7 +64,7 @@ module Solargraph
     #
     # @param gemspec [Gem::Specification]
     # @return [Array<YARD::CodeObjects::Base>]
-    def load!(gemspec)
+    def load! gemspec
       YARD::Registry.load! PinCache.yardoc_path gemspec
       YARD::Registry.all
     end
@@ -78,6 +80,7 @@ module Solargraph
     # @return [Hash{String => String}] a hash of environment variables to override
     def current_bundle_env_tweaks
       tweaks = {}
+      # @sg-ignore Unresolved call to empty? on String, nil
       if ENV['BUNDLE_GEMFILE'] && !ENV['BUNDLE_GEMFILE'].empty?
         tweaks['BUNDLE_GEMFILE'] = File.expand_path(ENV['BUNDLE_GEMFILE'])
       end

data/lib/solargraph.rb

@@ -55,8 +55,8 @@ module Solargraph
 
   CHDIR_MUTEX = Mutex.new
 
-  # @param type [Symbol] Type of assert.
-  def self.asserts_on?(type)
+  def self.asserts_on?
+    # @sg-ignore Translate to something flow sensitive typing understands
     if ENV['SOLARGRAPH_ASSERTS'].nil? || ENV['SOLARGRAPH_ASSERTS'].empty?
       false
     elsif ENV['SOLARGRAPH_ASSERTS'] == 'on'
@@ -71,8 +71,31 @@ module Solargraph
   # @param msg [String, nil] An optional message to log
   # @param block [Proc] A block that returns a message to log
   # @return [void]
-  def self.assert_or_log(type, msg = nil, &block)
-    raise (msg || block.call) if asserts_on?(type) && ![:combine_with_visibility].include?(type)
+  def self.assert_or_log type, msg = nil, &block
+    if asserts_on?
+      # @type [String, nil]
+      msg ||= block.call
+
+      raise "No message given for #{type.inspect}" if msg.nil?
+
+      # conditional aliases to handle compatibility corner cases
+      # @sg-ignore flow sensitive typing needs to handle 'raise if'
+      return if type == :alias_target_missing && msg.include?('highline/compatibility.rb')
+      # @sg-ignore flow sensitive typing needs to handle 'raise if'
+      return if type == :alias_target_missing && msg.include?('lib/json/add/date.rb')
+      # @sg-ignore flow sensitive typing needs to handle 'raise if'
+      return if type == :alias_target_missing && msg.include?('rubocop-ast.rbs')
+      # @todo :combine_with_visibility is not ready for prime time -
+      #  lots of disagreements found in practice that heuristics need
+      #  to be created for and/or debugging needs to resolve in pin
+      #  generation.
+      # @todo :api_map_namespace_pin_stack triggers in a badly handled
+      #   self type case - 'keeps track of self type in method
+      #   parameters in subclass' in call_spec.rb
+      return if %i[api_map_namespace_pin_stack combine_with_visibility].include?(type)
+
+      raise msg
+    end
     logger.info msg, &block
   end
 
@@ -90,13 +113,13 @@ module Solargraph
   # @yieldreturn [generic<T>]
   # @sg-ignore dynamic call, but both functions behave the same
   # @return [generic<T>]
-  def self.with_clean_env &block
+  def self.with_clean_env(&)
     meth = if Bundler.respond_to?(:with_original_env)
-      :with_original_env
-    else
-      :with_clean_env
-    end
-    Bundler.send meth, &block
+             :with_original_env
+           else
+             :with_clean_env
+           end
+    Bundler.send(meth, &)
   end
 end
 

data/rbs/fills/rubygems/0/dependency.rbs

@@ -0,0 +1,193 @@
+# <!-- rdoc-file=lib/rubygems/dependency.rb -->
+# The Dependency class holds a Gem name and a Gem::Requirement.
+#
+class Gem::Dependency
+  @name: untyped
+
+  @requirement: untyped
+
+  @type: untyped
+
+  @prerelease: untyped
+
+  @version_requirements: untyped
+
+  @version_requirement: untyped
+
+  # <!-- rdoc-file=lib/rubygems/dependency.rb -->
+  # Valid dependency types.
+  #
+  TYPES: ::Array[:development | :runtime]
+
+  # <!-- rdoc-file=lib/rubygems/dependency.rb -->
+  # Dependency name or regular expression.
+  #
+  attr_accessor name: untyped
+
+  # <!-- rdoc-file=lib/rubygems/dependency.rb -->
+  # Allows you to force this dependency to be a prerelease.
+  #
+  attr_writer prerelease: untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - new(name, *requirements)
+  # -->
+  # Constructs a dependency with `name` and `requirements`. The last argument can
+  # optionally be the dependency type, which defaults to `:runtime`.
+  #
+  def initialize: (untyped name, *untyped requirements) -> void
+
+  def hash: () -> untyped
+
+  def inspect: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - prerelease?()
+  # -->
+  # Does this dependency require a prerelease?
+  #
+  def prerelease?: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - latest_version?()
+  # -->
+  # Is this dependency simply asking for the latest version of a gem?
+  #
+  def latest_version?: () -> untyped
+
+  def pretty_print: (untyped q) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - requirement()
+  # -->
+  # What does this dependency require?
+  #
+  def requirement: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - requirements_list()
+  # -->
+  #
+  def requirements_list: () -> untyped
+
+  def to_s: () -> ::String
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - type()
+  # -->
+  # Dependency type.
+  #
+  def type: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - runtime?()
+  # -->
+  #
+  def runtime?: () -> untyped
+
+  def ==: (untyped other) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - <=>(other)
+  # -->
+  # Dependencies are ordered by name.
+  #
+  def <=>: (untyped other) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - =~(other)
+  # -->
+  # Uses this dependency as a pattern to compare to `other`. This dependency will
+  # match if the name matches the other's name, and other has only an equal
+  # version requirement that satisfies this dependency.
+  #
+  def =~: (untyped other) -> (nil | false | untyped)
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - ===(other)
+  # -->
+  #
+  alias === =~
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - dep.match? name          => true or false
+  #   - dep.match? name, version => true or false
+  #   - dep.match? spec          => true or false
+  # -->
+  # Does this dependency match the specification described by `name` and `version`
+  # or match `spec`?
+  #
+  # NOTE:  Unlike #matches_spec? this method does not return true when the version
+  # is a prerelease version unless this is a prerelease dependency.
+  #
+  def match?: (untyped obj, ?untyped? version, ?bool allow_prerelease) -> (false | true | untyped)
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - matches_spec?(spec)
+  # -->
+  # Does this dependency match `spec`?
+  #
+  # NOTE:  This is not a convenience method.  Unlike #match? this method returns
+  # true when `spec` is a prerelease version even if this dependency is not a
+  # prerelease dependency.
+  #
+  def matches_spec?: (untyped spec) -> (false | true | untyped)
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - merge(other)
+  # -->
+  # Merges the requirements of `other` into this dependency
+  #
+  def merge: (untyped other) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - matching_specs(platform_only = false)
+  # -->
+  #
+  def matching_specs: (?bool platform_only) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - specific?()
+  # -->
+  # True if the dependency will not always match the latest version.
+  #
+  def specific?: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - to_specs()
+  # -->
+  #
+  def to_specs: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - to_spec()
+  # -->
+  #
+  def to_spec: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/rubygems/dependency.rb
+  #   - identity()
+  # -->
+  #
+  def identity: () -> (:complete | :abs_latest | :latest | :released)
+
+  def encode_with: (untyped coder) -> untyped
+end

data/rbs/shims/ast/0/node.rbs

@@ -1,5 +1,5 @@
 module ::AST
   class Node
-     def children: () -> [self, Integer, String, Symbol, nil]
+     def children: () -> Array[self | Integer | String | Symbol | nil]
   end
 end

data/rbs/shims/diff-lcs/1.5/diff-lcs.rbs

@@ -0,0 +1,11 @@
+module Diff
+end
+
+module Diff::LCS
+  def self.LCS: (Array[String], Array[String]) -> Array[String]
+              | (String, String) -> Array[String]
+  def self.diff: (Array[String], Array[String]) -> Array[Array[String]]
+              | (String, String) -> Array[Array[Diff::LCS::Change]]
+
+  def self.patch!: (Array[String], Array[String]) -> String
+end