solargraph 0.26.1 → 0.27.0

data/lib/solargraph/source/chain.rb

@@ -15,65 +15,55 @@ module Solargraph
       autoload :Definition,       'solargraph/source/chain/definition'
       autoload :Head,             'solargraph/source/chain/head'
 
-      UNDEFINED_CALL = Source::Chain::Call.new('<undefined>')
-      UNDEFINED_CONSTANT = Source::Chain::Constant.new('<undefined>')
+      UNDEFINED_CALL = Chain::Call.new('<undefined>')
+      UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
 
       # @return [Array<Source::Chain::Link>]
       attr_reader :links
 
-      # @param filename [String]
       # @param links [Array<Chain::Link>]
-      def initialize filename, links
-        @filename = filename
+      def initialize links
         @links = links
         @links.push UNDEFINED_CALL if @links.empty?
       end
 
-      # @return [Array<Source::Chain::Link>]
+      # @return [Chain]
       def base
-        # @todo It might make sense for the chain links to always have a root.
-        @base ||= links[0..-2]
-      end
-
-      # @return [Source::Chain::Link]
-      def tail
-        @tail ||= links.last
-      end
-
-      def literal?
-        tail.is_a?(Literal)
+        @base ||= Chain.new(links[0..-2])
       end
 
       # @param api_map [ApiMap]
-      # @param context [Pin::Base]
+      # @param name_pin [Pin::Base]
       # @param locals [Array<Pin::Base>]
       # @return [Array<Pin::Base>]
-      def define_with api_map, context, locals
-        inner_define_with links, api_map, context, locals
-      end
-
-      def define_base_with api_map, context, locals
-        inner_define_with links[0..-2], api_map, context, locals
+      def define api_map, name_pin, locals
+        return [] if undefined?
+        type = ComplexType::UNDEFINED
+        head = true
+        working_pin = name_pin
+        links[0..-2].each do |link|
+          pins = link.resolve(api_map, working_pin, head ? locals : [])
+          head = false
+          return [] if pins.empty?
+          type = ComplexType::UNDEFINED
+          pins.each do |pin|
+            type = pin.infer(api_map)
+            break unless type.undefined?
+          end
+          return [] if type.undefined?
+          working_pin = Pin::ProxyType.anonymous(type)
+        end
+        links.last.resolve(api_map, working_pin, head ? locals: [])
       end
 
       # @param api_map [ApiMap]
-      # @param context [Pin::Base]
+      # @param name_pin [Pin::Base]
       # @param locals [Array<Pin::Base>]
       # @return [ComplexType]
-      def infer_type_with api_map, context, locals
-        # @todo Perform link inference
-        inner_infer_type_with(links, api_map, context, locals)
-      end
-
-      def infer_base_type_with api_map, context, locals
-        inner_infer_type_with(links[0..-2], api_map, context, locals)
-      end
-
-      private
-
-      def inner_infer_type_with array, api_map, context, locals
+      def infer api_map, name_pin, locals
+        return ComplexType::UNDEFINED if undefined?
         type = ComplexType::UNDEFINED
-        pins = inner_define_with(array, api_map, context, locals)
+        pins = define(api_map, name_pin, locals)
         pins.each do |pin|
           type = pin.infer(api_map)
           break unless type.undefined?
@@ -81,23 +71,16 @@ module Solargraph
         type
       end
 
-      def inner_define_with array, api_map, context, locals
-        return [] if array.empty?
-        type = ComplexType::UNDEFINED
-        head = true
-        # @param link [Chain::Link]
-        array[0..-2].each do |link|
-          pins = link.resolve_pins(api_map, context, head ? locals : [])
-          head = false
-          return [] if pins.empty?
-          pins.each do |pin|
-            type = pin.infer(api_map)
-            break unless type.undefined?
-          end
-          return [] if type.undefined?
-          context = Pin::ProxyType.anonymous(type)
-        end
-        array.last.resolve_pins(api_map, context, head ? locals: [])
+      def literal?
+        links.last.is_a?(Chain::Literal)
+      end
+
+      def undefined?
+        links.any?(&:undefined?)
+      end
+
+      def constant?
+        links.last.is_a?(Chain::Constant)
       end
     end
   end

data/lib/solargraph/source/chain/call.rb

@@ -13,59 +13,77 @@ module Solargraph
           @arguments = arguments
         end
 
-        def resolve_pins api_map, context, locals
+        def resolve api_map, name_pin, locals
           found = locals.select{|p| p.name == word}
-          return inferred_pins(found, api_map, context) unless found.empty?
-          pins = api_map.get_method_stack(namespace_from_context(context), word, scope: context.scope)
+          return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
+          pins = api_map.get_method_stack(name_pin.context.namespace, word, scope: name_pin.context.scope)
           return [] if pins.empty?
-          pins[0] = virtual_new_pin(pins.first, context) if pins.first.path == 'Class#new'
-          inferred_pins(pins, api_map, context)
+          pins.unshift virtual_new_pin(pins.first, name_pin.context) if external_constructor?(pins.first, name_pin.context)
+          inferred_pins(pins, api_map, name_pin.context, locals)
         end
 
         private
 
-        # @param pin [Pin::Base]
-        # @return [String]
-        def namespace_from_context pin
-          return pin.namespace if pin.kind == Pin::ATTRIBUTE or pin.kind == Pin::METHOD
-          pin.return_complex_type.namespace
-        end
-
         # Create a `new` pin to facilitate type inference. This is necessary for
         # classes from YARD and classes in the namespace that do not have an
         # `initialize` method.
         #
         # @param new_pin [Solargraph::Pin::Base]
-        # @param context_pin [Solargraph::Pin::Base]
+        # @param context [Solargraph::ComplexType]
         # @return [Pin::Method]
-        def virtual_new_pin new_pin, context_pin
-          pin = Pin::Method.new(new_pin.location, context_pin.path, new_pin.name, '', :class, new_pin.visibility, new_pin.parameters)
+        def virtual_new_pin new_pin, context
+          # pin = Pin::Method.new(new_pin.location, context.namespace, new_pin.name, '', :class, new_pin.visibility, new_pin.parameters)
           # @todo Smelly instance variable access.
-          pin.instance_variable_set(:@return_complex_type, ComplexType.parse(context_pin.path))
-          pin
+          # pin.instance_variable_set(:@return_complex_type, ComplexType.parse(context.namespace))
+          # pin
+          Pin::ProxyType.anonymous(ComplexType.parse(context.namespace))
         end
 
-        def self_pin(api_map, context)
-          return Pin::ProxyType.anonymous(ComplexType.parse(context.namespace)) if context.scope == :instance
-          # return api_map.get_path_suggestions(context.namespace)
-          context
-        end
-
-        def inferred_pins pins, api_map, context_pin
-          result = pins.uniq(&:location).map do |p|
+        def inferred_pins pins, api_map, context, locals
+          result = pins.map do |p|
             if CoreFills::METHODS_RETURNING_SELF.include?(p.path)
-              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context_pin.return_complex_type.tag}]", p.scope, p.visibility, p.parameters)
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.tag}]", p.scope, p.visibility, p.parameters)
             end
-            if CoreFills::METHODS_RETURNING_SUBTYPES.include?(p.path) and !context_pin.return_complex_type.subtypes.empty?
-              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context_pin.return_complex_type.subtypes.first.tag}]", p.scope, p.visibility, p.parameters)
+            if CoreFills::METHODS_RETURNING_SUBTYPES.include?(p.path) && !context.subtypes.empty?
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.subtypes.first.tag}]", p.scope, p.visibility, p.parameters)
             end
-            next p if p.kind == Pin::METHOD or p.kind == Pin::ATTRIBUTE or p.kind == Pin::NAMESPACE
+            # @todo Temporarily disabled macros
+            # if p.kind == Pin::METHOD && !p.macros.empty?
+            #   result = process_macro(p, api_map, context, locals)
+            #   next result unless result.return_type.undefined?
+            # end
+            next p if p.kind == Pin::METHOD || p.kind == Pin::ATTRIBUTE || p.kind == Pin::NAMESPACE
             type = p.infer(api_map)
             next p if p.return_complex_type == type
             Pin::ProxyType.new(p.location, nil, p.name, type)
           end
           result
         end
+
+        def external_constructor? pin, context
+          pin.path == 'Class#new' || (pin.name == 'new' && pin.scope == :class && pin.context != context)
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        def process_macro pin, api_map, context, locals
+          pin.macros.each do |macro|
+            vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
+            txt = macro.tag.text.clone
+            i = 1
+            vals.each do |v|
+              txt.gsub!(/\$#{i}/, v.context.namespace)
+              i += 1
+            end
+            docstring = YARD::Docstring.parser.parse(txt).to_docstring
+            tag = docstring.tag(:return)
+            unless tag.nil? || tag.types.nil?
+              return Pin::ProxyType.anonymous(ComplexType.parse(*tag.types))
+            end
+          end
+          return Pin::ProxyType.new(nil, nil, nil, ComplexType::UNDEFINED)
+        end
       end
     end
   end

data/lib/solargraph/source/chain/class_variable.rb

@@ -2,8 +2,8 @@ module Solargraph
   class Source
     class Chain
       class ClassVariable < Link
-        def resolve_pins api_map, context, locals
-          api_map.get_class_variable_pins(context.namespace).select{|p| p.name == word}
+        def resolve api_map, name_pin, locals
+          api_map.get_class_variable_pins(name_pin.context.namespace).select{|p| p.name == word}
         end
       end
     end

data/lib/solargraph/source/chain/constant.rb

@@ -6,12 +6,12 @@ module Solargraph
           @word = word
         end
 
-        # @param api_map [ApiMap]
-        def resolve_pins api_map, context, locals
+        def resolve api_map, name_pin, locals
+          return [Pin::ROOT_PIN] if word.empty?
           parts = word.split('::')
           last = parts.pop
           first = parts.join('::').to_s
-          api_map.get_constants(first, context.named_context).select{|p| p.name == last}
+          api_map.get_constants(first, name_pin.context.namespace).select{|p| p.name == last}
         end
       end
     end

data/lib/solargraph/source/chain/definition.rb

@@ -2,13 +2,17 @@ module Solargraph
   class Source
     class Chain
       class Definition < Link
-        # @param location [Solargraph::Source::Location]
+        # @param location [Solargraph::Location]
         def initialize location
           @location = location
         end
 
-        def resolve_pins api_map, context, locals
-          api_map.locate_pin(@location)
+        # @param api_map [ApiMap]
+        def resolve api_map, name_pin, locals
+          result = api_map.locate_pin(@location)
+          # result = api_map.source_map(@location.filename).locate_named_path_pin(@location.range.start.line, @location.range.start.column)
+          return [] if result.nil?
+          [result]
         end
       end
     end

data/lib/solargraph/source/chain/global_variable.rb

@@ -2,7 +2,7 @@ module Solargraph
   class Source
     class Chain
       class GlobalVariable < Link
-        def resolve_pins api_map, context, locals
+        def resolve api_map, name_pin, locals
           api_map.get_global_variable_pins.select{|p| p.name == word}
         end
       end

data/lib/solargraph/source/chain/head.rb

@@ -4,15 +4,28 @@ module Solargraph
       # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
       # either a class (`String`) or a function (`Kernel#String`).
       #
-      class Head < Call
-        def resolve_pins api_map, context, locals
-          return [self_pin(api_map, context)] if word == 'self'
-          base = super
-          return base if locals.map(&:name).include?(word)
-          here = []
-          ns = api_map.qualify(word, context.named_context)
-          here.concat api_map.get_path_suggestions(ns) unless ns.nil?
-          here + base
+      # @note Chain::Head is only intended to handle `self` and `super`.
+      class Head < Link
+        def resolve api_map, name_pin, locals
+          return [self_pin(name_pin.context)] if word == 'self'
+          return super_pins(api_map, name_pin) if word == 'super'
+          []
+        end
+
+        private
+
+        # @param context [ComplexType]
+        # @return [Pin::ProxyType]
+        def self_pin(context)
+          Pin::ProxyType.anonymous(context)
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @return [Array<Pin::Base>]
+        def super_pins api_map, name_pin
+          pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+          pins.reject{|p| p.path == name_pin.path}
         end
       end
     end

data/lib/solargraph/source/chain/instance_variable.rb

@@ -2,8 +2,8 @@ module Solargraph
   class Source
     class Chain
       class InstanceVariable < Link
-        def resolve_pins api_map, context, locals
-          api_map.get_instance_variable_pins(context.namespace, context.scope).select{|p| p.name == word}
+        def resolve api_map, name_pin, locals
+          api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select{|p| p.name == word}
         end
       end
     end

data/lib/solargraph/source/chain/link.rb

@@ -17,10 +17,10 @@ module Solargraph
         end
 
         # @param api_map [ApiMap]
-        # @param context [ComplexType]
-        # @param locals [Array<Solargraph::Pin::Base>]
-        # @return [Array<Solargraph::Pin::Base>]
-        def resolve_pins api_map, context, locals
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        # @return [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
           []
         end
 

data/lib/solargraph/source/chain/literal.rb

@@ -12,7 +12,7 @@ module Solargraph
           @complex_type = ComplexType.parse(type).first
         end
 
-        def resolve_pins api_map, context, locals
+        def resolve api_map, name_pin, locals
           [Pin::ProxyType.anonymous(@complex_type)]
         end
       end

data/lib/solargraph/source/chain/variable.rb

@@ -2,8 +2,8 @@ module Solargraph
   class Source
     class Chain
       class Variable < Link
-        def resolve_pins api_map, context, locals
-          api_map.get_instance_variable_pins(context.namespace, context.scope).select{|p| p.name == word}
+        def resolve api_map, name_pin, locals
+          api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select{|p| p.name == word}
         end
       end
     end

data/lib/solargraph/source/change.rb

@@ -38,12 +38,6 @@ module Solargraph
             break
           end
           commit text, "#{new_text[0..-2]} "
-        elsif nullable and !range.nil? and new_text.empty?
-          offset = Position.to_offset(text, range.start)
-          if offset > 0 and text[offset - 1] == '.'
-            text = text[0..offset - 1] + ' ' + text[offset..-1]
-          end
-          commit text, new_text
         elsif range.nil?
           new_text
         else

data/lib/solargraph/source/cursor.rb

@@ -0,0 +1,161 @@
+module Solargraph
+  class Source
+    # Information about a position in a source, including the word located
+    # there.
+    #
+    class Cursor
+      # @return [Position]
+      attr_reader :position
+
+      # @return [Source]
+      attr_reader :source
+
+      # @param source [Source]
+      # @param position [Position, Array(Integer, Integer)]
+      def initialize source, position
+        @source = source
+        @position = if position.is_a?(Array)
+                      Position.new(position[0], position[1])
+                    else
+                      position
+                    end
+      end
+
+      # @return [String]
+      def filename
+        source.filename
+      end
+
+      # The whole word at the current position. Given the text `foo.bar`, the
+      # word at position(0,6) is `bar`.
+      #
+      # @return [String]
+      def word
+        @word ||= start_of_word + end_of_word
+      end
+
+      # The part of the word before the current position. Given the text
+      # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
+      #
+      # @return [String]
+      def start_of_word
+        @start_of_word ||= begin
+          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?('::')
+          result
+        end
+      end
+
+      # The part of the word after the current position. Given the text
+      # `foo.bar`, the end_of_word at position (0,6) is `r`.
+      #
+      # @return [String]
+      def end_of_word
+        @end_of_word ||= begin
+          match = source.code[offset..-1].to_s.match(end_word_pattern)
+          match ? match[0] : ''
+        end
+      end
+
+      def start_of_constant?
+        source.code[offset-2, 2] == '::'
+      end
+
+      # The range of the word at the current position.
+      #
+      # @return [Range]
+      def range
+        @range ||= begin
+          s = Position.from_offset(source.code, offset - start_of_word.length)
+          e = Position.from_offset(source.code, offset + end_of_word.length)
+          Solargraph::Range.new(s, e)
+        end
+      end
+
+      # @return [Chain]
+      def chain
+        @chain ||= SourceChainer.chain(source, position)
+      end
+
+      # @return [Boolean]
+      def argument?
+        @argument ||= !signature_position.nil?
+      end
+
+      # @return [Boolean]
+      def comment?
+        @comment ||= source.comment_at?(position)
+      end
+
+      # @return [Boolean]
+      def string?
+        @string ||= source.string_at?(position)
+      end
+
+      # @return [Cursor, nil]
+      def recipient
+        return nil unless argument?
+        @recipient ||= Cursor.new(source, signature_position)
+      end
+
+      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
+      end
+
+      private
+
+      # @return [Integer]
+      def offset
+        @offset ||= Position.to_offset(source.code, position)
+      end
+
+      # A regular expression to find the start of a word from an offset.
+      #
+      # @return [Regexp]
+      def start_word_pattern
+        /(@{1,2}|\$)?([a-z0-9_]|[^\u0000-\u007F])*\z/i
+      end
+
+      # A regular expression to find the end of a word from an offset.
+      #
+      # @return [Regexp]
+      def end_word_pattern
+        /^([a-z0-9_]|[^\u0000-\u007F])*[\?\!]?/i
+      end
+
+      def signature_position
+        if @signature_position.nil?
+          open_parens = 0
+          cursor = offset - 1
+          while cursor >= 0
+            break if cursor < 0
+            if source.code[cursor] == ')'
+              open_parens -= 1
+            elsif source.code[cursor] == '('
+              open_parens += 1
+            end
+            break if open_parens == 1
+            cursor -= 1
+          end
+          if cursor >= 0
+            @signature_position = Position.from_offset(source.code, cursor)
+          end
+        end
+        @signature_position
+      end
+    end
+  end
+end