solargraph 0.58.2 → 0.59.0.dev.1

data/lib/solargraph/source/change.rb

@@ -7,13 +7,13 @@ module Solargraph
     class Change
       include EncodingFixes
 
-      # @return [Range]
+      # @return [Range, nil]
       attr_reader :range
 
       # @return [String]
       attr_reader :new_text
 
-      # @param range [Range] The starting and ending positions of the change.
+      # @param range [Range, nil] The starting and ending positions of the change.
       #   If nil, the original text will be overwritten.
       # @param new_text [String] The text to be changed.
       def initialize range, new_text
@@ -31,9 +31,11 @@ module Solargraph
         if nullable and !range.nil? and new_text.match(/[.\[{(@$:]$/)
           [':', '@'].each do |dupable|
             next unless new_text == dupable
+            # @sg-ignore flow sensitive typing needs to handle attrs
             offset = Position.to_offset(text, range.start)
             if text[offset - 1] == dupable
               p = Position.from_offset(text, offset - 1)
+              # @sg-ignore flow sensitive typing needs to handle attrs
               r = Change.new(Range.new(p, range.start), ' ')
               text = r.write(text)
             end
@@ -58,9 +60,12 @@ module Solargraph
           fixed
         else
           result = commit text, fixed
+          # @sg-ignore flow sensitive typing needs to handle attrs
           off = Position.to_offset(text, range.start)
+          # @sg-ignore Need to add nil check here
           match = result[0, off].match(/[.:]+\z/)
           if match
+            # @sg-ignore flow sensitive typing should be able to handle redefinition
             result = result[0, off].sub(/#{match[0]}\z/, ' ' * match[0].length) + result[off..-1]
           end
           result
@@ -73,7 +78,9 @@ module Solargraph
       # @param insert [String]
       # @return [String]
       def commit text, insert
+        # @sg-ignore Need to add nil check here
         start_offset = Position.to_offset(text, range.start)
+        # @sg-ignore Need to add nil check here
         end_offset = Position.to_offset(text, range.ending)
         (start_offset == 0 ? '' : text[0..start_offset-1].to_s) + normalize(insert) + text[end_offset..-1].to_s
       end

data/lib/solargraph/source/cursor.rb

@@ -19,7 +19,7 @@ module Solargraph
         @position = Position.normalize(position)
       end
 
-      # @return [String]
+      # @return [String, nil]
       def filename
         source.filename
       end
@@ -35,12 +35,14 @@ module Solargraph
       # The part of the word before the current position. Given the text
       # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
       #
+      # @sg-ignore Need to add nil check here
       # @return [String]
       def start_of_word
         @start_of_word ||= begin
           match = source.code[0..offset-1].to_s.match(start_word_pattern)
           result = (match ? match[0] : '')
           # Including the preceding colon if the word appears to be a symbol
+          # @sg-ignore Need to add nil check here
           result = ":#{result}" if source.code[0..offset-result.length-1].end_with?(':') and !source.code[0..offset-result.length-1].end_with?('::')
           result
         end
@@ -50,6 +52,7 @@ module Solargraph
       # `foo.bar`, the end_of_word at position (0,6) is `r`.
       #
       # @return [String]
+      # @sg-ignore Need to add nil check here
       def end_of_word
         @end_of_word ||= begin
           match = source.code[offset..-1].to_s.match(end_word_pattern)
@@ -110,6 +113,7 @@ module Solargraph
       def recipient
         @recipient ||= begin
           node = recipient_node
+          # @sg-ignore Need to add nil check here
           node ? Cursor.new(source, Range.from_node(node).ending) : nil
         end
       end
@@ -124,8 +128,10 @@ module Solargraph
       def node_position
         @node_position ||= begin
           if start_of_word.empty?
+            # @sg-ignore Need to add nil check here
             match = source.code[0, offset].match(/\s*(\.|:+)\s*$/)
             if match
+              # @sg-ignore Need to add nil check here
               Position.from_offset(source.code, offset - match[0].length)
             else
               position

data/lib/solargraph/source/source_chainer.rb

@@ -33,25 +33,29 @@ module Solargraph
       def chain
         # Special handling for files that end with an integer and a period
         return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
+        # @sg-ignore Need to add nil check here
         return Chain.new([Chain::Literal.new('Symbol', phrase[1..].to_sym)]) if phrase.start_with?(':') && !phrase.start_with?('::')
         return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
         begin
           return Chain.new([]) if phrase.end_with?('..')
+          # @type [::Parser::AST::Node, nil]
           node = nil
+          # @type [::Parser::AST::Node, nil]
           parent = nil
           if !source.repaired? && source.parsed? && source.synchronized?
             tree = source.tree_at(position.line, position.column)
             node, parent = tree[0..2]
           elsif source.parsed? && source.repaired? && end_of_phrase == '.'
             node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2]
-            node = Parser.parse(fixed_phrase) if node.nil?
+            # provide filename and line so that we can look up local variables there later
+            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
           elsif source.repaired?
-            node = Parser.parse(fixed_phrase)
+            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line)
           else
             node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2] unless source.error_ranges.any?{|r| r.nil? || r.include?(fixed_position)}
             # Exception for positions that chain literal nodes in unsynchronized sources
             node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
-            node = Parser.parse(fixed_phrase) if node.nil?
+            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
           end
         rescue Parser::SyntaxError
           return Chain.new([Chain::UNDEFINED_CALL])
@@ -79,11 +83,13 @@ module Solargraph
       # @return [Solargraph::Source]
       attr_reader :source
 
+      # @sg-ignore Need to add nil check here
       # @return [String]
       def phrase
         @phrase ||= source.code[signature_data..offset-1]
       end
 
+      # @sg-ignore Need to add nil check here
       # @return [String]
       def fixed_phrase
         @fixed_phrase ||= phrase[0..-(end_of_phrase.length+1)]
@@ -95,6 +101,7 @@ module Solargraph
       end
 
       # @return [String]
+      # @sg-ignore Need to add nil check here
       def end_of_phrase
         @end_of_phrase ||= begin
           match = phrase.match(/\s*(\.{1}|::)\s*$/)
@@ -149,9 +156,12 @@ module Solargraph
             in_whitespace = true
           else
             if brackets.zero? and parens.zero? and squares.zero? and in_whitespace
+              # @sg-ignore Need to add nil check here
               unless char == '.' or @source.code[index+1..-1].strip.start_with?('.')
                 old = @source.code[index+1..-1]
+                # @sg-ignore Need to add nil check here
                 nxt = @source.code[index+1..-1].lstrip
+                # @sg-ignore Need to add nil check here
                 index += (@source.code[index+1..-1].length - @source.code[index+1..-1].lstrip.length)
                 break
               end

data/lib/solargraph/source/updater.rb

@@ -29,6 +29,7 @@ module Solargraph
 
       # @param text [String]
       # @param nullable [Boolean]
+      # @sg-ignore changes doesn't mutate @output, so this can never be nil
       # @return [String]
       def write text, nullable = false
         can_nullify = (nullable and changes.length == 1)
@@ -37,6 +38,9 @@ module Solargraph
         @output = text
         @did_nullify = can_nullify
         changes.each do |ch|
+          # @sg-ignore Wrong argument type for
+          #   Solargraph::Source::Change#write: text expected String,
+          #   received String, nil
           @output = ch.write(@output, can_nullify)
         end
         @output

data/lib/solargraph/source.rb

@@ -60,6 +60,8 @@ module Solargraph
     # @param c1 [Integer]
     # @param l2 [Integer]
     # @param c2 [Integer]
+    #
+    # @sg-ignore Need to add nil check here
     # @return [String]
     def from_to l1, c1, l2, c2
       b = Solargraph::Position.line_char_to_offset(code, l1, c1)
@@ -81,7 +83,7 @@ module Solargraph
     #
     # @param line [Integer]
     # @param column [Integer]
-    # @return [Array<AST::Node>]
+    # @return [Array<Parser::AST::Node>]
     def tree_at(line, column)
       position = Position.new(line, column)
       stack = []
@@ -131,20 +133,29 @@ module Solargraph
       return false if Position.to_offset(code, position) >= code.length
       string_nodes.each do |node|
         range = Range.from_node(node)
+        # @sg-ignore Need to add nil check here
         next if range.ending.line < position.line
+        # @sg-ignore Need to add nil check here
         break if range.ending.line > position.line
+        # @sg-ignore Need to add nil check here
         return true if node.type == :str && range.include?(position) && range.start != position
+        # @sg-ignore Need to add nil check here
         return true if [:STR, :str].include?(node.type) && range.include?(position) && range.start != position
         if node.type == :dstr
           inner = node_at(position.line, position.column)
           next if inner.nil?
           inner_range = Range.from_node(inner)
+          # @sg-ignore Need to add nil check here
           next unless range.include?(inner_range.ending)
           return true if inner.type == :str
+          # @sg-ignore Need to add nil check here
           inner_code = at(Solargraph::Range.new(inner_range.start, position))
+          # @sg-ignore Need to add nil check here
           return true if (inner.type == :dstr && inner_range.ending.character <= position.character) && !inner_code.end_with?('}') ||
+                         # @sg-ignore Need to add nil check here
                          (inner.type != :dstr && inner_range.ending.line == position.line && position.character <= inner_range.ending.character && inner_code.end_with?('}'))
         end
+        # @sg-ignore Need to add nil check here
         break if range.ending.line > position.line
       end
       false
@@ -181,17 +192,22 @@ module Solargraph
     # @return [String]
     def code_for(node)
       rng = Range.from_node(node)
+      # @sg-ignore Need to add nil check here
       b = Position.line_char_to_offset(code, rng.start.line, rng.start.column)
+      # @sg-ignore Need to add nil check here
       e = Position.line_char_to_offset(code, rng.ending.line, rng.ending.column)
       frag = code[b..e-1].to_s
       frag.strip.gsub(/,$/, '')
     end
 
-    # @param node [Parser::AST::Node]
+    # @param node [AST::Node]
+    #
     # @return [String, nil]
     def comments_for node
       rng = Range.from_node(node)
+      # @sg-ignore Need to add nil check here
       stringified_comments[rng.start.line] ||= begin
+        # @sg-ignore Need to add nil check here
         buff = associated_comments[rng.start.line]
         buff ? stringify_comment_array(buff) : nil
       end
@@ -219,6 +235,7 @@ module Solargraph
     # @return [Array<Range>]
     def folding_ranges
       @folding_ranges ||= begin
+        # @type [Array<Range>]
         result = []
         inner_folding_ranges node, result
         result.concat foldable_comment_block_ranges
@@ -232,7 +249,7 @@ module Solargraph
 
     # Get a hash of comments grouped by the line numbers of the associated code.
     #
-    # @return [Hash{Integer => String}]
+    # @return [Hash{Integer => String, nil}]
     def associated_comments
       @associated_comments ||= begin
         # @type [Hash{Integer => String}]
@@ -265,18 +282,23 @@ module Solargraph
       cursor
     end
 
-    # @param top [Parser::AST::Node]
+    # @param top [Parser::AST::Node, nil]
     # @param result [Array<Range>]
     # @param parent [Symbol, nil]
     # @return [void]
     def inner_folding_ranges top, result = [], parent = nil
       return unless Parser.is_ast_node?(top)
+      # @sg-ignore Translate to something flow sensitive typing understands
       if FOLDING_NODE_TYPES.include?(top.type)
+        # @sg-ignore Translate to something flow sensitive typing understands
         range = Range.from_node(top)
+        # @sg-ignore Need to add nil check here
         if result.empty? || range.start.line > result.last.start.line
+          # @sg-ignore Need to add nil check here
           result.push range unless range.ending.line - range.start.line < 2
         end
       end
+      # @sg-ignore Translate to something flow sensitive typing understands
       top.children.each do |child|
         inner_folding_ranges(child, result, top.type)
       end
@@ -298,6 +320,7 @@ module Solargraph
           ctxt.concat p
         else
           here = p.index(/[^ \t]/)
+          # @sg-ignore flow sensitive typing should be able to handle redefinition
           skip = here if skip.nil? || here < skip
           ctxt.concat p[skip..-1]
         end
@@ -308,7 +331,7 @@ module Solargraph
 
     # A hash of line numbers and their associated comments.
     #
-    # @return [Hash{Integer => Array<String>, nil}]
+    # @return [Hash{Integer => String}]
     def stringified_comments
       @stringified_comments ||= {}
     end
@@ -348,9 +371,11 @@ module Solargraph
     def string_nodes_in n
       result = []
       if Parser.is_ast_node?(n)
+        # @sg-ignore Translate to something flow sensitive typing understands
         if n.type == :str || n.type == :dstr || n.type == :STR || n.type == :DSTR
           result.push n
         else
+          # @sg-ignore Translate to something flow sensitive typing understands
           n.children.each{ |c| result.concat string_nodes_in(c) }
         end
       end
@@ -364,6 +389,7 @@ module Solargraph
     def inner_tree_at node, position, stack
       return if node.nil?
       here = Range.from_node(node)
+      # @sg-ignore Need to add nil check here
       if here.contain?(position)
         stack.unshift node
         node.children.each do |c|
@@ -396,7 +422,7 @@ module Solargraph
       end
       @finalized = true
       begin
-        @node, @comments = Solargraph::Parser.parse_with_comments(@code, filename)
+        @node, @comments = Solargraph::Parser.parse_with_comments(@code, filename, 0)
         @parsed = true
         @repaired = @code
       rescue Parser::SyntaxError, EncodingError => e
@@ -412,7 +438,7 @@ module Solargraph
         end
         error_ranges.concat(changes.map(&:range))
         begin
-          @node, @comments = Solargraph::Parser.parse_with_comments(@repaired, filename)
+          @node, @comments = Solargraph::Parser.parse_with_comments(@repaired, filename, 0)
           @parsed = true
         rescue Parser::SyntaxError, EncodingError => e
           @node = nil

data/lib/solargraph/source_map/clip.rb

@@ -12,6 +12,7 @@ module Solargraph
         @api_map = api_map
         @cursor = cursor
         closure_pin = closure
+        # @sg-ignore Need to add nil check here
         closure_pin.rebind(api_map) if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
       end
 
@@ -20,6 +21,7 @@ module Solargraph
         return [] if cursor.comment? || cursor.chain.literal?
         result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
+        # @sg-ignore Need to add nil check here
         result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
         result
       end
@@ -78,7 +80,7 @@ module Solargraph
       # @param phrase [String]
       # @return [Array<Solargraph::Pin::Base>]
       def translate phrase
-        chain = Parser.chain(Parser.parse(phrase))
+        chain = Parser.chain(Parser.parse(phrase, cursor.filename, cursor.position.line))
         chain.define(api_map, closure, locals)
       end
 
@@ -92,6 +94,7 @@ module Solargraph
 
       # @return [SourceMap]
       def source_map
+        # @sg-ignore Need to add nil check here
         @source_map ||= api_map.source_map(cursor.filename)
       end
 
@@ -150,16 +153,23 @@ module Solargraph
       # @return [Completion]
       def tag_complete
         result = []
+        # @sg-ignore Need to add nil check here
         match = source_map.code[0..cursor.offset-1].match(/[\[<, ]([a-z0-9_:]*)\z/i)
         if match
+          # @sg-ignore Need to add nil check here
           full = match[1]
+          # @sg-ignore Need to add nil check here
           if full.include?('::')
+            # @sg-ignore Need to add nil check here
             if full.end_with?('::')
+              # @sg-ignore Need to add nil check here
               result.concat api_map.get_constants(full[0..-3], *gates)
             else
+              # @sg-ignore Need to add nil check here
               result.concat api_map.get_constants(full.split('::')[0..-2].join('::'), *gates)
             end
           else
+            # @sg-ignore Need to add nil check here
             result.concat api_map.get_constants('', full.end_with?('::') ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
           end
         end
@@ -176,6 +186,7 @@ module Solargraph
             cursor.chain.base.infer(api_map, context_pin, locals)
           else
             if full.include?('::') && cursor.chain.links.length == 1
+              # @sg-ignore Need to add nil check here
               ComplexType.try_parse(full.split('::')[0..-2].join('::'))
             elsif cursor.chain.links.length > 1
               ComplexType.try_parse(full)
@@ -199,7 +210,7 @@ module Solargraph
             if cursor.word.start_with?('@@')
               return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
             elsif cursor.word.start_with?('@')
-              return package_completions(api_map.get_instance_variable_pins(closure.binder.namespace, closure.binder.scope))
+              return package_completions(api_map.get_instance_variable_pins(closure.full_context.namespace, closure.context.scope))
             elsif cursor.word.start_with?('$')
               return package_completions(api_map.get_global_variable_pins)
             end

data/lib/solargraph/source_map/data.rb

@@ -8,13 +8,16 @@ module Solargraph
         @source = source
       end
 
+      # @sg-ignore Translate to something flow sensitive typing understands
       # @return [Array<Solargraph::Pin::Base>]
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1100
       def pins
         generate
         @pins || []
       end
 
-      # @return [Array<Solargraph::LocalVariable>]
+      # @sg-ignore Translate to something flow sensitive typing understands
+      # @return [Array<Solargraph::Pin::LocalVariable>]
       def locals
         generate
         @locals || []

data/lib/solargraph/source_map/mapper.rb

@@ -24,6 +24,7 @@ module Solargraph
         @code = source.code
         @comments = source.comments
         @pins, @locals = Parser.map(source)
+        # @param p [Solargraph::Pin::Base]
         @pins.each { |p| p.source = :code }
         @locals.each { |l| l.source = :code }
         process_comment_directives
@@ -48,6 +49,7 @@ module Solargraph
         # @param source [Source]
         # @return [Array]
         def map source
+          # @sg-ignore Need to add nil check here
           return new.unmap(source.filename, source.code) unless source.parsed?
           new.map source
         end
@@ -62,6 +64,7 @@ module Solargraph
       # @param position [Solargraph::Position]
       # @return [Solargraph::Pin::Closure]
       def closure_at(position)
+        # @sg-ignore Need to add nil check here
         pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
       end
 
@@ -90,11 +93,13 @@ module Solargraph
       def find_directive_line_number comment, tag, start
         # Avoid overruning the index
         return start unless start < comment.lines.length
+        # @sg-ignore Need to add nil check here
         num = comment.lines[start..-1].find_index do |line|
           # Legacy method directives might be `@method` instead of `@!method`
           # @todo Legacy syntax should probably emit a warning
           line.include?("@!#{tag}") || (tag == 'method' && line.include?("@#{tag}"))
         end
+        # @sg-ignore Need to add nil check here
         num.to_i + start
       end
 
@@ -103,17 +108,21 @@ module Solargraph
       # @param directive [YARD::Tags::Directive]
       # @return [void]
       def process_directive source_position, comment_position, directive
+        # @sg-ignore Need to add nil check here
         docstring = Solargraph::Source.parse_docstring(directive.tag.text).to_docstring
         location = Location.new(@filename, Range.new(comment_position, comment_position))
         case directive.tag.tag_name
         when 'method'
           namespace = closure_at(source_position) || @pins.first
+          # @todo Missed nil violation
+          # @todo Need to add nil check here
           if namespace.location.range.start.line < comment_position.line
             namespace = closure_at(comment_position)
           end
           begin
             src = Solargraph::Source.load_string("def #{directive.tag.name};end", @source.filename)
             region = Parser::Region.new(source: src, closure: namespace)
+            # @type [Array<Pin::Method>]
             method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
             gen_pin = method_gen_pins.last
             return if gen_pin.nil?
@@ -165,10 +174,13 @@ module Solargraph
         when 'visibility'
 
             kind = directive.tag.text&.to_sym
+            # @sg-ignore Need to look at Tuple#include? handling
             return unless [:private, :protected, :public].include?(kind)
 
             name = directive.tag.name
             closure = closure_at(source_position) || @pins.first
+            # @todo Missed nil violation
+            # @todo Need to add nil check here
             if closure.location.range.start.line < comment_position.line
               closure = closure_at(comment_position)
             end
@@ -186,6 +198,7 @@ module Solargraph
         when 'parse'
           begin
             ns = closure_at(source_position)
+            # @sg-ignore Need to add nil check here
             src = Solargraph::Source.load_string(directive.tag.text, @source.filename)
             region = Parser::Region.new(source: src, closure: ns)
             # @todo These pins may need to be marked not explicit
@@ -195,7 +208,11 @@ module Solargraph
             else
               comment_position.line
             end
-            Parser.process_node(src.node, region, @pins)
+            locals = []
+            ivars = []
+            Parser.process_node(src.node, region, @pins, locals, ivars)
+            @pins.concat ivars
+            # @sg-ignore Need to add nil check here
             @pins[index..-1].each do |p|
               # @todo Smelly instance variable access
               p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
@@ -206,8 +223,10 @@ module Solargraph
           end
         when 'domain'
           namespace = closure_at(source_position) || Pin::ROOT_PIN
+          # @sg-ignore flow sensitive typing should be able to handle redefinition
           namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
         when 'override'
+          # @sg-ignore Need to add nil check here
           pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
                                                  source: :source_map)
         when 'macro'
@@ -217,7 +236,9 @@ module Solargraph
 
       # @param line1 [Integer]
       # @param line2 [Integer]
+      # @sg-ignore Need to add nil check here
       def no_empty_lines?(line1, line2)
+        # @sg-ignore Need to add nil check here
         @code.lines[line1..line2].none? { |line| line.strip.empty? }
       end
 
@@ -235,6 +256,7 @@ module Solargraph
             started = true
           elsif started && !p.strip.empty?
             cur = p.index(/[^ ]/)
+            # @sg-ignore Need to add nil check here
             num = cur if cur < num
           end
           ctxt += "#{p[num..-1]}" if started
@@ -248,6 +270,7 @@ module Solargraph
         code_lines = @code.lines
         @source.associated_comments.each do |line, comments|
           src_pos = line ? Position.new(line, code_lines[line].to_s.chomp.index(/[^\s]/) || 0) : Position.new(code_lines.length, 0)
+          # @sg-ignore Need to add nil check here
           com_pos = Position.new(line + 1 - comments.lines.length, 0)
           process_comment(src_pos, com_pos, comments)
         end

data/lib/solargraph/source_map.rb

@@ -34,6 +34,8 @@ module Solargraph
     # @param source [Source]
     def initialize source
       @source = source
+      # @type [Array<Pin::Base>, nil]
+      @convention_pins = nil
 
       conventions_environ.merge Convention.for_local(self) unless filename.nil?
       # FIXME: unmemoizing the document_symbols in case it was called and memoized from any of conventions above
@@ -63,7 +65,7 @@ module Solargraph
       @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
     end
 
-    # @return [String]
+    # @return [String, nil]
     def filename
       source.filename
     end
@@ -84,6 +86,7 @@ module Solargraph
     end
 
     # all pins except Solargraph::Pin::Reference::Reference
+    #
     # @return [Array<Pin::Base>]
     def document_symbols
       @document_symbols ||= (pins + convention_pins).select do |pin|
@@ -97,7 +100,7 @@ module Solargraph
       Pin::Search.new(document_symbols, query).results
     end
 
-    # @param position [Position]
+    # @param position [Position, Array(Integer, Integer)]
     # @return [Source::Cursor]
     def cursor_at position
       Source::Cursor.new(source, position)
@@ -125,7 +128,7 @@ module Solargraph
 
     # @param line [Integer]
     # @param character [Integer]
-    # @return [Pin::Namespace,Pin::Method,Pin::Block]
+    # @return [Pin::Closure]
     def locate_closure_pin line, character
       _locate_pin line, character, Pin::Closure
     end
@@ -143,7 +146,7 @@ module Solargraph
     # @return [Array<Pin::LocalVariable>]
     def locals_at(location)
       return [] if location.filename != filename
-      closure = locate_named_path_pin(location.range.start.line, location.range.start.character)
+      closure = locate_closure_pin(location.range.start.line, location.range.start.character)
       locals.select { |pin| pin.visible_at?(closure, location) }
     end
 
@@ -178,6 +181,7 @@ module Solargraph
 
     # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
     def pin_class_hash
+      # @todo Need to support generic resolution in classify and transform_values
       @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
     end
 
@@ -191,10 +195,12 @@ module Solargraph
       @convention_pins || []
     end
 
+    # @generic T
     # @param line [Integer]
     # @param character [Integer]
-    # @param klasses [Array<Class>]
-    # @return [Pin::Base, nil]
+    # @param klasses [Array<Class<generic<T>>>]
+    # @return [generic<T>, nil]
+    # @sg-ignore Need better generic inference here
     def _locate_pin line, character, *klasses
       position = Position.new(line, character)
       found = nil
@@ -202,7 +208,9 @@ module Solargraph
         # @todo Attribute pins should not be treated like closures, but
         #   there's probably a better way to handle it
         next if pin.is_a?(Pin::Method) && pin.attribute?
+        # @sg-ignore Need to add nil check here
         found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
+        # @sg-ignore Need to add nil check here
         break if pin.location.range.start.line > line
       end
       # Assuming the root pin is always valid

data/lib/solargraph/type_checker/problem.rb

@@ -5,19 +5,21 @@ module Solargraph
     # A problem reported by TypeChecker.
     #
     class Problem
+      # @todo Missed nil violation
       # @return [Solargraph::Location]
       attr_reader :location
 
       # @return [String]
       attr_reader :message
 
+      # @todo Missed nil violation
       # @return [Pin::Base]
       attr_reader :pin
 
       # @return [String, nil]
       attr_reader :suggestion
 
-      # @param location [Solargraph::Location]
+      # @param location [Solargraph::Location, nil]
       # @param message [String]
       # @param pin [Solargraph::Pin::Base, nil]
       # @param suggestion [String, nil]