solargraph 0.58.2 → 0.59.0.dev.2

data/lib/solargraph/parser/node_processor/base.rb

@@ -16,15 +16,20 @@ module Solargraph
         # @return [Array<Pin::LocalVariable>]
         attr_reader :locals
 
+        # @return [Array<Pin::InstanceVariable>]
+        attr_reader :ivars
+
         # @param node [Parser::AST::Node]
         # @param region [Region]
         # @param pins [Array<Pin::Base>]
         # @param locals [Array<Pin::LocalVariable>]
-        def initialize node, region, pins, locals
+        # @param ivars [Array<Pin::InstanceVariable>]
+        def initialize node, region, pins, locals, ivars
           @node = node
           @region = region
           @pins = pins
           @locals = locals
+          @ivars = ivars
           @processed_children = false
         end
 
@@ -40,6 +45,28 @@ module Solargraph
 
         private
 
+        # @return [Solargraph::Location]
+        def location
+          get_node_location(node)
+        end
+
+        # @return [Solargraph::Position]
+        def position
+          Position.new(node.loc.line, node.loc.column)
+        end
+
+        # @sg-ignore downcast output of Enumerable#select
+        # @return [Solargraph::Pin::Breakable, nil]
+        def enclosing_breakable_pin
+          pins.select { |pin| pin.is_a?(Pin::Breakable) && pin.location&.range&.contain?(position) }.last
+        end
+
+        # @todo downcast output of Enumerable#select
+        # @return [Solargraph::Pin::CompoundStatement, nil]
+        def enclosing_compound_statement_pin
+          pins.select { |pin| pin.is_a?(Pin::CompoundStatement) && pin.location&.range&.contain?(position) }.last
+        end
+
         # @param subregion [Region]
         # @return [void]
         def process_children subregion = region
@@ -47,20 +74,20 @@ module Solargraph
           @processed_children = true
           node.children.each do |child|
             next unless Parser.is_ast_node?(child)
-            NodeProcessor.process(child, subregion, pins, locals)
+            NodeProcessor.process(child, subregion, pins, locals, ivars)
           end
         end
 
         # @param node [Parser::AST::Node]
         # @return [Solargraph::Location]
-        def get_node_location(node)
+        def get_node_location node
           range = Parser.node_range(node)
           Location.new(region.filename, range)
         end
 
         # @param node [Parser::AST::Node]
         # @return [String, nil]
-        def comments_for(node)
+        def comments_for node
           region.source.comments_for(node)
         end
 
@@ -68,6 +95,7 @@ module Solargraph
         # @return [Pin::Closure, nil]
         def named_path_pin position
           pins.select do |pin|
+            # @sg-ignore Need to add nil check here
             pin.is_a?(Pin::Closure) && pin.path && !pin.path.empty? && pin.location.range.contain?(position)
           end.last
         end
@@ -77,6 +105,7 @@ module Solargraph
         # @return [Pin::Closure, nil]
         def block_pin position
           # @todo determine if this can return a Pin::Block
+          # @sg-ignore Need to add nil check here
           pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
         end
 
@@ -84,6 +113,7 @@ module Solargraph
         # @param position [Solargraph::Position]
         # @return [Pin::Closure, nil]
         def closure_pin position
+          # @sg-ignore Need to add nil check here
           pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
         end
       end

data/lib/solargraph/parser/node_processor.rb

@@ -35,27 +35,28 @@ module Solargraph
       # @param node [Parser::AST::Node]
       # @param region [Region]
       # @param pins [Array<Pin::Base>]
-      # @param locals [Array<Pin::BaseVariable>]
-      # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
-      def self.process node, region = Region.new, pins = [], locals = []
+      # @param locals [Array<Pin::LocalVariable>]
+      # @param ivars [Array<Pin::InstanceVariable>]
+      # @return [Array(Array<Pin::Base>, Array<Pin::LocalVariable>, Array<Pin::InstanceVariable>)]
+      def self.process node, region = Region.new, pins = [], locals = [], ivars = []
         if pins.empty?
           pins.push Pin::Namespace.new(
             location: region.source.location,
             name: '',
-            source: :parser,
+            source: :parser
           )
         end
-        return [pins, locals] unless Parser.is_ast_node?(node)
+        return [pins, locals, ivars] unless Parser.is_ast_node?(node)
         node_processor_classes = @@processors[node.type] || [NodeProcessor::Base]
 
         node_processor_classes.each do |klass|
-          processor = klass.new(node, region, pins, locals)
+          processor = klass.new(node, region, pins, locals, ivars)
           process_next = processor.process
 
           break unless process_next
         end
 
-        [pins, locals]
+        [pins, locals, ivars]
       end
     end
   end

data/lib/solargraph/parser/parser_gem/class_methods.rb

@@ -8,19 +8,23 @@ module Solargraph
       module ClassMethods
         # @param code [String]
         # @param filename [String, nil]
+        # @param starting_line [Integer] must be provided so that we
+        #   can find relevant local variables later even if this is just
+        #   a subset of the file in question
         # @return [Array(Parser::AST::Node, Hash{Integer => Solargraph::Parser::Snippet})]
-        def parse_with_comments code, filename = nil
-          node = parse(code, filename)
+        def parse_with_comments code, filename = nil, starting_line = 0
+          node = parse(code, filename, starting_line)
           comments = CommentRipper.new(code, filename, 0).parse
           [node, comments]
         end
 
         # @param code [String]
         # @param filename [String, nil]
-        # @param line [Integer]
+        # @param starting_line [Integer]
+        # @sg-ignore need to understand that raise does not return
         # @return [Parser::AST::Node]
-        def parse code, filename = nil, line = 0
-          buffer = ::Parser::Source::Buffer.new(filename, line)
+        def parse code, filename = nil, starting_line = 0
+          buffer = ::Parser::Source::Buffer.new(filename, starting_line)
           buffer.source = code
           parser.parse(buffer)
         rescue ::Parser::SyntaxError, ::Parser::UnknownEncodingInMagicComment => e
@@ -30,35 +34,43 @@ module Solargraph
         # @return [::Parser::Base]
         def parser
           @parser ||= Prism::Translation::Parser.new(FlawedBuilder.new).tap do |parser|
+            # @sg-ignore Unresolved call to diagnostics on Prism::Translation::Parser
             parser.diagnostics.all_errors_are_fatal = true
+            # @sg-ignore Unresolved call to diagnostics on Prism::Translation::Parser
             parser.diagnostics.ignore_warnings      = true
           end
         end
 
         # @param source [Source]
-        # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
+        # @return [Array(Array<Pin::Base>, Array<Pin::LocalVariable>)]
         def map source
-          NodeProcessor.process(source.node, Region.new(source: source))
+          # @sg-ignore Need to add nil check here
+          pins, locals, ivars = NodeProcessor.process(source.node, Region.new(source: source))
+          pins.concat(ivars)
+          [pins, locals]
         end
 
         # @param source [Source]
         # @param name [String]
         # @return [Array<Location>]
         def references source, name
-          if name.end_with?("=")
+          if name.end_with?('=')
             reg = /#{Regexp.escape name[0..-2]}\s*=/
             # @param code [String]
             # @param offset [Integer]
             # @return [Array(Integer, Integer), Array(nil, nil)]
+            # @sg-ignore Need to add nil check here
             extract_offset = ->(code, offset) { reg.match(code, offset).offset(0) }
           else
             # @param code [String]
             # @param offset [Integer]
             # @return [Array(Integer, Integer), Array(nil, nil)]
+            # @sg-ignore Need to add nil check here
             extract_offset = ->(code, offset) { [soff = code.index(name, offset), soff + name.length] }
           end
           inner_node_references(name, source.node).map do |n|
             rng = Range.from_node(n)
+            # @sg-ignore Need to add nil check here
             offset = Position.to_offset(source.code, rng.start)
             soff, eoff = extract_offset[source.code, offset]
             Location.new(
@@ -86,20 +98,20 @@ module Solargraph
 
         # @return [Source::Chain]
         def chain *args
-          NodeChainer.chain *args
+          NodeChainer.chain(*args)
         end
 
         # @return [Source::Chain]
         def chain_string *args
-          NodeChainer.load_string *args
+          NodeChainer.load_string(*args)
         end
 
         # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
         def process_node *args
-          Solargraph::Parser::NodeProcessor.process *args
+          Solargraph::Parser::NodeProcessor.process(*args)
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [String, nil]
         def infer_literal_node_type node
           NodeMethods.infer_literal_node_type node
@@ -110,7 +122,7 @@ module Solargraph
           parser.version
         end
 
-        # @param node [BasicObject]
+        # @param node [BasicObject, nil]
         # @return [Boolean]
         def is_ast_node? node
           node.is_a?(::Parser::AST::Node)
@@ -124,19 +136,25 @@ module Solargraph
           Range.new(st, en)
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [Array<Range>]
         def string_ranges node
           return [] unless is_ast_node?(node)
           result = []
+          # @sg-ignore Translate to something flow sensitive typing understands
           result.push Range.from_node(node) if node.type == :str
+          # @sg-ignore Translate to something flow sensitive typing understands
           node.children.each do |child|
             result.concat string_ranges(child)
           end
+          # @sg-ignore Translate to something flow sensitive typing understands
           if node.type == :dstr && node.children.last.nil?
+            # @sg-ignore Translate to something flow sensitive typing understands
             last = node.children[-2]
+            # @sg-ignore Need to add nil check here
             unless last.nil?
               rng = Range.from_node(last)
+              # @sg-ignore Need to add nil check here
               pos = Position.new(rng.ending.line, rng.ending.column - 1)
               result.push Range.new(pos, pos)
             end

data/lib/solargraph/parser/parser_gem/flawed_builder.rb

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      # A custom builder for source parsers that ignores character encoding
-      # issues in literal strings.
-      #
-      class FlawedBuilder < ::Parser::Builders::Default
-        # @param token [::Parser::AST::Node]
-        # @return [String]
-        # @sg-ignore
-        def string_value(token)
-          value(token)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      # A custom builder for source parsers that ignores character encoding
+      # issues in literal strings.
+      #
+      class FlawedBuilder < ::Parser::Builders::Default
+        # @param token [::Parser::AST::Node]
+        # @return [String]
+        # @sg-ignore
+        def string_value token
+          value(token)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_chainer.rb

@@ -22,7 +22,7 @@ module Solargraph
         # @return [Source::Chain]
         def chain
           links = generate_links(@node)
-          Chain.new(links, @node, (Parser.is_ast_node?(@node) && @node.type == :splat))
+          Chain.new(links, @node, Parser.is_ast_node?(@node) && @node.type == :splat)
         end
 
         class << self
@@ -35,9 +35,12 @@ module Solargraph
           end
 
           # @param code [String]
+          # @param filename [String]
+          # @param starting_line [Integer]
+          #
           # @return [Source::Chain]
-          def load_string(code)
-            node = Parser.parse(code.sub(/\.$/, ''))
+          def load_string code, filename, starting_line
+            node = Parser.parse(code.sub(/\.$/, ''), filename, starting_line)
             chain = NodeChainer.new(node).chain
             chain.links.push(Chain::Link.new) if code.end_with?('.')
             chain
@@ -60,9 +63,9 @@ module Solargraph
               result.concat generate_links(n.children[0])
               result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             elsif n.children[0].nil?
-              args = []
-              n.children[2..-1].each do |c|
-                args.push NodeChainer.chain(c, @filename, n)
+              # @sg-ignore Need to add nil check here
+              n.children[2..].map do |c|
+                NodeChainer.chain(c, @filename, n)
               end
               result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             else
@@ -90,27 +93,46 @@ module Solargraph
           elsif n.type == :const
             const = unpack_name(n)
             result.push Chain::Constant.new(const)
-          elsif [:lvar, :lvasgn].include?(n.type)
+          elsif %i[lvar lvasgn].include?(n.type)
             result.push Chain::Call.new(n.children[0].to_s, Location.from_node(n))
-          elsif [:ivar, :ivasgn].include?(n.type)
-            result.push Chain::InstanceVariable.new(n.children[0].to_s)
-          elsif [:cvar, :cvasgn].include?(n.type)
+          elsif %i[ivar ivasgn].include?(n.type)
+            result.push Chain::InstanceVariable.new(n.children[0].to_s, n, Location.from_node(n))
+          elsif %i[cvar cvasgn].include?(n.type)
             result.push Chain::ClassVariable.new(n.children[0].to_s)
-          elsif [:gvar, :gvasgn].include?(n.type)
+          elsif %i[gvar gvasgn].include?(n.type)
             result.push Chain::GlobalVariable.new(n.children[0].to_s)
           elsif n.type == :or_asgn
-            new_node = n.updated(n.children[0].type, n.children[0].children + [n.children[1]])
-            result.concat generate_links new_node
-          elsif [:class, :module, :def, :defs].include?(n.type)
+            # @bar ||= 123 translates to:
+            #
+            # s(:or_asgn,
+            #   s(:ivasgn, :@bar),
+            #   s(:int, 123))
+            lhs_chain = NodeChainer.chain n.children[0] # s(:ivasgn, :@bar)
+            rhs_chain = NodeChainer.chain n.children[1] # s(:int, 123)
+            or_link = Chain::Or.new([lhs_chain, rhs_chain])
+            # this is just for a call chain, so we don't need to record the assignment
+            result.push(or_link)
+          elsif %i[class module def defs].include?(n.type)
             # @todo Undefined or what?
             result.push Chain::UNDEFINED_CALL
           elsif n.type == :and
             result.concat generate_links(n.children.last)
           elsif n.type == :or
-            result.push Chain::Or.new([NodeChainer.chain(n.children[0], @filename), NodeChainer.chain(n.children[1], @filename, n)])
+            result.push Chain::Or.new([NodeChainer.chain(n.children[0], @filename),
+                                       NodeChainer.chain(n.children[1], @filename, n)])
           elsif n.type == :if
-            result.push Chain::If.new([NodeChainer.chain(n.children[1], @filename), NodeChainer.chain(n.children[2], @filename, n)])
-          elsif [:begin, :kwbegin].include?(n.type)
+            then_clause = if n.children[1]
+                            NodeChainer.chain(n.children[1], @filename, n)
+                          else
+                            Source::Chain.new([Source::Chain::Literal.new('nil', nil)], n)
+                          end
+            else_clause = if n.children[2]
+                            NodeChainer.chain(n.children[2], @filename, n)
+                          else
+                            Source::Chain.new([Source::Chain::Literal.new('nil', nil)], n)
+                          end
+            result.push Chain::If.new([then_clause, else_clause])
+          elsif %i[begin kwbegin].include?(n.type)
             result.concat generate_links(n.children.last)
           elsif n.type == :block_pass
             block_variable_name_node = n.children[0]
@@ -118,12 +140,10 @@ module Solargraph
               # anonymous block forwarding (e.g., "&")
               # added in Ruby 3.1 - https://bugs.ruby-lang.org/issues/11256
               result.push Chain::BlockVariable.new(nil)
+            elsif block_variable_name_node.type == :sym
+              result.push Chain::BlockSymbol.new(block_variable_name_node.children[0].to_s)
             else
-              if block_variable_name_node.type == :sym
-                result.push Chain::BlockSymbol.new("#{block_variable_name_node.children[0].to_s}")
-              else
-                result.push Chain::BlockVariable.new("&#{block_variable_name_node.children[0].to_s}")
-              end
+              result.push Chain::BlockVariable.new("&#{block_variable_name_node.children[0]}")
             end
           elsif n.type == :hash
             result.push Chain::Hash.new('::Hash', n, hash_is_splatted?(n))
@@ -132,7 +152,7 @@ module Solargraph
             result.push Source::Chain::Array.new(chained_children, n)
           else
             lit = infer_literal_node_type(n)
-            result.push (lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
+            result.push(lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
           end
           result
         end
@@ -141,7 +161,9 @@ module Solargraph
         def hash_is_splatted? node
           return false unless Parser.is_ast_node?(node) && node.type == :hash
           return false unless Parser.is_ast_node?(node.children.last) && node.children.last.type == :kwsplat
-          return false if Parser.is_ast_node?(node.children.last.children[0]) && node.children.last.children[0].type == :hash
+          if Parser.is_ast_node?(node.children.last.children[0]) && node.children.last.children[0].type == :hash
+            return false
+          end
           true
         end
 
@@ -150,13 +172,16 @@ module Solargraph
         def passed_block node
           return unless node == @node && @parent&.type == :block
 
+          # @sg-ignore Need to add nil check here
           NodeChainer.chain(@parent.children[2], @filename)
         end
 
         # @param node [Parser::AST::Node]
+        # @sg-ignore Need to add nil check here
         # @return [Array<Source::Chain>]
         def node_args node
-          node.children[2..-1].map do |child|
+          # @sg-ignore Need to add nil check here
+          node.children[2..].map do |child|
             NodeChainer.chain(child, @filename, node)
           end
         end