solargraph 0.58.2 → 0.59.0.dev.2

data/Gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec name: 'solargraph'
 
 # Local gemfile for development tools, etc.
-local_gemfile = File.expand_path(".Gemfile", __dir__)
+local_gemfile = File.expand_path('.Gemfile', __dir__)
 instance_eval File.read local_gemfile if File.exist? local_gemfile

data/README.md

@@ -51,6 +51,8 @@ Plug-ins and extensions are available for the following editors:
 
 Solargraph's behavior can be controlled via optional [configuration](https://solargraph.org/guides/configuration) files. The highest priority file is a `.solargraph.yml` file at the root of the project. If not present, any global configuration at `~/.config/solargraph/config.yml` will apply. The path to the global configuration can be overridden with the `SOLARGRAPH_GLOBAL_CONFIG` environment variable.
 
+Use `bundle exec solargraph config` to create a configuration file.
+
 ### Plugins
 
 Solargraph supports [plugins](https://solargraph.org/guides/plugins) that implement their own Solargraph features, such as diagnostics reporters and conventions to provide LSP features and type-checking, e.g. for frameworks which use metaprogramming and/or DSLs.
@@ -132,9 +134,7 @@ See [https://solargraph.org/guides](https://solargraph.org/guides) for more tips
 
 ### Development
 
-To see more logging when typechecking or running specs, set the
-`SOLARGRAPH_LOG` environment variable to `debug` or `info`.  `warn` is
-the default value.
+To see more logging when typechecking or running specs, set the `SOLARGRAPH_LOG` environment variable to `debug` or `info`.  `warn` is the default value.
 
 Code contributions are always appreciated. Feel free to fork the repo and submit pull requests. Check for open issues that could use help. Start new issues to discuss changes that have a major impact on the code or require large time commitments.
 

data/Rakefile

@@ -1,42 +1,44 @@
+# frozen_string_literal: true
+
 require 'rake'
 require 'bundler/gem_tasks'
 require 'fileutils'
 require 'open3'
 
-desc "Open a Pry session preloaded with this library"
+desc 'Open a Pry session preloaded with this library'
 task :console do
-  sh "pry -I lib -r solargraph.rb"
+  sh 'pry -I lib -r solargraph.rb'
 end
 
-desc "Run the type checker"
+desc 'Run the type checker'
 task typecheck: [:typecheck_strong]
 
-desc "Run the type checker at typed level - return code issues provable without annotations being correct"
+desc 'Run the type checker at typed level - return code issues provable without annotations being correct'
 task :typecheck_typed do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level typed"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level typed'
 end
 
-desc "Run the type checker at strict level - report issues using type annotations"
+desc 'Run the type checker at strict level - report issues using type annotations'
 task :typecheck_strict do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strict"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strict'
 end
 
-desc "Run the type checker at strong level - enforce that type annotations exist"
+desc 'Run the type checker at strong level - enforce that type annotations exist'
 task :typecheck_strong do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strong"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strong'
 end
 
-desc "Run the type checker at alpha level - run high-false-alarm checks"
+desc 'Run the type checker at alpha level - run high-false-alarm checks'
 task :typecheck_alpha do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level alpha"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level alpha'
 end
 
-desc "Run RSpec tests, starting with the ones that failed last time"
+desc 'Run RSpec tests, starting with the ones that failed last time'
 task spec: %i[spec_failed undercover_no_fail full_spec] do
   undercover
 end
 
-desc "Run all RSpec tests"
+desc 'Run all RSpec tests'
 task :full_spec do
   warn 'starting spec'
   sh 'TEST_COVERAGE_COMMAND_NAME=full-new bundle exec rspec' #  --profile'
@@ -63,19 +65,20 @@ def undercover
   status
 rescue StandardError => e
   warn "hit error: #{e.message}"
+  # @sg-ignore Need to add nil check here
   warn "Backtrace:\n#{e.backtrace.join("\n")}"
   warn "output: #{output}"
-  puts "Flushing"
+  puts 'Flushing'
   $stdout.flush
   raise
 end
 
-desc "Check PR coverage"
+desc 'Check PR coverage'
 task :undercover do
-  raise "Undercover failed" unless undercover.success?
+  raise 'Undercover failed' unless undercover.success?
 end
 
-desc "Branch-focused fast-feedback quality/spec/coverage checks"
+desc 'Branch-focused fast-feedback quality/spec/coverage checks'
 task test: %i[overcommit spec typecheck] do
   # do these in order
   Rake::Task['typecheck_strict'].invoke
@@ -83,18 +86,18 @@ task test: %i[overcommit spec typecheck] do
   Rake::Task['typecheck_alpha'].invoke
 end
 
-desc "Re-run failed specs.  Add --fail-fast in your .rspec-local file if desired."
+desc 'Re-run failed specs.  Add --fail-fast in your .rspec-local file if desired.'
 task :spec_failed do
   # allow user to check out any persistent failures while looking for
   # more in the whole test suite
   sh 'TEST_COVERAGE_COMMAND_NAME=next-failure bundle exec rspec --only-failures || true'
 end
 
-desc "Run undercover and show output without failing the task if it fails"
+desc 'Run undercover and show output without failing the task if it fails'
 task :undercover_no_fail do
   undercover
 rescue StandardError
-  puts "Undercover failed, but continuing with other tasks."
+  puts 'Undercover failed, but continuing with other tasks.'
 end
 
 # @return [void]
@@ -103,7 +106,7 @@ def simplecov_collate
   require 'simplecov-lcov'
   require 'undercover/simplecov_formatter'
 
-  SimpleCov.collate(Dir["coverage/{next-failure,full,ad-hoc}/.resultset.json"]) do
+  SimpleCov.collate(Dir['coverage/{next-failure,full,ad-hoc}/.resultset.json']) do
     cname = 'combined'
     command_name cname
     new_dir = File.join('coverage', cname)
@@ -118,7 +121,7 @@ def simplecov_collate
              ])
     SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
   end
-  puts "Simplecov collated results into coverage/combined/.resultset.json"
+  puts 'Simplecov collated results into coverage/combined/.resultset.json'
 rescue StandardError => e
   puts "Simplecov collate failed: #{e.message}"
 ensure
@@ -130,7 +133,7 @@ task :simplecov_collate do
   simplecov_collate
 end
 
-desc "Show quality checks on this development branch so far, including any staged files"
+desc 'Show quality checks on this development branch so far, including any staged files'
 task :overcommit do
   # OVERCOMMIT_DEBUG=1 will show more detail
   sh 'SOLARGRAPH_ASSERTS=on bundle exec overcommit --run --diff origin/master'

data/bin/solargraph

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 # turn off warning diagnostics from Ruby
-$VERBOSE=nil
+$VERBOSE = nil
 
 require 'solargraph'
 

data/lib/solargraph/api_map/cache.rb

@@ -8,7 +8,7 @@ module Solargraph
         @methods = {}
         # @type [Hash{String, Array<String> => Array<Pin::Base>}]
         @constants = {}
-        # @type [Hash{String => String}]
+        # @type [Hash{String => String, nil}]
         @qualified_namespaces = {}
         # @type [Hash{String => Pin::Method}]
         @receiver_definitions = {}
@@ -61,14 +61,14 @@ module Solargraph
 
       # @param name [String]
       # @param context [String]
-      # @return [String]
+      # @return [String, nil]
       def get_qualified_namespace name, context
         @qualified_namespaces["#{name}|#{context}"]
       end
 
       # @param name [String]
       # @param context [String]
-      # @param value [String]
+      # @param value [String, nil]
       # @return [void]
       def set_qualified_namespace name, context, value
         @qualified_namespaces["#{name}|#{context}"] = value

data/lib/solargraph/api_map/constants.rb

@@ -27,9 +27,11 @@ module Solargraph
       # @param name [String] Namespace which may relative and not be rooted.
       # @param gates [Array<Array<String>, String>] Namespaces to search while resolving the name
       #
+      # @sg-ignore flow sensitive typing needs to eliminate literal from union with return if foo == :bar
       # @return [String, nil] fully qualified namespace (i.e., is
       #   absolute, but will not start with ::)
       def resolve(name, *gates)
+        # @sg-ignore Need to add nil check here
         return store.get_path_pins(name[2..]).first&.path if name.start_with?('::')
 
         flat = gates.flatten
@@ -86,6 +88,7 @@ module Solargraph
         return unless fqns
         pin = store.get_path_pins(fqns).first
         if pin.is_a?(Pin::Constant)
+          # @sg-ignore Need to add nil check here
           const = Solargraph::Parser::NodeMethods.unpack_name(pin.assignment)
           return unless const
           fqns = resolve(const, *pin.gates)
@@ -105,6 +108,7 @@ module Solargraph
 
       # @param name [String]
       # @param gates [Array<String>]
+      # @sg-ignore flow sensitive typing should be able to handle redefinition
       # @return [String, nil]
       def resolve_and_cache name, gates
         cached_resolve[[name, gates]] = :in_process
@@ -125,6 +129,7 @@ module Solargraph
           if resolved
             base = [resolved]
           else
+            # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
             return resolve(name, first) unless first.empty?
           end
         end
@@ -138,7 +143,7 @@ module Solargraph
       # @param name [String]
       # @param gates [Array<String>]
       # @param internal [Boolean] True if the name is not the last in the namespace
-      # @return [Array(Object, Array<String>)]
+      # @return [Array(String, Array<String>), Array(nil, Array<String>), String]
       def complex_resolve name, gates, internal
         resolved = nil
         gates.each.with_index do |gate, idx|
@@ -165,6 +170,7 @@ module Solargraph
         here = "#{gate}::#{name}".sub(/^::/, '').sub(/::$/, '')
         pin = store.get_path_pins(here).first
         if pin.is_a?(Pin::Constant) && internal
+          # @sg-ignore Need to add nil check here
           const = Solargraph::Parser::NodeMethods.unpack_name(pin.assignment)
           return unless const
           resolve(const, pin.gates)
@@ -197,13 +203,14 @@ module Solargraph
       # will start the search in the specified context until it finds a
       # match for the namespace.
       #
-      # @param namespace [String, nil] The namespace to
+      # @param namespace [String] The namespace to
       #   match
       # @param context_namespace [String] The context namespace in which the
       #   tag was referenced; start from here to resolve the name
       # @return [String, nil] fully qualified namespace
       def qualify_namespace namespace, context_namespace = ''
         if namespace.start_with?('::')
+          # @sg-ignore Need to add nil check here
           inner_qualify(namespace[2..], '', Set.new)
         else
           inner_qualify(namespace, context_namespace, Set.new)
@@ -249,7 +256,7 @@ module Solargraph
         end
       end
 
-      # @param fqns [String]
+      # @param fqns [String, nil]
       # @param visibility [Array<Symbol>]
       # @param skip [Set<String>]
       # @return [Array<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
@@ -259,17 +266,20 @@ module Solargraph
         result = []
 
         store.get_prepends(fqns).each do |pre|
+          # @sg-ignore Need to add nil check here
           pre_fqns = resolve(pre.name, pre.closure.gates - skip.to_a)
           result.concat inner_get_constants(pre_fqns, [:public], skip)
         end
         result.concat(store.get_constants(fqns, visibility).sort { |a, b| a.name <=> b.name })
         store.get_includes(fqns).each do |pin|
+          # @sg-ignore Need to add nil check here
           inc_fqns = resolve(pin.name, pin.closure.gates - skip.to_a)
           result.concat inner_get_constants(inc_fqns, [:public], skip)
         end
         sc_ref = store.get_superclass(fqns)
         if sc_ref
           fqsc = dereference(sc_ref)
+          # @sg-ignore Need to add nil check here
           result.concat inner_get_constants(fqsc, [:public], skip) unless %w[Object BasicObject].include?(fqsc)
         end
         result

data/lib/solargraph/api_map/index.rb

@@ -40,13 +40,13 @@ module Solargraph
       # @param klass [Class<generic<T>>]
       # @return [Set<generic<T>>]
       def pins_by_class klass
-        # @type [Set<Solargraph::Pin::Base>]
+        # @type [Set<generic<T>>]
         s = Set.new
         # @sg-ignore need to support destructured args in blocks
         @pin_select_cache[klass] ||= pin_class_hash.each_with_object(s) { |(key, o), n| n.merge(o) if key <= klass }
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
       def include_references
         # @param h [String]
         # @param k [Array<String>]
@@ -60,21 +60,21 @@ module Solargraph
         @include_reference_pins ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Pin::Reference::Extend>}]
       def extend_references
         # @param h [String]
         # @param k [Array<String>]
         @extend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Pin::Reference::Prepend>}]
       def prepend_references
         # @param h [String]
         # @param k [Array<String>]
         @prepend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Pin::Reference::Superclass>}]
       def superclass_references
         # @param h [String]
         # @param k [Array<String>]
@@ -118,15 +118,15 @@ module Solargraph
         # @param k [String]
         # @param v [Set<Pin::Base>]
         set.classify(&:class)
-          .map { |k, v| pin_class_hash[k].concat v.to_a }
+           .map { |k, v| pin_class_hash[k].concat v.to_a }
         # @param k [String]
         # @param v [Set<Pin::Namespace>]
         set.classify(&:namespace)
-          .map { |k, v| namespace_hash[k].concat v.to_a }
+           .map { |k, v| namespace_hash[k].concat v.to_a }
         # @param k [String]
         # @param v [Set<Pin::Base>]
         set.classify(&:path)
-          .map { |k, v| path_pin_hash[k].concat v.to_a }
+           .map { |k, v| path_pin_hash[k].concat v.to_a }
         @namespaces = path_pin_hash.keys.compact.to_set
         map_references Pin::Reference::Include, include_references
         map_references Pin::Reference::Prepend, prepend_references
@@ -138,7 +138,7 @@ module Solargraph
 
       # @generic T
       # @param klass [Class<generic<T>>]
-      # @param hash [Hash{String => generic<T>}]
+      # @param hash [Hash{String => Array<generic<T>>}]
       #
       # @return [void]
       def map_references klass, hash
@@ -150,26 +150,32 @@ module Solargraph
 
       # @return [void]
       def map_overrides
+        # @todo should complain when type for 'ovr' is not provided
         # @param ovr [Pin::Reference::Override]
         pins_by_class(Pin::Reference::Override).each do |ovr|
           logger.debug { "ApiMap::Index#map_overrides: Looking at override #{ovr} for #{ovr.name}" }
           pins = path_pin_hash[ovr.name]
           logger.debug { "ApiMap::Index#map_overrides: pins for path=#{ovr.name}: #{pins}" }
           pins.each do |pin|
-            new_pin = if pin.path.end_with?('#initialize')
-                        path_pin_hash[pin.path.sub(/#initialize/, '.new')].first
-                      end
+            new_pin = (path_pin_hash[pin.path.sub('#initialize', '.new')].first if pin.path.end_with?('#initialize'))
             (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
+              # @sg-ignore Wrong argument type for
+              #   YARD::Docstring#delete_tags: name expected String,
+              #   received String, Symbol - delete_tags is ok with a
+              #   _ToS, but we should fix anyway
               pin.docstring.delete_tags tag
-              new_pin.docstring.delete_tags tag if new_pin
+              new_pin&.docstring&.delete_tags tag
             end
             ovr.tags.each do |tag|
               pin.docstring.add_tag(tag)
               redefine_return_type pin, tag
-              if new_pin
-                new_pin.docstring.add_tag(tag)
-                redefine_return_type new_pin, tag
-              end
+              pin.reset_generated!
+
+              next unless new_pin
+
+              new_pin.docstring.add_tag(tag)
+              redefine_return_type new_pin, tag
+              new_pin.reset_generated!
             end
           end
         end
@@ -186,7 +192,6 @@ module Solargraph
         pin.signatures.each do |sig|
           sig.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
         end
-        pin.reset_generated!
       end
     end
   end

data/lib/solargraph/api_map/source_to_yard.rb

@@ -3,16 +3,18 @@
 module Solargraph
   class ApiMap
     module SourceToYard
-
       # Get the YARD CodeObject at the specified path.
       #
+      # @sg-ignore Declared return type generic<T>, nil does not match
+      #   inferred type ::YARD::CodeObjects::Base, nil for
+      #   Solargraph::ApiMap::SourceToYard#code_object_at
       # @generic T
       # @param path [String]
       # @param klass [Class<generic<T>>]
       # @return [generic<T>, nil]
       def code_object_at path, klass = YARD::CodeObjects::Base
         obj = code_object_map[path]
-        obj if obj&.is_a?(klass)
+        obj if obj.is_a?(klass)
       end
 
       # @return [Array<String>]
@@ -33,16 +35,20 @@ module Solargraph
           end
           if pin.type == :class
             # @param obj [YARD::CodeObjects::RootObject]
-            code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path) { |obj|
+            code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path) do |obj|
+              # @sg-ignore flow sensitive typing needs to handle attrs
               next if pin.location.nil? || pin.location.filename.nil?
+              # @sg-ignore flow sensitive typing needs to handle attrs
               obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
-            }
+            end
           else
             # @param obj [YARD::CodeObjects::RootObject]
-            code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) { |obj|
+            code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) do |obj|
+              # @sg-ignore flow sensitive typing needs to handle attrs
               next if pin.location.nil? || pin.location.filename.nil?
+              # @sg-ignore flow sensitive typing needs to handle attrs
               obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
-            }
+            end
           end
           code_object_map[pin.path].docstring = pin.docstring
           store.get_includes(pin.path).each do |ref|
@@ -57,7 +63,6 @@ module Solargraph
             code_object = code_object_map[ref.type.to_s]
             next unless code_object
             extend_object.class_mixins.push code_object
-            # @todo add spec showing why this next line is necessary
             extend_object.instance_mixins.push code_object
           end
         end
@@ -67,14 +72,22 @@ module Solargraph
             next
           end
 
+          # @sg-ignore Need to add nil check here
           # @param obj [YARD::CodeObjects::RootObject]
-          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace, YARD::CodeObjects::NamespaceObject), pin.name, pin.scope) { |obj|
+          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(
+            code_object_at(pin.namespace, YARD::CodeObjects::NamespaceObject), pin.name, pin.scope
+          ) do |obj|
+            # @sg-ignore flow sensitive typing needs to handle attrs
             next if pin.location.nil? || pin.location.filename.nil?
+            # @sg-ignore flow sensitive typing needs to handle attrs
             obj.add_file pin.location.filename, pin.location.range.start.line
-          }
+          end
           method_object = code_object_at(pin.path, YARD::CodeObjects::MethodObject)
+          # @sg-ignore Need to add nil check here
           method_object.docstring = pin.docstring
+          # @sg-ignore Need to add nil check here
           method_object.visibility = pin.visibility || :public
+          # @sg-ignore Need to add nil check here
           method_object.parameters = pin.parameters.map do |p|
             [p.full_name, p.asgn_code]
           end

data/lib/solargraph/api_map/store.rb

@@ -32,15 +32,16 @@ module Solargraph
 
         # @todo Fix this map
         @fqns_pins_map = nil
-        return catalog(pinsets) if changed == 0
+        return catalog(pinsets) if changed.zero?
 
+        # @sg-ignore Need to add nil check here
         pinsets[changed..].each_with_index do |pins, idx|
           @pinsets[changed + idx] = pins
           @indexes[changed + idx] = if pins.empty?
-            @indexes[changed + idx - 1]
-          else
-            @indexes[changed + idx - 1].merge(pins)
-          end
+                                      @indexes[changed + idx - 1]
+                                    else
+                                      @indexes[changed + idx - 1].merge(pins)
+                                    end
         end
         constants.clear
         cached_qualify_superclass.clear
@@ -59,10 +60,10 @@ module Solargraph
       # @param visibility [Array<Symbol>]
       # @return [Enumerable<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
       def get_constants fqns, visibility = [:public]
-        namespace_children(fqns).select { |pin|
-          # @sg-ignore flow-sensitive typing not smart enough to handle this case
+        namespace_children(fqns).select do |pin|
+          # @sg-ignore flow sensitive typing not smart enough to handle this case
           !pin.name.empty? && (pin.is_a?(Pin::Namespace) || pin.is_a?(Pin::Constant)) && visibility.include?(pin.visibility)
-        }
+        end
       end
 
       # @param fqns [String]
@@ -71,17 +72,18 @@ module Solargraph
       # @return [Enumerable<Solargraph::Pin::Method>]
       def get_methods fqns, scope: :instance, visibility: [:public]
         all_pins = namespace_children(fqns).select do |pin|
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           pin.is_a?(Pin::Method) && pin.scope == scope && visibility.include?(pin.visibility)
         end
         GemPins.combine_method_pins_by_path(all_pins)
       end
 
-      BOOLEAN_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Boolean', closure: Pin::ROOT_PIN, source: :solargraph)
-      OBJECT_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Object', closure: Pin::ROOT_PIN, source: :solargraph)
+      BOOLEAN_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Boolean', closure: Pin::ROOT_PIN,
+                                                              source: :solargraph)
+      OBJECT_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Object', closure: Pin::ROOT_PIN,
+                                                             source: :solargraph)
 
-      # @param fqns [String]
-      # @return [Pin::Reference::Superclass]
+      # @param fqns [String, nil]
+      # @return [Pin::Reference::Superclass, nil]
       def get_superclass fqns
         return nil if fqns.nil? || fqns.empty?
         return BOOLEAN_SUPERCLASS_PIN if %w[TrueClass FalseClass].include?(fqns)
@@ -126,20 +128,20 @@ module Solargraph
         index.path_pin_hash[path]
       end
 
-      # @param fqns [String]
+      # @param fqns [String, nil]
       # @param scope [Symbol] :class or :instance
       # @return [Enumerable<Solargraph::Pin::Base>]
-      def get_instance_variables(fqns, scope = :instance)
-        all_instance_variables.select { |pin|
+      def get_instance_variables fqns, scope = :instance
+        all_instance_variables.select do |pin|
           pin.binder.namespace == fqns && pin.binder.scope == scope
-        }
+        end
       end
 
       # @param fqns [String]
       #
       # @return [Enumerable<Solargraph::Pin::ClassVariable>]
-      def get_class_variables(fqns)
-        namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable)}
+      def get_class_variables fqns
+        namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable) }
       end
 
       # @return [Enumerable<Solargraph::Pin::Base>]
@@ -149,7 +151,7 @@ module Solargraph
 
       # @param fqns [String]
       # @return [Boolean]
-      def namespace_exists?(fqns)
+      def namespace_exists? fqns
         fqns_pins(fqns).any?
       end
 
@@ -165,7 +167,7 @@ module Solargraph
 
       # @param fqns [String]
       # @return [Array<String>]
-      def domains(fqns)
+      def domains fqns
         result = []
         fqns_pins(fqns).each do |nspin|
           result.concat nspin.domains
@@ -178,7 +180,7 @@ module Solargraph
         @named_macros ||= begin
           result = {}
           pins.each do |pin|
-            pin.macros.select{|m| m.tag.tag_name == 'macro' && !m.tag.text.empty? }.each do |macro|
+            pin.macros.select { |m| m.tag.tag_name == 'macro' && !m.tag.text.empty? }.each do |macro|
               next if macro.tag.name.nil? || macro.tag.name.empty?
               result[macro.tag.name] = macro
             end
@@ -199,7 +201,7 @@ module Solargraph
         index.pins_by_class klass
       end
 
-      # @param fqns [String]
+      # @param fqns [String, nil]
       # @return [Array<Solargraph::Pin::Namespace>]
       def fqns_pins fqns
         return [] if fqns.nil?
@@ -217,7 +219,7 @@ module Solargraph
       # Get all ancestors (superclasses, includes, prepends, extends) for a namespace
       # @param fqns [String] The fully qualified namespace
       # @return [Array<String>] Array of ancestor namespaces including the original
-      def get_ancestors(fqns)
+      def get_ancestors fqns
         return [] if fqns.nil? || fqns.empty?
 
         ancestors = [fqns]
@@ -244,8 +246,11 @@ module Solargraph
             next if refs.nil?
             # @param ref [String]
             refs.map(&:type).map(&:to_s).each do |ref|
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
               next if ref.nil? || ref.empty? || visited.include?(ref)
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
               ancestors << ref
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
               queue << ref
             end
           end
@@ -257,7 +262,7 @@ module Solargraph
       # @param fqns [String]
       #
       # @return [Array<Solargraph::Pin::Reference>]
-      def get_ancestor_references(fqns)
+      def get_ancestor_references fqns
         (get_prepends(fqns) + get_includes(fqns) + [get_superclass(fqns)]).compact
       end
 
@@ -275,7 +280,7 @@ module Solargraph
 
       # @param pinsets [Array<Array<Pin::Base>>]
       #
-      # @return [void]
+      # @return [true]
       def catalog pinsets
         @pinsets = pinsets
         # @type [Array<Index>]
@@ -308,7 +313,7 @@ module Solargraph
         index.pins_by_class(Pin::Symbol)
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Pin::Reference::Superclass>}]
       def superclass_references
         index.superclass_references
       end
@@ -347,7 +352,7 @@ module Solargraph
 
       # @param fqns [String]
       # @return [Pin::Reference::Superclass, nil]
-      def try_special_superclasses(fqns)
+      def try_special_superclasses fqns
         return OBJECT_SUPERCLASS_PIN if fqns == 'Boolean'
         return OBJECT_SUPERCLASS_PIN if !%w[BasicObject Object].include?(fqns) && namespace_exists?(fqns)