solargraph 0.58.2 → 0.59.0.dev.2

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,13 +35,17 @@ 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)
+          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
-          result = ":#{result}" if source.code[0..offset-result.length-1].end_with?(':') and !source.code[0..offset-result.length-1].end_with?('::')
+          # @sg-ignore Need to add nil check here
+          if source.code[0..(offset - result.length - 1)].end_with?(':') && !source.code[0..(offset - result.length - 1)].end_with?('::')
+            result = ":#{result}"
+          end
           result
         end
       end
@@ -50,16 +54,17 @@ 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)
+          match = source.code[offset..].to_s.match(end_word_pattern)
           match ? match[0] : ''
         end
       end
 
       # @return [Boolean]
       def start_of_constant?
-        source.code[offset-2, 2] == '::'
+        source.code[offset - 2, 2] == '::'
       end
 
       # The range of the word at the current position.
@@ -110,6 +115,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
@@ -122,18 +128,18 @@ module Solargraph
 
       # @return [Position]
       def node_position
-        @node_position ||= begin
-          if start_of_word.empty?
-            match = source.code[0, offset].match(/\s*(\.|:+)\s*$/)
-            if match
-              Position.from_offset(source.code, offset - match[0].length)
-            else
-              position
-            end
-          else
-            position
-          end
-        end
+        @node_position ||= 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
+                             end
+                           else
+                             position
+                           end
       end
 
       # @return [Parser::AST::Node, nil]

data/lib/solargraph/source/encoding_fixes.rb

@@ -10,13 +10,12 @@ module Solargraph
       # @param string [String]
       # @return [String]
       def normalize string
-        begin
-          string.dup.force_encoding('UTF-8')
-        rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError => e
-          # @todo Improve error handling
-          Solargraph::Logging.logger.warn "Normalize error: #{e.message}"
-          string
-        end
+        string.dup.force_encoding('UTF-8')
+      rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError,
+             ::Encoding::InvalidByteSequenceError => e
+        # @todo Improve error handling
+        Solargraph::Logging.logger.warn "Normalize error: #{e.message}"
+        string
       end
     end
   end

data/lib/solargraph/source/source_chainer.rb

@@ -32,26 +32,47 @@ module Solargraph
       # @return [Source::Chain]
       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]+\.$/
-        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)
+        if phrase =~ /^[0-9]+\.$/
+          return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
+                            Chain::UNDEFINED_CALL])
+        end
+        if phrase.start_with?(':') && !phrase.start_with?('::')
+          return Chain.new([Chain::Literal.new('Symbol',
+                                               # @sg-ignore Need to add nil check here
+                                               phrase[1..].to_sym)])
+        end
+        if end_of_phrase.strip == '::' && source.code[Position.to_offset(
+          source.code, position
+        )].to_s.match?(/[a-z]/i)
+          return SourceChainer.chain(source,
+                                     Position.new(position.line,
+                                                  position.character + 1))
+        end
         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)}
+            unless source.error_ranges.any? do |r|
+              r.nil? || r.include?(fixed_position)
+            end
+              node, parent = source.tree_at(fixed_position.line,
+                                            fixed_position.column)[0..2]
+            end
             # 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,14 +100,16 @@ 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]
+        @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)]
+        @fixed_phrase ||= phrase[0..-(end_of_phrase.length + 1)]
       end
 
       # @return [Position]
@@ -95,6 +118,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*$/)
@@ -137,47 +161,47 @@ module Solargraph
         brackets = 0
         squares = 0
         parens = 0
-        index -=1
+        index -= 1
         in_whitespace = false
         while index >= 0
           pos = Position.from_offset(@source.code, index)
-          break if index > 0 and @source.comment_at?(pos)
-          break if brackets > 0 or parens > 0 or squares > 0
+          break if index.positive? && @source.comment_at?(pos)
+          break if brackets.positive? || parens.positive? || squares.positive?
           char = @source.code[index, 1]
           break if char.nil? # @todo Is this the right way to handle this?
-          if brackets.zero? and parens.zero? and squares.zero? and [' ', "\r", "\n", "\t"].include?(char)
+          if brackets.zero? && parens.zero? && squares.zero? && [' ', "\r", "\n", "\t"].include?(char)
             in_whitespace = true
           else
-            if brackets.zero? and parens.zero? and squares.zero? and in_whitespace
-              unless char == '.' or @source.code[index+1..-1].strip.start_with?('.')
-                old = @source.code[index+1..-1]
-                nxt = @source.code[index+1..-1].lstrip
-                index += (@source.code[index+1..-1].length - @source.code[index+1..-1].lstrip.length)
-                break
-              end
+            # @sg-ignore Need to add nil check here
+            if brackets.zero? && parens.zero? && squares.zero? && in_whitespace && !((char == '.') || @source.code[(index + 1)..].strip.start_with?('.'))
+              @source.code[(index + 1)..]
+              # @sg-ignore Need to add nil check here
+              @source.code[(index + 1)..].lstrip
+              # @sg-ignore Need to add nil check here
+              index += (@source.code[(index + 1)..].length - @source.code[(index + 1)..].lstrip.length)
+              break
             end
-            if char == ')'
-              parens -=1
-            elsif char == ']'
-              squares -=1
-            elsif char == '}'
+            case char
+            when ')'
+              parens -= 1
+            when ']'
+              squares -= 1
+            when '}'
               brackets -= 1
-            elsif char == '('
+            when '('
               parens += 1
-            elsif char == '{'
+            when '{'
               brackets += 1
-            elsif char == '['
+            when '['
               squares += 1
             end
-            if brackets.zero? and parens.zero? and squares.zero?
+            if brackets.zero? && parens.zero? && squares.zero?
               break if ['"', "'", ',', ';', '%'].include?(char)
               break if ['!', '?'].include?(char) && index < offset - 1
               break if char == '$'
               if char == '@'
                 index -= 1
-                if @source.code[index, 1] == '@'
-                  index -= 1
-                end
+                index -= 1 if @source.code[index, 1] == '@'
                 break
               end
             elsif parens == 1 || brackets == 1 || squares == 1

data/lib/solargraph/source/updater.rb

@@ -29,14 +29,18 @@ 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)
-        return @output if @input == text and can_nullify == @did_nullify
+        return @output if (@input == text) && (can_nullify == @did_nullify)
         @input = text
         @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,11 +60,13 @@ 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)
       e = Solargraph::Position.line_char_to_offset(code, l2, c2)
-      code[b..e-1]
+      code[b..(e - 1)]
     end
 
     # Get the nearest node that contains the specified index.
@@ -72,7 +74,7 @@ module Solargraph
     # @param line [Integer]
     # @param column [Integer]
     # @return [AST::Node]
-    def node_at(line, column)
+    def node_at line, column
       tree_at(line, column).first
     end
 
@@ -81,8 +83,8 @@ module Solargraph
     #
     # @param line [Integer]
     # @param column [Integer]
-    # @return [Array<AST::Node>]
-    def tree_at(line, column)
+    # @return [Array<Parser::AST::Node>]
+    def tree_at line, column
       position = Position.new(line, column)
       stack = []
       inner_tree_at node, position, 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
-        return true if [:STR, :str].include?(node.type) && range.include?(position) && range.start != position
+        # @sg-ignore Need to add nil check here
+        return true if %i[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))
-          return true if (inner.type == :dstr && inner_range.ending.character <= position.character) && !inner_code.end_with?('}') ||
+          # @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
@@ -160,7 +171,7 @@ module Solargraph
     def comment_at? position
       comment_ranges.each do |range|
         return true if range.include?(position) ||
-          (range.ending.line == position.line && range.ending.column < position.column)
+                       (range.ending.line == position.line && range.ending.column < position.column)
         break if range.ending.line > position.line
       end
       false
@@ -179,19 +190,24 @@ module Solargraph
 
     # @param node [Parser::AST::Node]
     # @return [String]
-    def code_for(node)
+    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 = 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
@@ -208,8 +224,8 @@ module Solargraph
     end
 
     FOLDING_NODE_TYPES = %i[
-        class sclass module def defs if str dstr array while unless kwbegin hash block
-      ].freeze
+      class sclass module def defs if str dstr array while unless kwbegin hash block
+    ].freeze
 
     # Get an array of ranges that can be folded, e.g., the range of a class
     # definition or an if condition.
@@ -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,22 @@ 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)
-        if result.empty? || range.start.line > result.last.start.line
-          result.push range unless range.ending.line - range.start.line < 2
+        # @sg-ignore Need to add nil check here
+        if (result.empty? || range.start.line > result.last.start.line) && range.ending.line - range.start.line >= 2
+          result.push range
         end
       end
+      # @sg-ignore Translate to something flow sensitive typing understands
       top.children.each do |child|
         inner_folding_ranges(child, result, top.type)
       end
@@ -290,7 +311,7 @@ module Solargraph
       ctxt = String.new('')
       started = false
       skip = nil
-      comments.lines.each { |l|
+      comments.lines.each do |l|
         # Trim the comment and minimum leading whitespace
         p = l.force_encoding('UTF-8').encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#+/, '')
         if p.strip.empty?
@@ -298,17 +319,18 @@ 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]
+          ctxt.concat p[skip..]
         end
         started = true
-      }
+      end
       ctxt
     end
 
     # 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
@@ -331,7 +353,7 @@ module Solargraph
       return [] unless synchronized?
       result = []
       grouped = []
-      comments.keys.each do |l|
+      comments.each_key do |l|
         if grouped.empty? || l == grouped.last + 1
           grouped.push l
         else
@@ -348,10 +370,12 @@ module Solargraph
     def string_nodes_in n
       result = []
       if Parser.is_ast_node?(n)
-        if n.type == :str || n.type == :dstr || n.type == :STR || n.type == :DSTR
+        # @sg-ignore Translate to something flow sensitive typing understands
+        if %i[str dstr STR DSTR].include?(n.type)
           result.push n
         else
-          n.children.each{ |c| result.concat string_nodes_in(c) }
+          # @sg-ignore Translate to something flow sensitive typing understands
+          n.children.each { |c| result.concat string_nodes_in(c) }
         end
       end
       result
@@ -364,13 +388,13 @@ module Solargraph
     def inner_tree_at node, position, stack
       return if node.nil?
       here = Range.from_node(node)
-      if here.contain?(position)
-        stack.unshift node
-        node.children.each do |c|
-          next unless Parser.is_ast_node?(c)
-          next if c.loc.expression.nil?
-          inner_tree_at(c, position, stack)
-        end
+      # @sg-ignore Need to add nil check here
+      return unless here.contain?(position)
+      stack.unshift node
+      node.children.each do |c|
+        next unless Parser.is_ast_node?(c)
+        next if c.loc.expression.nil?
+        inner_tree_at(c, position, stack)
       end
     end
 
@@ -396,10 +420,10 @@ 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
+      rescue Parser::SyntaxError, EncodingError
         @node = nil
         @comments = {}
         @parsed = false
@@ -412,9 +436,9 @@ 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
+        rescue Parser::SyntaxError, EncodingError
           @node = nil
           @comments = {}
           @parsed = false
@@ -427,7 +451,7 @@ module Solargraph
 
     # @param val [String]
     # @return [String]
-    def code=(val)
+    def code= val
       @code_lines = nil
       @finalized = false
       @code = val