solargraph 0.32.5 → 0.33.0

data/lib/solargraph/source_map.rb

@@ -44,20 +44,6 @@ module Solargraph
       @requires ||= pins.select{|p| p.kind == Pin::REQUIRE_REFERENCE}
     end
 
-    # @param position [Position, Array(Integer, Integer)]
-    # @return [Boolean]
-    def string_at? position
-      position = Position.normalize(position)
-      @source.string_at?(position)
-    end
-
-    # @param position [Position, Array(Integer, Integer)]
-    # @return [Boolean]
-    def comment_at? position
-      position = Position.normalize(position)
-      @source.comment_at?(position)
-    end
-
     # @return [Array<Pin::Base>]
     def document_symbols
       @document_symbols ||= pins.select { |pin|
@@ -72,7 +58,7 @@ module Solargraph
     end
 
     # @param position [Position]
-    # @return [Solargraph::SourceMap::Fragment]
+    # @return [Source::Cursor]
     def cursor_at position
       Source::Cursor.new(source, position)
     end
@@ -87,7 +73,7 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     def locate_pins location
       # return nil unless location.start_with?("#{filename}:")
-      pins.select { |pin| pin.location == location }
+      (pins + locals).select { |pin| pin.location == location }
     end
 
     def locate_named_path_pin line, character
@@ -118,6 +104,13 @@ module Solargraph
       source.references name
     end
 
+    # @param location [Location]
+    # @return [Array<Pin::LocalVariable>]
+    def locals_at(location)
+      return [] if location.filename != filename
+      locals.select { |pin| pin.visible_at?(location) }
+    end
+
     class << self
       # @param filename [String]
       # @return [SourceMap]
@@ -146,7 +139,7 @@ module Solargraph
 
     # @param line [Integer]
     # @param character [Integer]
-    # @param *kinds [Array<Symbol>]
+    # @param kinds [Array<Symbol>]
     # @return [Pin::Base]
     def _locate_pin line, character, *kinds
       position = Position.new(line, character)
@@ -155,7 +148,7 @@ module Solargraph
         found = pin if (kinds.empty? || kinds.include?(pin.kind)) && pin.location.range.contain?(position)
         break if pin.location.range.start.line > line
       end
-      # @todo Assuming the root pin is always valid
+      # Assuming the root pin is always valid
       found || pins.first
     end
 

data/lib/solargraph/source_map/clip.rb

@@ -14,13 +14,14 @@ module Solargraph
       # @return [Array<Pin::Base>]
       def define
         return [] if cursor.comment? || cursor.chain.literal?
-        result = cursor.chain.define(api_map, context_pin, locals)
+        result = cursor.chain.define(api_map, block, locals)
         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
 
       # @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>'
         return Completion.new([], cursor.range) if cursor.chain.literal? || cursor.comment?
         result = []
@@ -37,21 +38,21 @@ module Solargraph
               type = ComplexType::UNDEFINED
             end
           end
-          result.concat api_map.get_constants(type.undefined? ? '' : type.namespace, cursor.start_of_constant? ? '' : context_pin.context.namespace)
+          result.concat api_map.get_constants(type.undefined? ? '' : type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace)
         else
-          type = cursor.chain.base.infer(api_map, context_pin, locals)
-          result.concat api_map.get_complex_type_methods(type, context_pin.context.namespace, cursor.chain.links.length == 1)
+          type = cursor.chain.base.infer(api_map, block, locals)
+          result.concat api_map.get_complex_type_methods(type, block.binder.namespace, cursor.chain.links.length == 1)
           if cursor.chain.links.length == 1
             if cursor.word.start_with?('@@')
-              return package_completions(api_map.get_class_variable_pins(context_pin.context.namespace))
+              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(context_pin.context.namespace, context_pin.context.scope))
+              return package_completions(api_map.get_instance_variable_pins(block.binder.namespace, block.binder.scope))
             elsif cursor.word.start_with?('$')
               return package_completions(api_map.get_global_variable_pins)
             end
             result.concat locals
             result.concat api_map.get_constants('', context_pin.context.namespace)
-            result.concat api_map.get_methods(context_pin.context.namespace, scope: context_pin.context.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
             result.concat ApiMap.keywords
             result.concat yielded_self_pins
@@ -63,13 +64,15 @@ module Solargraph
       # @return [Array<Pin::Base>]
       def signify
         return [] unless cursor.argument?
-        clip = Clip.new(api_map, cursor.recipient)
-        clip.define.select{|pin| pin.kind == Pin::METHOD}
+        chain = Source::NodeChainer.chain(cursor.recipient_node, cursor.filename)
+        chain.define(api_map, context_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
       end
 
       # @return [ComplexType]
       def infer
-        cursor.chain.infer(api_map, context_pin, locals)
+        result = cursor.chain.infer(api_map, block, locals)
+        return result unless result.tag == 'self'
+        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).namespace)
       end
 
       # Get an array of all the locals that are visible from the cursors's
@@ -117,11 +120,6 @@ module Solargraph
         receiver_pin = chain.define(api_map, context_pin, locals).first
         return [] if receiver_pin.nil?
         result = []
-        ys = receiver_pin.docstring.tag(:yieldself)
-        unless ys.nil? || ys.types.empty?
-          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
-          result.concat api_map.get_complex_type_methods(ysct, ysct.namespace, true)
-        end
         ys = receiver_pin.docstring.tag(:yieldpublic)
         unless ys.nil? || ys.types.empty?
           ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)

data/lib/solargraph/source_map/mapper.rb

@@ -21,13 +21,12 @@ module Solargraph
         @filename = source.filename
         @code = source.code
         @comments = source.comments
-        @pins = NodeProcessor.process(source.node, Region.new(source: source))
+        @pins, @locals = NodeProcessor.process(source.node, Region.new(source: source))
         process_comment_directives
-        locals = @pins.select{|p| [Pin::LocalVariable, Pin::MethodParameter, Pin::BlockParameter].include?(p.class)}
-        [@pins - locals, locals]
+        [@pins, @locals]
       rescue Exception => e
         Solargraph.logger.warn "Error mapping #{source.filename}: [#{e.class}] #{e.message}"
-        Solargraph.logger.warn e.backtrace
+        Solargraph.logger.warn e.backtrace.join("\n")
         [[], []]
       end
 
@@ -35,7 +34,7 @@ module Solargraph
         s = Position.new(0, 0)
         e = Position.from_offset(code, code.length)
         location = Location.new(filename, Range.new(s, e))
-        [[Pin::Namespace.new(location, '', '', '', :class, :public)], []]
+        [[Pin::Namespace.new(location: location, name: '')], []]
       end
 
       class << self
@@ -52,15 +51,8 @@ module Solargraph
         @pins ||= []
       end
 
-      # @param node [Parser::AST::Node]
-      # @return [Solargraph::Pin::Namespace]
-      def namespace_for(node)
-        position = Position.new(node.loc.line, node.loc.column)
-        namespace_at(position)
-      end
-
-      def namespace_at(position)
-        @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.location.range.contain?(position)}.last
+      def closure_at(position)
+        @pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
       end
 
       def process_comment source_position, comment_position, comment
@@ -77,25 +69,42 @@ module Solargraph
         location = Location.new(@filename, Range.new(comment_position, comment_position))
         case directive.tag.tag_name
         when 'method'
-          namespace = namespace_at(source_position)
-          gen_src = Solargraph::SourceMap.load_string("def #{directive.tag.name};end")
-          gen_pin = gen_src.pins.select{ |p| p.kind == Pin::METHOD }.first
+          namespace = closure_at(source_position)
+          region = Region.new(source: @source, closure: namespace)
+          src_node = Solargraph::Source.parse("def #{directive.tag.name};end", @filename, location.range.start.line)
+          gen_pin = Solargraph::SourceMap::NodeProcessor.process(src_node, region).first.last
           return if gen_pin.nil?
-          @pins.push Solargraph::Pin::Method.new(location, namespace.path, gen_pin.name, docstring.all, :instance, :public, gen_pin.parameters, nil)
+          # @todo: Smelly instance variable access
+          gen_pin.instance_variable_set(:@comments, docstring.all)
+          @pins.push gen_pin
         when 'attribute'
-          namespace = namespace_at(source_position)
+          namespace = closure_at(source_position)
           t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
           if t.nil? || t.include?('r')
-            # location, namespace, name, docstring, access
-            pins.push Solargraph::Pin::Attribute.new(location, namespace.path, directive.tag.name, docstring.all, :reader, :instance, :public)
+            pins.push Solargraph::Pin::Attribute.new(
+              location: location,
+              closure: namespace,
+              name: directive.tag.name,
+              comments: docstring.all,
+              access: :reader,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public
+            )
           end
           if t.nil? || t.include?('w')
-            pins.push Solargraph::Pin::Attribute.new(location, namespace.path, "#{directive.tag.name}=", docstring.all, :writer, :instance, :public)
+            pins.push Solargraph::Pin::Attribute.new(
+              location: location,
+              closure: namespace,
+              name: "#{directive.tag.name}=",
+              comments: docstring.all,
+              access: :writer,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public
+            )
           end
         when 'parse'
-          # @todo Parse and map directive.tag.text
-          ns = namespace_at(comment_position)
-          region = Region.new(source: @source, namespace: ns.path)
+          ns = closure_at(source_position)
+          region = Region.new(source: @source, closure: ns)
           begin
             node = Solargraph::Source.parse(directive.tag.text, @filename, comment_position.line)
             NodeProcessor.process(node, region, @pins)
@@ -103,8 +112,10 @@ module Solargraph
             # @todo Handle parser errors in !parse directives
           end
         when 'domain'
-          namespace = namespace_at(source_position)
+          namespace = closure_at(source_position)
           namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
+        when 'override'
+          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags)
         end
       end
 

data/lib/solargraph/source_map/node_processor.rb

@@ -22,6 +22,7 @@ module Solargraph
       autoload :BlockNode,     'solargraph/source_map/node_processor/block_node'
       autoload :OrasgnNode,    'solargraph/source_map/node_processor/orasgn_node'
       autoload :SymNode,       'solargraph/source_map/node_processor/sym_node'
+      autoload :ResbodyNode,   'solargraph/source_map/node_processor/resbody_node'
 
       class << self
         @@processors ||= {}
@@ -41,9 +42,8 @@ module Solargraph
       register :source,  BeginNode
       register :begin,   BeginNode
       register :kwbegin, BeginNode
-      # # @todo Is this the best way to handle rescue nodes?
       register :rescue,  BeginNode
-      register :resbody, BeginNode
+      register :resbody, ResbodyNode
       register :def,     DefNode
       register :defs,    DefsNode
       register :send,    SendNode
@@ -64,14 +64,19 @@ module Solargraph
       # @param node [Parser::AST::Node]
       # @param region [Region]
       # @param pins [Array<Pin::Base>]
-      # @return [Array<Pin::Base>]
-      def self.process node, region = Region.new(nil, '', :instance, :public, []), pins = []
-        pins.push Pin::Namespace.new(region.source.location, '', '', nil, :class, :public) if pins.empty?
-        return pins unless node.is_a?(Parser::AST::Node) #&& @@processors.key?(node.type)
+      # @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: ''
+          )
+        end
+        return [pins, locals] unless node.is_a?(Parser::AST::Node)
         klass = @@processors[node.type] || BeginNode
-        processor = klass.new(node, region, pins)
+        processor = klass.new(node, region, pins, locals)
         processor.process
-        processor.pins
+        [processor.pins, processor.locals]
       end
     end
   end

data/lib/solargraph/source_map/node_processor/alias_node.rb

@@ -3,14 +3,14 @@ module Solargraph
     module NodeProcessor
       class AliasNode < Base
         def process
-          pin = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.name == node.children[1].children[0].to_s && p.namespace == region.namespace && p.scope == region.scope}.first
-          if pin.nil?
-            pins.push Solargraph::Pin::MethodAlias.new(get_node_location(node), region.namespace, node.children[0].children[0].to_s, region.scope, node.children[1].children[0].to_s)
-          elsif pin.is_a?(Solargraph::Pin::Method)
-            pins.push Solargraph::Pin::Method.new(get_node_location(node), pin.namespace, node.children[0].children[0].to_s, comments_for(node) || pin.comments, pin.scope, pin.visibility, pin.parameters, pin.node)
-          elsif pin.is_a?(Solargraph::Pin::Attribute)
-            pins.push Solargraph::Pin::Attribute.new(get_node_location(node), pin.namespace, node.children[0].children[0].to_s, comments_for(node) || pin.comments, pin.access, pin.scope, pin.visibility)
-          end
+          loc = get_node_location(node)
+          pins.push Solargraph::Pin::MethodAlias.new(
+            location: loc,
+            closure: region.closure,
+            name: node.children[0].children[0].to_s,
+            original: node.children[1].children[0].to_s,
+            scope: region.scope || :instance
+          )
           process_children
         end
       end

data/lib/solargraph/source_map/node_processor/args_node.rb

@@ -3,22 +3,16 @@ module Solargraph
     module NodeProcessor
       class ArgsNode < Base
         def process
-          return if node.children.empty?
-          here = get_node_start_position(node)
-          context = named_path_pin(here)
-          block = block_pin(here)
-          if block.kind == Solargraph::Pin::BLOCK
-            pi = 0
-            node.children.each do |u|
-              pins.push Solargraph::Pin::BlockParameter.new(get_node_location(u), region.namespace, "#{u.children[0]}", comments_for(node), block)
-              block.parameters.push pins.last
-              pi += 1
-            end
-          else
-            node.children.each do |u|
-              presence = Range.new(here, block.location.range.ending)
-              pins.push Solargraph::Pin::MethodParameter.new(get_node_location(u), region.namespace, u.children[0].to_s, comments_for(node), u.children[1], infer_literal_node_type(u.children[1]), context, block, presence)
-            end
+          node.children.each do |u|
+            loc = get_node_location(u)
+            locals.push Solargraph::Pin::Parameter.new(
+              location: loc,
+              closure: region.closure,
+              comments: comments_for(node),
+              name: u.children[0].to_s,
+              assignment: u.children[1],
+              presence: region.closure.location.range
+            )
           end
           process_children
         end

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

@@ -13,13 +13,17 @@ module Solargraph
         # @return [Array<Pin::Base>]
         attr_reader :pins
 
+        # @return [Array<Pin::Base>]
+        attr_reader :locals
+
         # @param node [Parser::AST::Node]
         # @param region [Region]
         # @param pins [Array<Pin::Base>]
-        def initialize node, region, pins
+        def initialize node, region, pins, locals
           @node = node
           @region = region
           @pins = pins
+          @locals = locals
         end
 
         protected
@@ -38,7 +42,7 @@ module Solargraph
         def process_children subregion = region
           node.children.each do |child|
             next unless child.is_a?(Parser::AST::Node)
-            NodeProcessor.process(child, subregion, pins)
+            NodeProcessor.process(child, subregion, pins, locals)
           end
         end
 
@@ -56,11 +60,50 @@ module Solargraph
         end
 
         def named_path_pin position
-          pins.select{|pin| [Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
+          pins.select{|pin| [Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) && pin.location.range.contain?(position)}.last
         end
 
+        # @todo Candidate for deprecation
         def block_pin position
-          pins.select{|pin| [Pin::BLOCK, Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
+          pins.select{|pin| [Pin::BLOCK, Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) && pin.location.range.contain?(position)}.last
+        end
+
+        # @todo Candidate for deprecation
+        def closure_pin position
+          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position)}.last
+        end
+
+        private
+
+        def method_args
+          return [] if node.nil?
+          list = nil
+          args = []
+          node.children.each { |c|
+            if c.kind_of?(AST::Node) and c.type == :args
+              list = c
+              break
+            end
+          }
+          return args if list.nil?
+          list.children.each { |c|
+            if c.type == :arg
+              args.push c.children[0].to_s
+            elsif c.type == :restarg
+              args.push "*#{c.children[0]}"
+            elsif c.type == :optarg
+              args.push "#{c.children[0]} = #{region.code_for(c.children[1])}"
+            elsif c.type == :kwarg
+              args.push "#{c.children[0]}:"
+            elsif c.type == :kwoptarg
+              args.push "#{c.children[0]}: #{region.code_for(c.children[1])}"
+            elsif c.type == :kwrestarg
+              args.push "**#{c.children[0]}"
+            elsif c.type == :blockarg
+              args.push "&#{c.children[0]}"
+            end
+          }
+          args
         end
       end
     end

data/lib/solargraph/source_map/node_processor/block_node.rb

@@ -3,10 +3,15 @@ module Solargraph
     module NodeProcessor
       class BlockNode < Base
         def process
-          here = get_node_start_position(node)
-          named_path = named_path_pin(here)
-          pins.push Solargraph::Pin::Block.new(get_node_location(node), region.namespace, '', comments_for(node), node.children[0], named_path.context)
-          process_children
+          pins.push Solargraph::Pin::Block.new(
+            location: get_node_location(node),
+            closure: region.closure,
+            receiver: node.children[0],
+            comments: comments_for(node),
+            scope: region.scope || region.closure.context.scope,
+            args: method_args
+          )
+          process_children region.update(closure: pins.last)
         end
       end
     end