solargraph 0.58.2 → 0.59.0.dev.1

data/lib/solargraph/workspace/gemspecs.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+
+module Solargraph
+  class Workspace
+    # Manages determining which gemspecs are available in a workspace
+    class Gemspecs
+      include Logging
+
+      attr_reader :directory, :preferences
+
+      # @param directory [String, nil] If nil, assume no bundle is present
+      # @param preferences [Array<Gem::Specification>]
+      def initialize directory, preferences: []
+        # @todo an issue with both external bundles and the potential
+        #   preferences feature is that bundler gives you a 'clean'
+        #   rubygems environment with only the specified versions
+        #   installed.  Possible alternatives:
+        #
+        #   *) prompt the user to run solargraph outside of bundler
+        #      and treat all bundles as external
+        #   *) reinstall the needed gems dynamically each time
+        #   *) manipulate the rubygems/bundler environment
+        @directory = directory && File.absolute_path(directory)
+        # @todo implement preferences as a config-exposed feature
+        @preferences = preferences
+      end
+
+      # Take the path given to a 'require' statement in a source file
+      # and return the Gem::Specifications which will be brought into
+      # scope with it, so we can load pins for them.
+      #
+      # @param require [String] The string sent to 'require' in the code to resolve, e.g. 'rails', 'bundler/require'
+      # @return [::Array<Gem::Specification>, nil]
+      def resolve_require require
+        return nil if require.empty?
+
+        # This is added in the parser when it sees 'Bundler.require' -
+        # see https://bundler.io/guides/bundler_setup.html '
+        #
+        # @todo handle different arguments to Bundler.require
+        return auto_required_gemspecs_from_bundler if require == 'bundler/require'
+
+        # Determine gem name based on the require path
+        file = "lib/#{require}.rb"
+        spec_with_path = Gem::Specification.find_by_path(file)
+
+        all_gemspecs = all_gemspecs_from_bundle
+
+        gem_names_to_try = [
+          spec_with_path&.name,
+          require.tr('/', '-'),
+          require.split('/').first
+        ].compact.uniq
+        # @param gem_name [String]
+        gem_names_to_try.each do |gem_name|
+          # @sg-ignore Unresolved call to == on Boolean
+          gemspec = all_gemspecs.find { |gemspec| gemspec.name == gem_name }
+          # @sg-ignore flow sensitive typing should be able to handle redefinition
+          return [gemspec_or_preference(gemspec)] if gemspec
+
+          begin
+            gemspec = Gem::Specification.find_by_name(gem_name)
+            # @sg-ignore flow sensitive typing should be able to handle redefinition
+            return [gemspec_or_preference(gemspec)] if gemspec
+          rescue Gem::MissingSpecError
+            logger.debug do
+              "Require path #{require} could not be resolved to a gem via find_by_path or guess of #{gem_name}"
+            end
+          end
+
+          # look ourselves just in case this is hanging out somewhere
+          # that find_by_path doesn't index
+          gemspec = all_gemspecs.find do |spec|
+            spec = to_gem_specification(spec) unless spec.respond_to?(:files)
+
+            # @sg-ignore Translate to something flow sensitive typing understands
+            spec&.files&.any? { |gemspec_file| file == gemspec_file }
+          end
+          # @sg-ignore flow sensitive typing should be able to handle redefinition
+          return [gemspec_or_preference(gemspec)] if gemspec
+        end
+
+        nil
+      end
+
+      # @param stdlib_name [String]
+      #
+      # @return [Array<String>]
+      def stdlib_dependencies stdlib_name
+        deps = RbsMap::StdlibMap.stdlib_dependencies(stdlib_name, nil) || []
+        deps.map { |dep| dep['name'] }.compact
+      end
+
+      # @param name [String]
+      # @param version [String, nil]
+      # @param out [IO, nil] output stream for logging
+      #
+      # @return [Gem::Specification, nil]
+      def find_gem name, version = nil, out: $stderr
+        # @sg-ignore flow sensitive typing should be able to handle redefinition
+        specish = all_gemspecs_from_bundle.find { |specish| specish.name == name && specish.version == version }
+        return to_gem_specification specish if specish
+
+        # @sg-ignore flow sensitive typing should be able to handle redefinition
+        specish = all_gemspecs_from_bundle.find { |specish| specish.name == name }
+        # @sg-ignore flow sensitive typing needs to create separate ranges for postfix if
+        return to_gem_specification specish if specish
+
+        resolve_gem_ignoring_local_bundle name, version, out: out
+      end
+
+      # @param gemspec [Gem::Specification]
+      # @param out[IO, nil] output stream for logging
+      #
+      # @return [Array<Gem::Specification>]
+      def fetch_dependencies gemspec, out: $stderr
+        gemspecs = all_gemspecs_from_bundle
+
+        # @type [Hash{String => Gem::Specification}]
+        deps_so_far = {}
+
+        # @param runtime_dep [Gem::Dependency]
+        # @param deps [Hash{String => Gem::Specification}]
+        gem_dep_gemspecs = only_runtime_dependencies(gemspec).each_with_object(deps_so_far) do |runtime_dep, deps|
+          dep = find_gem(runtime_dep.name, runtime_dep.requirement)
+          next unless dep
+
+          fetch_dependencies(dep, out: out).each { |sub_dep| deps[sub_dep.name] ||= sub_dep }
+
+          deps[dep.name] ||= dep
+        end
+
+        # RBS tracks implicit dependencies, like how the YAML standard
+        # library implies pulling in the psych library.
+        stdlib_deps = RbsMap::StdlibMap.stdlib_dependencies(gemspec.name, gemspec.version) || []
+        stdlib_dep_gemspecs = stdlib_deps.map { |dep| find_gem(dep['name'], dep['version']) }.compact
+        (gem_dep_gemspecs.values.compact + stdlib_dep_gemspecs).uniq(&:name)
+      end
+
+      # Returns all gemspecs directly depended on by this workspace's
+      # bundle (does not include transitive dependencies).
+      #
+      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
+      def all_gemspecs_from_bundle
+        return [] unless directory
+
+        @all_gemspecs_from_bundle ||=
+          if in_this_bundle?
+            all_gemspecs_from_this_bundle
+          else
+            all_gemspecs_from_external_bundle
+          end
+      end
+
+      # @return [Hash{Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification => Gem::Specification}]
+      def self.gem_specification_cache
+        @gem_specification_cache ||= {}
+      end
+
+      private
+
+      # @param specish [Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification]
+      #
+      # @return [Gem::Specification, nil]
+      # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
+      def to_gem_specification specish
+        # print time including milliseconds
+        self.class.gem_specification_cache[specish] ||= case specish
+                                                        when Gem::Specification
+                                                          specish
+                                                        when Bundler::LazySpecification
+                                                          # materializing didn't work.  Let's look in the local
+                                                          # rubygems without bundler's help
+                                                          resolve_gem_ignoring_local_bundle specish.name,
+                                                                                            specish.version
+                                                        when Bundler::StubSpecification
+                                                          # turns a Bundler::StubSpecification into a
+                                                          # Gem::StubSpecification if we can
+                                                          if specish.respond_to?(:stub)
+                                                            # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
+                                                            to_gem_specification specish.stub
+                                                          else
+                                                            # A Bundler::StubSpecification is a Bundler::
+                                                            # RemoteSpecification which ought to proxy a Gem::
+                                                            # Specification
+                                                            specish
+                                                          end
+                                                        # @sg-ignore Unresolved constant Gem::StubSpecification
+                                                        when Gem::StubSpecification
+                                                          # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
+                                                          specish.to_spec
+                                                        else
+                                                          raise "Unexpected type while resolving gem: #{specish.class}"
+                                                        end
+      end
+
+      # @param command [String] The expression to evaluate in the external bundle
+      # @sg-ignore Need a JSON type
+      # @yield [undefined, nil]
+      def query_external_bundle command
+        Solargraph.with_clean_env do
+          cmd = [
+            'ruby', '-e',
+            "require 'bundler'; require 'json'; Dir.chdir('#{directory}') { puts begin; #{command}; end.to_json }"
+          ]
+          o, e, s = Open3.capture3(*cmd)
+          if s.success?
+            Solargraph.logger.debug "External bundle: #{o}"
+            o && !o.empty? ? JSON.parse(o.split("\n").last) : nil
+          else
+            Solargraph.logger.warn e
+            raise BundleNotFoundError, "Failed to load gems from bundle at #{directory}"
+          end
+        end
+      end
+
+      # @sg-ignore need boolish support for ? methods
+      def in_this_bundle?
+        Bundler.definition&.lockfile&.to_s&.start_with?(directory)
+      end
+
+      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
+      def all_gemspecs_from_this_bundle
+        # Find only the gems bundler is now using
+        specish_objects = Bundler.definition.locked_gems.specs
+        if specish_objects.first.respond_to?(:materialize_for_installation)
+          specish_objects = specish_objects.map(&:materialize_for_installation)
+        end
+        specish_objects.map do |specish|
+          if specish.respond_to?(:name) && specish.respond_to?(:version) && specish.respond_to?(:gem_dir)
+            # duck type is good enough for outside uses!
+            specish
+          else
+            to_gem_specification(specish)
+          end
+        end.compact
+      end
+
+      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
+      def auto_required_gemspecs_from_bundler
+        return [] unless directory
+
+        logger.info 'Fetching gemspecs autorequired from Bundler (bundler/require)'
+        @auto_required_gemspecs_from_bundler ||=
+          if in_this_bundle?
+            auto_required_gemspecs_from_this_bundle
+          else
+            auto_required_gemspecs_from_external_bundle
+          end
+      end
+
+      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
+      def auto_required_gemspecs_from_this_bundle
+        # Adapted from require() in lib/bundler/runtime.rb
+        dep_names = Bundler.definition.dependencies.select do |dep|
+          dep.groups.include?(:default) && dep.should_include?
+        end.map(&:name)
+
+        all_gemspecs_from_bundle.select { |gemspec| dep_names.include?(gemspec.name) }
+      end
+
+      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
+      def auto_required_gemspecs_from_external_bundle
+        @auto_required_gemspecs_from_external_bundle ||=
+          begin
+            logger.info 'Fetching auto-required gemspecs from Bundler (bundler/require)'
+            command =
+              'Bundler.definition.dependencies' \
+              '.select { |dep| dep.groups.include?(:default) && dep.should_include? }' \
+              '.map(&:name)'
+            # @sg-ignore
+            # @type [Array<String>]
+            dep_names = query_external_bundle command
+
+            all_gemspecs_from_bundle.select { |gemspec| dep_names.include?(gemspec.name) }
+          end
+      end
+
+      # @param gemspec [Gem::Specification]
+      # @return [Array<Gem::Dependency>]
+      def only_runtime_dependencies gemspec
+        unless gemspec.respond_to?(:dependencies) && gemspec.respond_to?(:development_dependencies)
+          gemspec = to_gem_specification(gemspec)
+        end
+        return [] if gemspec.nil?
+
+        gemspec.dependencies - gemspec.development_dependencies
+      end
+
+      # @todo Should this be using Gem::SpecFetcher and pull them automatically?
+      #
+      # @param name [String]
+      # @param version_or_requirement [String, nil]
+      # @param out [IO, nil] output stream for logging
+      #
+      # @return [Gem::Specification, nil]
+      def resolve_gem_ignoring_local_bundle name, version_or_requirement = nil, out: $stderr
+        Gem::Specification.find_by_name(name, version_or_requirement)
+      rescue Gem::MissingSpecError
+        begin
+          Gem::Specification.find_by_name(name)
+        rescue Gem::MissingSpecError
+          stdlibmap = RbsMap::StdlibMap.new(name)
+          unless stdlibmap.resolved?
+            gem_desc = name
+            gem_desc += ":#{version_or_requirement}" if version_or_requirement
+            out&.puts "Please install the gem #{gem_desc} in Solargraph's Ruby environment"
+          end
+          nil # either not here or in stdlib
+        end
+      end
+
+      # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
+      # @return [Array<Gem::Specification>]
+      def all_gemspecs_from_external_bundle
+        @all_gemspecs_from_external_bundle ||=
+          begin
+            logger.info 'Fetching gemspecs required from external bundle'
+
+            command = 'specish_objects = Bundler.definition.locked_gems&.specs; ' \
+                      'if specish_objects.first.respond_to?(:materialize_for_installation);' \
+                      'specish_objects = specish_objects.map(&:materialize_for_installation);' \
+                      'end;' \
+                      'specish_objects.map { |specish| [specish.name, specish.version] }'
+            # @type [Array<Gem::Specification>]
+            query_external_bundle(command).map do |name, version|
+              resolve_gem_ignoring_local_bundle(name, version)
+            end.compact
+          rescue Solargraph::BundleNotFoundError => e
+            Solargraph.logger.info e.message
+            # @sg-ignore Need to add nil check here
+            Solargraph.logger.debug e.backtrace.join("\n")
+            []
+          end
+      end
+
+      # @return [Hash{String => Gem::Specification}]
+      def preference_map
+        @preference_map ||= preferences.to_h { |gemspec| [gemspec.name, gemspec] }
+      end
+
+      # @param gemspec [Gem::Specification]
+      #
+      # @return [Gem::Specification]
+      def gemspec_or_preference gemspec
+        return gemspec unless preference_map.key?(gemspec.name)
+        return gemspec if gemspec.version == preference_map[gemspec.name].version
+
+        change_gemspec_version gemspec, preference_map[gemspec.name].version
+      end
+
+      # @param gemspec [Gem::Specification]
+      # @param version [String]
+      # @return [Gem::Specification]
+      def change_gemspec_version gemspec, version
+        Gem::Specification.find_by_name(gemspec.name, "= #{version}")
+      rescue Gem::MissingSpecError
+        Solargraph.logger.info "Gem #{gemspec.name} version #{version.inspect} not found. " \
+                               "Using #{gemspec.version} instead"
+        gemspec
+      end
+    end
+  end
+end

data/lib/solargraph/workspace/require_paths.rb

@@ -83,6 +83,7 @@ module Solargraph
             return [] if hash.empty?
             hash['paths'].map { |path| File.join(base, path) }
           rescue StandardError => e
+            # @sg-ignore flow sensitive typing should be able to handle redefinition
             Solargraph.logger.warn "Error reading #{gemspec_file_path}: [#{e.class}] #{e.message}"
             []
           end

data/lib/solargraph/workspace.rb

@@ -2,6 +2,7 @@
 
 require 'open3'
 require 'json'
+require 'yaml'
 
 module Solargraph
   # A workspace consists of the files in a project's directory and the
@@ -9,7 +10,10 @@ module Solargraph
   # in an associated Library or ApiMap.
   #
   class Workspace
+    include Logging
+
     autoload :Config, 'solargraph/workspace/config'
+    autoload :Gemspecs, 'solargraph/workspace/gemspecs'
     autoload :RequirePaths, 'solargraph/workspace/require_paths'
 
     # @return [String]
@@ -19,7 +23,8 @@ module Solargraph
     attr_reader :gemnames
     alias source_gems gemnames
 
-    # @param directory [String] TODO: Remove '' and '*' special cases
+    # @todo Remove '' and '*' special cases
+    # @param directory [String]
     # @param config [Config, nil]
     # @param server [Hash]
     def initialize directory = '', config = nil, server = {}
@@ -50,6 +55,76 @@ module Solargraph
       @config ||= Solargraph::Workspace::Config.new(directory)
     end
 
+    # @param stdlib_name [String]
+    #
+    # @return [Array<String>]
+    def stdlib_dependencies stdlib_name
+      gemspecs.stdlib_dependencies(stdlib_name)
+    end
+
+    # @param out [IO, nil] output stream for logging
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Gem::Specification>]
+    def fetch_dependencies gemspec, out: $stderr
+      gemspecs.fetch_dependencies(gemspec, out: out)
+    end
+
+    # @param require [String] The string sent to 'require' in the code to resolve, e.g. 'rails', 'bundler/require'
+    # @return [Array<Gem::Specification>, nil]
+    def resolve_require require
+      gemspecs.resolve_require(require)
+    end
+
+    # @return [Solargraph::PinCache]
+    def pin_cache
+      @pin_cache ||= fresh_pincache
+    end
+
+    # @param stdlib_name [String]
+    #
+    # @return [Array<String>]
+    def stdlib_dependencies stdlib_name
+      deps = RbsMap::StdlibMap.stdlib_dependencies(stdlib_name, nil) || []
+      deps.map { |dep| dep['name'] }.compact
+    end
+
+    # @return [Environ]
+    def global_environ
+      # empty docmap, since the result needs to work in any possible
+      # context here
+      @global_environ ||= Convention.for_global(DocMap.new([], self, out: nil))
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @param out [StringIO, IO, nil] output stream for logging
+    # @param rebuild [Boolean] whether to rebuild the pins even if they are cached
+    #
+    # @return [void]
+    def cache_gem gemspec, out: nil, rebuild: false
+      pin_cache.cache_gem(gemspec: gemspec, out: out, rebuild: rebuild)
+    end
+
+    # @param gemspec [Gem::Specification, Bundler::LazySpecification]
+    # @param out [StringIO, IO, nil] output stream for logging
+    #
+    # @return [void]
+    def uncache_gem gemspec, out: nil
+      pin_cache.uncache_gem(gemspec, out: out)
+    end
+
+    # @return [Solargraph::PinCache]
+    def fresh_pincache
+      PinCache.new(rbs_collection_path: rbs_collection_path,
+                   rbs_collection_config_path: rbs_collection_config_path,
+                   yard_plugins: yard_plugins,
+                   directory: directory)
+    end
+
+    # @return [Array<String>]
+    def yard_plugins
+      @yard_plugins ||= global_environ.yard_plugins.sort.uniq
+    end
+
     # @param level [Symbol]
     # @return [TypeChecker::Rules]
     def rules(level)
@@ -63,6 +138,7 @@ module Solargraph
     # @param sources [Array<Solargraph::Source>]
     # @return [Boolean] True if the source was added to the workspace
     def merge *sources
+      # @sg-ignore Need to add nil check here
       unless directory == '*' || sources.all? { |source| source_hash.key?(source.filename) }
         # Reload the config to determine if a new source should be included
         @config = Solargraph::Workspace::Config.new(directory)
@@ -70,10 +146,12 @@ module Solargraph
 
       includes_any = false
       sources.each do |source|
-        if directory == "*" || config.calculated.include?(source.filename)
-          source_hash[source.filename] = source
-          includes_any = true
-        end
+        # @sg-ignore Need to add nil check here
+        next unless directory == "*" || config.calculated.include?(source.filename)
+
+        # @sg-ignore Need to add nil check here
+        source_hash[source.filename] = source
+        includes_any = true
       end
 
       includes_any
@@ -126,6 +204,23 @@ module Solargraph
       false
     end
 
+    # True if the workspace contains at least one gemspec file.
+    #
+    # @return [Boolean]
+    def gemspec?
+      !gemspec_files.empty?
+    end
+
+    # Get an array of all gemspec files in the workspace.
+    #
+    # @return [Array<String>]
+    def gemspec_files
+      return [] if directory.empty? || directory == '*'
+      @gemspec_files ||= Dir[File.join(directory, '**/*.gemspec')].select do |gs|
+        config.allow? gs
+      end
+    end
+
     # @return [String, nil]
     def rbs_collection_path
       @gem_rbs_collection ||= read_rbs_collection_path
@@ -133,12 +228,57 @@ module Solargraph
 
     # @return [String, nil]
     def rbs_collection_config_path
-      @rbs_collection_config_path ||= begin
-        unless directory.empty? || directory == '*'
-          yaml_file = File.join(directory, 'rbs_collection.yaml')
-          yaml_file if File.file?(yaml_file)
+      @rbs_collection_config_path ||=
+        begin
+          unless directory.empty? || directory == '*'
+            yaml_file = File.join(directory, 'rbs_collection.yaml')
+            yaml_file if File.file?(yaml_file)
+          end
         end
+    end
+
+    # @param name [String]
+    # @param version [String, nil]
+    # @param out [IO, nil]
+    #
+    # @return [Gem::Specification, nil]
+    def find_gem name, version = nil, out: nil
+      gemspecs.find_gem(name, version, out: out)
+    end
+
+    # @return [Array<Gem::Specification>]
+    def all_gemspecs_from_bundle
+      gemspecs.all_gemspecs_from_bundle
+    end
+
+    # @todo make this actually work against bundle instead of pulling
+    #   all installed gemspecs -
+    #   https://github.com/apiology/solargraph/pull/10
+    # @return [Array<Gem::Specification>]
+    def all_gemspecs_from_bundle
+      Gem::Specification.to_a
+    end
+
+    # @param out [StringIO, IO, nil] output stream for logging
+    # @param rebuild [Boolean] whether to rebuild the pins even if they are cached
+    # @return [void]
+    def cache_all_for_workspace! out, rebuild: false
+      PinCache.cache_core(out: out) unless PinCache.core? && !rebuild
+
+      gem_specs = all_gemspecs_from_bundle
+      # try any possible standard libraries, but be quiet about it
+      stdlib_specs = pin_cache.possible_stdlibs.map { |stdlib| find_gem(stdlib, out: nil) }.compact
+      specs = (gem_specs + stdlib_specs)
+      specs.each do |spec|
+        pin_cache.cache_gem(gemspec: spec, rebuild: rebuild, out: out) unless pin_cache.cached?(spec)
       end
+      out&.puts "Documentation cached for all #{specs.length} gems."
+
+      # do this after so that we prefer stdlib requires from gems,
+      # which are likely to be newer and have more pins
+      pin_cache.cache_all_stdlibs(out: out, rebuild: rebuild)
+
+      out&.puts "Documentation cached for core, standard library and gems."
     end
 
     # Synchronize the workspace from the provided updater.
@@ -149,7 +289,9 @@ module Solargraph
       source_hash[updater.filename] = source_hash[updater.filename].synchronize(updater)
     end
 
+    # @sg-ignore Need to validate config
     # @return [String]
+    # @sg-ignore Need to validate config
     def command_path
       server['commandPath'] || 'solargraph'
     end
@@ -160,12 +302,9 @@ module Solargraph
       directory
     end
 
-    # True if the workspace has a root Gemfile.
-    #
-    # @todo Handle projects with custom Bundler/Gemfile setups (see DocMap#gemspecs_required_from_bundler)
-    #
-    def gemfile?
-      directory && File.file?(File.join(directory, 'Gemfile'))
+    # @return [Solargraph::Workspace::Gemspecs]
+    def gemspecs
+      @gemspecs ||= Solargraph::Workspace::Gemspecs.new(directory_or_nil)
     end
 
     private
@@ -186,7 +325,10 @@ module Solargraph
       source_hash.clear
       unless directory.empty? || directory == '*'
         size = config.calculated.length
-        raise WorkspaceTooLargeError, "The workspace is too large to index (#{size} files, #{config.max_files} max)" if config.max_files > 0 and size > config.max_files
+        if config.max_files > 0 and size > config.max_files
+          raise WorkspaceTooLargeError,
+                "The workspace is too large to index (#{size} files, #{config.max_files} max)"
+        end
         config.calculated.each do |filename|
           begin
             source_hash[filename] = Solargraph::Source.load(filename)

data/lib/solargraph/yard_map/helpers.rb

@@ -5,7 +5,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 +14,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

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

@@ -6,6 +6,7 @@ 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
@@ -25,9 +26,12 @@ 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]]
+          # @sg-ignore Need to add nil check here
           final_visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
           final_visibility ||= visibility
           final_visibility ||= :private if code_object.module_function? && final_scope == :instance
@@ -49,6 +53,7 @@ module Solargraph
               source: :yardoc,
             )
           else
+            # @sg-ignore Need to add nil check here
             pin = Pin::Method.new(
               location: location,
               closure: closure,
@@ -85,7 +90,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,

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

@@ -21,6 +21,7 @@ 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,
           )