solargraph 0.58.3 → 0.60.3

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,21 +190,26 @@ 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
+        stringify_comment_array(buff)
       end
     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,20 +249,20 @@ module Solargraph
 
     # Get a hash of comments grouped by the line numbers of the associated code.
     #
-    # @return [Hash{Integer => String}]
+    # @return [Hash{Integer => Array<String>}]
     def associated_comments
       @associated_comments ||= begin
         # @type [Hash{Integer => String}]
         result = {}
-        buffer = String.new('')
+        buffer = []
         # @type [Integer, nil]
         last = nil
         comments.each_pair do |num, snip|
           if !last || num == last + 1
-            buffer.concat "#{snip.text}\n"
+            buffer.push "#{snip.text}\n"
           else
             result[first_not_empty_from(last + 1)] = buffer.clone
-            buffer.replace "#{snip.text}\n"
+            buffer.replace ["#{snip.text}\n"]
           end
           last = num
         end
@@ -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
@@ -284,31 +305,36 @@ module Solargraph
 
     # Get a string representation of an array of comments.
     #
-    # @param comments [String]
+    # @param comments [Array<String>, nil]
     # @return [String]
     def stringify_comment_array comments
-      ctxt = String.new('')
+      ctxt = []
       started = false
       skip = nil
-      comments.lines.each { |l|
+      comments&.each do |l|
+        if l =~ /^#-\R/
+          ctxt.clear
+          next
+        end
         # Trim the comment and minimum leading whitespace
         p = l.force_encoding('UTF-8').encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#+/, '')
         if p.strip.empty?
           next unless started
-          ctxt.concat p
+          ctxt.push 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.push p[skip..]
         end
         started = true
-      }
-      ctxt
+      end
+      ctxt.join('')
     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 +357,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 +374,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 +392,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 +424,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 +440,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 +455,7 @@ module Solargraph
 
     # @param val [String]
     # @return [String]
-    def code=(val)
+    def code= val
       @code_lines = nil
       @finalized = false
       @code = val

data/lib/solargraph/source_map/clip.rb

@@ -12,7 +12,10 @@ module Solargraph
         @api_map = api_map
         @cursor = cursor
         closure_pin = closure
-        closure_pin.rebind(api_map) if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
+        # @sg-ignore Need to add nil check here
+        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
+          closure_pin.rebind(api_map)
+        end
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
@@ -20,7 +23,12 @@ module Solargraph
         return [] if cursor.comment? || cursor.chain.literal?
         result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
-        result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
+        if result.empty?
+          result.concat((source_map.pins + source_map.locals).select do |p|
+            # @sg-ignore Need to add nil check here
+            p.name == cursor.word && p.location.range.contain?(cursor.position)
+          end)
+        end
         result
       end
 
@@ -32,7 +40,9 @@ module Solargraph
       # @return [Completion]
       def complete
         return package_completions([]) if !source_map.source.parsed? || cursor.string?
-        return package_completions(api_map.get_symbols) if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+          return package_completions(api_map.get_symbols)
+        end
         return Completion.new([], cursor.range) if cursor.chain.literal?
         if cursor.comment?
           tag_complete
@@ -44,8 +54,13 @@ module Solargraph
       # @return [Array<Pin::Method>]
       def signify
         return [] unless cursor.argument?
+        return [] if cursor.recipient_node.nil?
         chain = Parser.chain(cursor.recipient_node, cursor.filename)
-        chain.define(api_map, context_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
+        name_pin = context_pin
+        if name_pin.nil?
+          name_pin = Pin::ProxyType.anonymous(ComplexType.try_parse('::Object'))
+        end
+        chain.define(api_map, name_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
       end
 
       # @return [ComplexType]
@@ -78,7 +93,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 +107,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
 
@@ -125,12 +141,11 @@ module Solargraph
             next unless param.keyword?
             result.push Pin::KeywordParam.new(pin.location, "#{param.name}:")
           end
-          if !pin.parameters.empty? && pin.parameters.last.kwrestarg?
-            pin.docstring.tags(:param).each do |tag|
-              next if done.include?(tag.name)
-              done.push tag.name
-              result.push Pin::KeywordParam.new(pin.location, "#{tag.name}:")
-            end
+          next unless !pin.parameters.empty? && pin.parameters.last.kwrestarg?
+          pin.docstring.tags(:param).each do |tag|
+            next if done.include?(tag.name)
+            done.push tag.name
+            result.push Pin::KeywordParam.new(pin.location, "#{tag.name}:")
           end
         end
         result
@@ -140,27 +155,34 @@ module Solargraph
       # @return [Completion]
       def package_completions result
         frag_start = cursor.start_of_word.to_s.downcase
-        filtered = result.uniq(&:name).select { |s|
+        filtered = result.uniq(&:name).select do |s|
           s.name.downcase.start_with?(frag_start) &&
-            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
-        }
+            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(!|\?|=)?$/i))
+        end
         Completion.new(filtered, cursor.range)
       end
 
       # @return [Completion]
       def tag_complete
         result = []
-        match = source_map.code[0..cursor.offset-1].match(/[\[<, ]([a-z0-9_:]*)\z/i)
+        # @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
-            result.concat api_map.get_constants('', full.end_with?('::') ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+            # @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
         package_completions(result)
@@ -173,24 +195,24 @@ module Solargraph
         if cursor.chain.constant? || cursor.start_of_constant?
           full = cursor.chain.links.first.word
           type = if cursor.chain.undefined?
-            cursor.chain.base.infer(api_map, context_pin, locals)
-          else
-            if full.include?('::') && cursor.chain.links.length == 1
-              ComplexType.try_parse(full.split('::')[0..-2].join('::'))
-            elsif cursor.chain.links.length > 1
-              ComplexType.try_parse(full)
-            else
-              ComplexType::UNDEFINED
-            end
-          end
+                   cursor.chain.base.infer(api_map, context_pin, locals)
+                 elsif 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)
+                 else
+                   ComplexType::UNDEFINED
+                 end
           if type.undefined?
             if full.include?('::')
               result.concat api_map.get_constants(full, *gates)
             else
-              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) # .select { |pin| pin.name.start_with?(full) }
             end
           else
-            result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
+            result.concat api_map.get_constants(type.namespace,
+                                                cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
           end
         else
           type = cursor.chain.base.infer(api_map, closure, locals)
@@ -199,14 +221,16 @@ 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
             result.concat locals
             result.concat file_global_methods unless closure.binder.namespace.empty?
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
-            result.concat api_map.get_methods(closure.binder.namespace, scope: closure.binder.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods(closure.binder.namespace, scope: closure.binder.scope,
+                                                                        visibility: %i[public private protected])
             result.concat api_map.get_methods('Kernel')
             result.concat api_map.keyword_pins.to_a
           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 || []