solargraph 0.58.0 → 0.59.0

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

@@ -1,92 +1,122 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module NodeProcessor
-      class Base
-        # @return [Parser::AST::Node]
-        attr_reader :node
-
-        # @return [Region]
-        attr_reader :region
-
-        # @return [Array<Pin::Base>]
-        attr_reader :pins
-
-        # @return [Array<Pin::LocalVariable>]
-        attr_reader :locals
-
-        # @param node [Parser::AST::Node]
-        # @param region [Region]
-        # @param pins [Array<Pin::Base>]
-        # @param locals [Array<Pin::LocalVariable>]
-        def initialize node, region, pins, locals
-          @node = node
-          @region = region
-          @pins = pins
-          @locals = locals
-          @processed_children = false
-        end
-
-        # Subclasses should override this method to generate new pins.
-        #
-        # @return [Boolean] continue processing the next processor of the same node type.
-        # @return [void] In case there is only one processor registered for the node type, it can be void.
-        def process
-          process_children
-
-          true
-        end
-
-        private
-
-        # @param subregion [Region]
-        # @return [void]
-        def process_children subregion = region
-          return if @processed_children
-          @processed_children = true
-          node.children.each do |child|
-            next unless Parser.is_ast_node?(child)
-            NodeProcessor.process(child, subregion, pins, locals)
-          end
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [Solargraph::Location]
-        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)
-          region.source.comments_for(node)
-        end
-
-        # @param position [Solargraph::Position]
-        # @return [Pin::Closure, nil]
-        def named_path_pin position
-          pins.select do |pin|
-            pin.is_a?(Pin::Closure) && pin.path && !pin.path.empty? && pin.location.range.contain?(position)
-          end.last
-        end
-
-        # @todo Candidate for deprecation
-        # @param position [Solargraph::Position]
-        # @return [Pin::Closure, nil]
-        def block_pin position
-          # @todo determine if this can return a Pin::Block
-          pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
-        end
-
-        # @todo Candidate for deprecation
-        # @param position [Solargraph::Position]
-        # @return [Pin::Closure, nil]
-        def closure_pin position
-          pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module NodeProcessor
+      class Base
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Region]
+        attr_reader :region
+
+        # @return [Array<Pin::Base>]
+        attr_reader :pins
+
+        # @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>]
+        # @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
+
+        # Subclasses should override this method to generate new pins.
+        #
+        # @return [Boolean] continue processing the next processor of the same node type.
+        # @return [void] In case there is only one processor registered for the node type, it can be void.
+        def process
+          process_children
+
+          true
+        end
+
+        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
+          return if @processed_children
+          @processed_children = true
+          node.children.each do |child|
+            next unless Parser.is_ast_node?(child)
+            NodeProcessor.process(child, subregion, pins, locals, ivars)
+          end
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [Solargraph::Location]
+        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
+          region.source.comments_for(node)
+        end
+
+        # @param position [Solargraph::Position]
+        # @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
+
+        # @todo Candidate for deprecation
+        # @param position [Solargraph::Position]
+        # @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
+
+        # @todo Candidate for deprecation
+        # @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
+    end
+  end
+end

data/lib/solargraph/parser/node_processor.rb

@@ -1,62 +1,63 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    # The processor classes used by SourceMap::Mapper to generate pins from
-    # parser nodes.
-    #
-    module NodeProcessor
-      autoload :Base, 'solargraph/parser/node_processor/base'
-
-      class << self
-        # @type [Hash{Symbol => Array<Class<NodeProcessor::Base>>}]
-        @@processors ||= {}
-
-        # Register a processor for a node type. You can register multiple processors for the same type.
-        # If a node processor returns true, it will skip the next processor of the same node type.
-        #
-        # @param type [Symbol]
-        # @param cls [Class<NodeProcessor::Base>]
-        # @return [Array<Class<NodeProcessor::Base>>]
-        def register type, cls
-          @@processors[type] ||= []
-          @@processors[type] << cls
-        end
-
-        # @param type [Symbol]
-        # @param cls [Class<NodeProcessor::Base>]
-        #
-        # @return [void]
-        def deregister type, cls
-          @@processors[type].delete(cls)
-        end
-      end
-
-      # @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 = []
-        if pins.empty?
-          pins.push Pin::Namespace.new(
-            location: region.source.location,
-            name: '',
-            source: :parser,
-          )
-        end
-        return [pins, locals] 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)
-          process_next = processor.process
-
-          break unless process_next
-        end
-
-        [pins, locals]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    # The processor classes used by SourceMap::Mapper to generate pins from
+    # parser nodes.
+    #
+    module NodeProcessor
+      autoload :Base, 'solargraph/parser/node_processor/base'
+
+      class << self
+        # @type [Hash{Symbol => Array<Class<NodeProcessor::Base>>}]
+        @@processors ||= {}
+
+        # Register a processor for a node type. You can register multiple processors for the same type.
+        # If a node processor returns true, it will skip the next processor of the same node type.
+        #
+        # @param type [Symbol]
+        # @param cls [Class<NodeProcessor::Base>]
+        # @return [Array<Class<NodeProcessor::Base>>]
+        def register type, cls
+          @@processors[type] ||= []
+          @@processors[type] << cls
+        end
+
+        # @param type [Symbol]
+        # @param cls [Class<NodeProcessor::Base>]
+        #
+        # @return [void]
+        def deregister type, cls
+          @@processors[type].delete(cls)
+        end
+      end
+
+      # @param node [Parser::AST::Node]
+      # @param region [Region]
+      # @param pins [Array<Pin::Base>]
+      # @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
+          )
+        end
+        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, ivars)
+          process_next = processor.process
+
+          break unless process_next
+        end
+
+        [pins, locals, ivars]
+      end
+    end
+  end
+end

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

@@ -1,149 +1,165 @@
-# frozen_string_literal: true
-
-require 'prism'
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module ClassMethods
-        # @param code [String]
-        # @param filename [String, nil]
-        # @return [Array(Parser::AST::Node, Hash{Integer => Solargraph::Parser::Snippet})]
-        def parse_with_comments code, filename = nil
-          node = parse(code, filename)
-          comments = CommentRipper.new(code, filename, 0).parse
-          [node, comments]
-        end
-
-        # @param code [String]
-        # @param filename [String, nil]
-        # @param line [Integer]
-        # @return [Parser::AST::Node]
-        def parse code, filename = nil, line = 0
-          buffer = ::Parser::Source::Buffer.new(filename, line)
-          buffer.source = code
-          parser.parse(buffer)
-        rescue ::Parser::SyntaxError, ::Parser::UnknownEncodingInMagicComment => e
-          raise Parser::SyntaxError, e.message
-        end
-
-        # @return [::Parser::Base]
-        def parser
-          @parser ||= Prism::Translation::Parser.new(FlawedBuilder.new).tap do |parser|
-            parser.diagnostics.all_errors_are_fatal = true
-            parser.diagnostics.ignore_warnings      = true
-          end
-        end
-
-        # @param source [Source]
-        # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
-        def map source
-          NodeProcessor.process(source.node, Region.new(source: source))
-        end
-
-        # @param source [Source]
-        # @param name [String]
-        # @return [Array<Location>]
-        def references source, name
-          if name.end_with?("=")
-            reg = /#{Regexp.escape name[0..-2]}\s*=/
-            # @param code [String]
-            # @param offset [Integer]
-            # @return [Array(Integer, Integer), Array(nil, nil)]
-            extract_offset = ->(code, offset) { reg.match(code, offset).offset(0) }
-          else
-            # @param code [String]
-            # @param offset [Integer]
-            # @return [Array(Integer, Integer), Array(nil, nil)]
-            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)
-            offset = Position.to_offset(source.code, rng.start)
-            soff, eoff = extract_offset[source.code, offset]
-            Location.new(
-              source.filename,
-              Range.new(
-                Position.from_offset(source.code, soff),
-                Position.from_offset(source.code, eoff)
-              )
-            )
-          end
-        end
-
-        # @param name [String]
-        # @param top [AST::Node]
-        # @return [Array<AST::Node>]
-        def inner_node_references name, top
-          # @type [Array<AST::Node>]
-          result = []
-          if top.is_a?(AST::Node) && top.to_s.include?(":#{name}")
-            result.push top if top.children.any? { |c| c.to_s == name }
-            top.children.each { |c| result.concat inner_node_references(name, c) }
-          end
-          result
-        end
-
-        # @return [Source::Chain]
-        def chain *args
-          NodeChainer.chain *args
-        end
-
-        # @return [Source::Chain]
-        def chain_string *args
-          NodeChainer.load_string *args
-        end
-
-        # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
-        def process_node *args
-          Solargraph::Parser::NodeProcessor.process *args
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [String, nil]
-        def infer_literal_node_type node
-          NodeMethods.infer_literal_node_type node
-        end
-
-        # @return [Integer]
-        def version
-          parser.version
-        end
-
-        # @param node [BasicObject]
-        # @return [Boolean]
-        def is_ast_node? node
-          node.is_a?(::Parser::AST::Node)
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [Range]
-        def node_range node
-          st = Position.new(node.loc.line, node.loc.column)
-          en = Position.new(node.loc.last_line, node.loc.last_column)
-          Range.new(st, en)
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [Array<Range>]
-        def string_ranges node
-          return [] unless is_ast_node?(node)
-          result = []
-          result.push Range.from_node(node) if node.type == :str
-          node.children.each do |child|
-            result.concat string_ranges(child)
-          end
-          if node.type == :dstr && node.children.last.nil?
-            last = node.children[-2]
-            unless last.nil?
-              rng = Range.from_node(last)
-              pos = Position.new(rng.ending.line, rng.ending.column - 1)
-              result.push Range.new(pos, pos)
-            end
-          end
-          result
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'prism'
+
+module Solargraph
+  module Parser
+    module ParserGem
+      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, 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 starting_line [Integer]
+        # @sg-ignore need to understand that raise does not return
+        # @return [Parser::AST::Node]
+        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
+          raise Parser::SyntaxError, e.message
+        end
+
+        # @return [::Parser::Base]
+        def parser
+          @parser ||= Prism::Translation::Parser.new(FlawedBuilder.new).tap do |parser|
+            parser.diagnostics.all_errors_are_fatal = true
+            parser.diagnostics.ignore_warnings      = true
+          end
+        end
+
+        # @param source [Source]
+        # @return [Array(Array<Pin::Base>, Array<Pin::LocalVariable>)]
+        def map 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?('=')
+            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(
+              source.filename,
+              Range.new(
+                Position.from_offset(source.code, soff),
+                Position.from_offset(source.code, eoff)
+              )
+            )
+          end
+        end
+
+        # @param name [String]
+        # @param top [AST::Node]
+        # @return [Array<AST::Node>]
+        def inner_node_references name, top
+          # @type [Array<AST::Node>]
+          result = []
+          if top.is_a?(AST::Node) && top.to_s.include?(":#{name}")
+            result.push top if top.children.any? { |c| c.to_s == name }
+            top.children.each { |c| result.concat inner_node_references(name, c) }
+          end
+          result
+        end
+
+        # @return [Source::Chain]
+        def chain *args
+          NodeChainer.chain(*args)
+        end
+
+        # @return [Source::Chain]
+        def chain_string *args
+          NodeChainer.load_string(*args)
+        end
+
+        # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
+        def process_node *args
+          Solargraph::Parser::NodeProcessor.process(*args)
+        end
+
+        # @param node [Parser::AST::Node, nil]
+        # @return [String, nil]
+        def infer_literal_node_type node
+          NodeMethods.infer_literal_node_type node
+        end
+
+        # @return [Integer]
+        def version
+          parser.version
+        end
+
+        # @param node [BasicObject, nil]
+        # @return [Boolean]
+        def is_ast_node? node
+          node.is_a?(::Parser::AST::Node)
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [Range]
+        def node_range node
+          st = Position.new(node.loc.line, node.loc.column)
+          en = Position.new(node.loc.last_line, node.loc.last_column)
+          Range.new(st, en)
+        end
+
+        # @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
+          end
+          result
+        end
+      end
+    end
+  end
+end