solargraph 0.58.3 → 0.59.0.dev.1

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]

data/lib/solargraph/type_checker/rules.rb

@@ -60,8 +60,81 @@ module Solargraph
         report?(:validate_tags, :typed)
       end
 
-      def require_all_return_types_match_inferred?
-        report?(:require_all_return_types_match_inferred, :alpha)
+      def require_inferred_type_params?
+        report?(:require_inferred_type_params, :alpha)
+      end
+
+      #
+      # False negatives:
+      #
+      # @todo 4: Missed nil violation
+      #
+      # pending code fixes (277):
+      #
+      # @todo 281: Need to add nil check here
+      # @todo 22: Translate to something flow sensitive typing understands
+      # @todo 3: Need a downcast here
+      #
+      # flow sensitive typing could handle (96):
+      #
+      # @todo 36: flow sensitive typing needs to handle attrs
+      # @todo 29: flow sensitive typing should be able to handle redefinition
+      # @todo 19: flow sensitive typing needs to narrow down type with an if is_a? check
+      # @todo 13: Need to validate config
+      # @todo 8: flow sensitive typing should support .class == .class
+      # @todo 6: need boolish support for ? methods
+      # @todo 5: literal arrays in this module turn into ::Solargraph::Source::Chain::Array
+      # @todo 5: flow sensitive typing needs to handle 'raise if'
+      # @todo 5: flow sensitive typing needs better handling of ||= on lvars
+      # @todo 4: flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
+      # @todo 4: nil? support in flow sensitive typing
+      # @todo 2: downcast output of Enumerable#select
+      # @todo 2: flow sensitive typing should handle return nil if location&.name.nil?
+      # @todo 2: flow sensitive typing should handle is_a? and next
+      # @todo 2: Need to look at Tuple#include? handling
+      # @todo 2: Should better support meaning of '&' in RBS
+      # @todo 2: (*) flow sensitive typing needs to handle "if foo = bar"
+      # @todo 2: flow sensitive typing needs to handle "if foo = bar"
+      # @todo 2: Need to handle duck-typed method calls on union types
+      # @todo 2: Need better handling of #compact
+      # @todo 2: flow sensitive typing should allow shadowing of Kernel#caller
+      # @todo 2: flow sensitive typing ought to be able to handle 'when ClassName'
+      # @todo 1: flow sensitive typing not smart enough to handle this case
+      # @todo 1: flow sensitive typing needs to handle if foo = bar
+      # @todo 1: flow sensitive typing needs to handle "if foo.nil?"
+      # @todo 1: flow sensitive typing should support case/when
+      # @todo 1: flow sensitive typing should support ivars
+      # @todo 1: Need to support this in flow sensitive typing
+      # @todo 1: flow sensitive typing needs to handle self.class == other.class
+      # @todo 1: flow sensitive typing needs to remove literal with
+      # @todo 1: flow sensitive typing needs to understand reassignment
+      # @todo 1: flow sensitive typing should be able to identify more blocks that always return
+      # @todo 1: should warn on nil dereference below
+      # @todo 1: flow sensitive typing needs to create separate ranges for postfix if
+      # @todo 1: flow sensitive typing needs to handle constants
+      # @todo 1: flow sensitive typing needs to eliminate literal from union with return if foo == :bar
+      def require_all_unique_types_match_expected?
+        report?(:require_all_unique_types_match_expected, :strong)
+      end
+
+      def require_all_unique_types_support_call?
+        report?(:require_all_unique_types_support_call, :strong)
+      end
+
+      def require_no_undefined_args?
+        report?(:require_no_undefined_args, :alpha)
+      end
+
+      def require_generics_resolved?
+        report?(:require_generics_resolved, :alpha)
+      end
+
+      def require_interfaces_resolved?
+        report?(:require_interfaces_resolved, :alpha)
+      end
+
+      def require_downcasts?
+        report?(:require_downcasts, :alpha)
       end
 
       # We keep this at strong because if you added an @ sg-ignore to