solargraph 0.29.4 → 0.29.5

data/lib/solargraph/pin.rb

@@ -4,6 +4,7 @@ module Solargraph
   module Pin
     autoload :Conversions,      'solargraph/pin/conversions'
     autoload :Base,             'solargraph/pin/base'
+    autoload :BaseMethod,       'solargraph/pin/base_method'
     autoload :Method,           'solargraph/pin/method'
     autoload :MethodAlias,      'solargraph/pin/method_alias'
     autoload :Attribute,        'solargraph/pin/attribute'

data/lib/solargraph/pin/attribute.rb

@@ -1,15 +1,9 @@
 module Solargraph
   module Pin
-    class Attribute < Base
+    class Attribute < BaseMethod
       # @return [Symbol] :reader or :writer
       attr_reader :access
 
-      # @return [Symbol] :class or :instance
-      attr_reader :scope
-
-      # @return [Symbol] :public, :protected, or :private
-      attr_reader :visibility
-
       def initialize location, namespace, name, comments, access, scope, visibility
         super(location, namespace, name, comments)
         @access = access
@@ -33,10 +27,6 @@ module Solargraph
         @path ||= namespace + (scope == :instance ? '#' : '.') + name
       end
 
-      def return_complex_type
-        @return_complex_type ||= generate_complex_type
-      end
-
       def parameters
         # Since attributes are generally equivalent to methods, treat
         # them as methods without parameters
@@ -46,26 +36,6 @@ module Solargraph
       def parameter_names
         []
       end
-
-      private
-
-      # @todo DRY this method. It also exists in Pin::Method.
-      #
-      # @return [ComplexType]
-      def generate_complex_type
-        tag = docstring.tag(:return)
-        if tag.nil?
-          ol = docstring.tag(:overload)
-          tag = ol.tag(:return) unless ol.nil?
-        end
-        return ComplexType::UNDEFINED if tag.nil? or tag.types.nil? or tag.types.empty?
-        begin
-          ComplexType.parse *tag.types
-        rescue Solargraph::ComplexTypeError => e
-          STDERR.puts e.message
-          ComplexType::UNDEFINED
-        end
-      end
     end
   end
 end

data/lib/solargraph/pin/base.rb

@@ -85,14 +85,12 @@ module Solargraph
       # @param other [Solargraph::Pin::Base, Object]
       # @return [Boolean]
       def nearly? other
-        # @todo The directives test needs to be a deep check similar to
-        #   compare_docstring_tags.
-        self.class == other.class and
-          namespace == other.namespace and
-          name == other.name and
-          (comments == other.comments or
-            ( ((maybe_directives? == false and other.maybe_directives? == false) or compare_directives(directives, other.directives)) and
-            compare_docstring_tags(docstring, other.docstring) )
+        self.class == other.class &&
+          namespace == other.namespace &&
+          name == other.name &&
+          (comments == other.comments ||
+            (((maybe_directives? == false && other.maybe_directives? == false) || compare_directives(directives, other.directives)) &&
+            compare_docstring_tags(docstring, other.docstring))
           )
       end
 
@@ -145,12 +143,36 @@ module Solargraph
         @deprecated ||= docstring.has_tag?('deprecated')
       end
 
+      # Get a fully qualified type from the pin's return type.
+      #
+      # The relative type is determined from YARD documentation (@return,
+      # @param, @type, etc.) and its namespaces are fully qualified using the
+      # provided ApiMap.
+      #
       # @param api_map [ApiMap]
       # @return [ComplexType]
-      def infer api_map
+      def typify api_map
         return_complex_type.qualify(api_map, namespace)
       end
 
+      # Infer the pin's return type via static code analysis.
+      #
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def probe api_map
+        typify api_map
+      end
+
+      # @deprecated Use #typify and/or #probe instead
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def infer api_map
+        STDERR.puts "WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead."
+        type = typify(api_map)
+        return type unless type.undefined?
+        probe api_map
+      end
+
       # Try to merge data from another pin. Merges are only possible if the
       # pins are near matches (see the #nearly? method). The changes should
       # not have any side effects on the API surface.
@@ -160,14 +182,13 @@ module Solargraph
       def try_merge! pin
         return false unless nearly?(pin)
         @location = pin.location
-        if comments != pin.comments
-          @comments = pin.comments
-          @docstring = pin.docstring
-          @return_complex_type = pin.return_complex_type
-          @documentation = nil
-          @deprecated = nil
-          reset_conversions
-        end
+        return true if comments == pin.comments
+        @comments = pin.comments
+        @docstring = pin.docstring
+        @return_complex_type = pin.return_complex_type
+        @documentation = nil
+        @deprecated = nil
+        reset_conversions
         true
       end
 

data/lib/solargraph/pin/base_method.rb

@@ -0,0 +1,64 @@
+module Solargraph
+  module Pin
+    # The base class for method and attribute pins.
+    #
+    class BaseMethod < Base
+      # @return [Symbol] :instance or :class
+      attr_reader :scope
+
+      # @return [Symbol] :public, :private, or :protected
+      attr_reader :visibility
+
+      def return_complex_type
+        @return_complex_type ||= generate_complex_type
+      end
+
+      def typify api_map
+        decl = super
+        return decl unless decl.undefined?
+        type = see_reference(api_map)
+        return type unless type.nil?
+        ComplexType::UNDEFINED
+      end
+
+      private
+
+      # @return [ComplexType]
+      def generate_complex_type
+        tag = docstring.tag(:return)
+        if tag.nil?
+          ol = docstring.tag(:overload)
+          tag = ol.tag(:return) unless ol.nil?
+        end
+        return ComplexType::UNDEFINED if tag.nil? or tag.types.nil? or tag.types.empty?
+        begin
+          ComplexType.parse *tag.types
+        rescue Solargraph::ComplexTypeError => e
+          STDERR.puts e.message
+          ComplexType::UNDEFINED
+        end
+      end
+
+      # @param [ApiMap]
+      def see_reference api_map
+        docstring.ref_tags.each do |ref|
+          next unless ref.tag_name == 'return' && ref.owner
+          parts = ref.owner.to_s.split(/[\.#]/)
+          if parts.first.empty?
+            path = "#{namespace}#{ref.owner.to_s}"
+          else
+            fqns = api_map.qualify(parts.first, namespace)
+            return ComplexType::UNDEFINED if fqns.nil?
+            path = fqns + ref.owner.to_s[parts.first.length] + parts.last
+          end
+          pins = api_map.get_path_pins(path)
+          pins.each do |pin|
+            type = pin.typify(api_map)
+            return type unless type.undefined?
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/solargraph/pin/base_variable.rb

@@ -39,10 +39,8 @@ module Solargraph
         true
       end
 
-      # @param api_map [ApiMap]
-      def infer api_map
-        result = super
-        return result if result.defined? or @assignment.nil?
+      def probe api_map
+        return ComplexType::UNDEFINED if @assignment.nil?
         chain = Source::NodeChainer.chain(@assignment, filename)
         clip = api_map.clip_at(location.filename, location.range.start)
         locals = clip.locals - [self]

data/lib/solargraph/pin/block.rb

@@ -6,9 +6,6 @@ module Solargraph
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
-      # @return [Array<String>]
-      attr_reader :parameters
-
       def initialize location, namespace, name, comments, receiver, context
         super(location, namespace, name, comments)
         @receiver = receiver
@@ -19,6 +16,7 @@ module Solargraph
         Pin::BLOCK
       end
 
+      # @return [Array<String>]
       def parameters
         @parameters ||= []
       end

data/lib/solargraph/pin/block_parameter.rb

@@ -71,9 +71,10 @@ module Solargraph
         block
       end
 
-      # @param api_map [ApiMap]
-      def infer api_map
-        return return_complex_type unless return_complex_type.undefined?
+      def typify api_map
+        # @todo Does anything need to be eliminated because it's more accurately a probe?
+        type = super
+        return type unless type.undefined?
         chain = Source::NodeChainer.chain(block.receiver, filename)
         clip = api_map.clip_at(location.filename, location.range.start)
         locals = clip.locals - [self]

data/lib/solargraph/pin/keyword.rb

@@ -12,10 +12,6 @@ module Solargraph
       def kind
         Solargraph::Pin::KEYWORD
       end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::KEYWORD
-      end
     end
   end
 end

data/lib/solargraph/pin/localized.rb

@@ -7,9 +7,10 @@ module Solargraph
       attr_reader :presence
 
       # @param other [Pin::Base] The caller's block
-      # @param position [Position] The caller's position
+      # @param position [Position, Array(Integer, Integer)] The caller's position
       # @return [Boolean]
       def visible_from?(other, position)
+        position = Position.normalize(position)
         other.filename == filename and
           ( other == block or 
             (block.location.range.contain?(other.location.range.start) and block.location.range.contain?(other.location.range.ending))

data/lib/solargraph/pin/method.rb

@@ -1,14 +1,8 @@
 module Solargraph
   module Pin
-    class Method < Base
+    class Method < BaseMethod
       include Source::NodeMethods
 
-      # @return [Symbol] :instance or :class
-      attr_reader :scope
-
-      # @return [Symbol] :public, :private, or :protected
-      attr_reader :visibility
-
       # @return [Array<String>]
       attr_reader :parameters
 
@@ -51,15 +45,10 @@ module Solargraph
         Solargraph::LanguageServer::CompletionItemKinds::METHOD
       end
 
-      # @return [Integer]
       def symbol_kind
         LanguageServer::SymbolKinds::METHOD
       end
 
-      def return_complex_type
-        @return_complex_type ||= generate_complex_type
-      end
-
       def documentation
         if @documentation.nil?
           @documentation ||= super || ''
@@ -87,14 +76,18 @@ module Solargraph
           visibility == other.visibility
       end
 
-      def infer api_map
-        decl = super
-        return decl unless decl.undefined?
-        type = see_reference(api_map)
-        return type unless type.nil?
+      def probe api_map
         infer_from_return_nodes(api_map)
       end
 
+      # @deprecated Use #typify and/or #probe instead
+      def infer api_map
+        STDERR.puts 'WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead.'
+        type = typify(api_map)
+        return type unless type.undefined?
+        probe api_map
+      end
+
       def try_merge! pin
         return false unless super
         @node = pin.node
@@ -103,59 +96,31 @@ module Solargraph
 
       private
 
-      # @return [ComplexType]
-      def generate_complex_type
-        tag = docstring.tag(:return)
-        if tag.nil?
-          ol = docstring.tag(:overload)
-          tag = ol.tag(:return) unless ol.nil?
-        end
-        return ComplexType::UNDEFINED if tag.nil? or tag.types.nil? or tag.types.empty?
-        begin
-          ComplexType.parse *tag.types
-        rescue Solargraph::ComplexTypeError => e
-          STDERR.puts e.message
-          ComplexType::UNDEFINED
-        end
+      # @return [Parser::AST:Node, nil]
+      def method_body_node
+        return nil if node.nil?
+        return node.children[2] if node.type == :def
+        return node.children[3] if node.type == :defs
+        nil
       end
 
       # @param api_map [ApiMap]
+      # @return [ComplexType]
       def infer_from_return_nodes api_map
-        return ComplexType::UNDEFINED if node.nil? ||
-          (node.type == :def && node.children[2].nil?) ||
-          (node.type == :defs && node.children[3].nil?)
         result = []
-        nodes = node.type == :def ? returns_from(node.children[2]) : returns_from(node.children[3])
-        nodes.each do |n|
+        returns_from(method_body_node).each do |n|
           next if n.loc.nil?
-          clip = api_map.clip_at(location.filename, Solargraph::Position.new(n.loc.expression.last_line, n.loc.expression.last_column))
-          type = clip.infer
+          clip = api_map.clip_at(
+            location.filename,
+            [n.loc.expression.last_line, n.loc.expression.last_column]
+          )
+          chain = Solargraph::Source::NodeChainer.chain(n, location.filename)
+          type = chain.infer(api_map, self, clip.locals)
           result.push type unless type.undefined?
         end
         return ComplexType::UNDEFINED if result.empty?
         ComplexType.parse(*result.map(&:tag))
       end
-
-      # @param [ApiMap]
-      def see_reference api_map
-        docstring.ref_tags.each do |ref|
-          next unless ref.tag_name == 'return' && ref.owner
-          parts = ref.owner.to_s.split(/[\.#]/)
-          if parts.first.empty?
-            path = "#{namespace}#{ref.owner.to_s}"
-          else
-            fqns = api_map.qualify(parts.first, namespace)
-            return ComplexType::UNDEFINED if fqns.nil?
-            path = fqns + ref.owner.to_s[parts.first.length] + parts.last
-          end
-          pins = api_map.get_path_pins(path)
-          pins.each do |pin|
-            type = pin.infer(api_map)
-            return type unless type.undefined?
-          end
-        end
-        nil
-      end
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -46,8 +46,7 @@ module Solargraph
         @domains ||= []
       end
 
-      def infer api_map
-        # Assuming that namespace pins are always fully qualified
+      def typify api_map
         return_complex_type
       end
     end

data/lib/solargraph/range.rb

@@ -28,9 +28,10 @@ module Solargraph
 
     # True if the specified position is inside the range.
     #
-    # @param position [Solargraph::Position]
+    # @param position [Position, Array(Integer, Integer)]
     # @return [Boolean]
     def contain? position
+      position = Position.normalize(position)
       return false if position.line < start.line || position.line > ending.line
       return false if position.line == start.line && position.character < start.character
       return false if position.line == ending.line && position.character > ending.character
@@ -39,9 +40,10 @@ module Solargraph
 
     # True if the range contains the specified position and the position does not precede it.
     #
-    # @param position [Position]
+    # @param position [Position, Array(Integer, Integer)]
     # @return [Boolean]
     def include? position
+      position = Position.normalize(position)
       contain?(position) && !(position.line == start.line && position.character == start.character)
     end
 

data/lib/solargraph/source.rb

@@ -24,6 +24,7 @@ module Solargraph
     # @return [Parser::AST::Node]
     attr_reader :node
 
+    # @return [Array<Parser::Source::Comment>]
     attr_reader :comments
 
     # @return [String]
@@ -194,6 +195,9 @@ module Solargraph
       arr ? stringify_comment_array(arr) : nil
     end
 
+    # A location representing the file in its entirety.
+    #
+    # @return [Location]
     def location
       st = Position.new(0, 0)
       en = Position.from_offset(code, code.length)
@@ -203,6 +207,9 @@ module Solargraph
 
     private
 
+    # Get a hash of comments grouped by the line numbers of the associated code.
+    #
+    # @return [Hash{Integer => Array<Parser::Source::Comment>}]
     def associated_comments
       @associated_comments ||= begin
         result = {}
@@ -216,6 +223,10 @@ module Solargraph
       end
     end
 
+    # Get a string representation of an array of comments.
+    #
+    # @param comments [Array<Parser::Source::Comment>]
+    # @return [String]
     def stringify_comment_array comments
       ctxt = ''
       num = nil
@@ -309,17 +320,24 @@ module Solargraph
 
       # @param code [String]
       # @param filename [String]
+      # @param version [Integer]
       # @return [Solargraph::Source]
       def load_string code, filename = nil, version = 0
         Source.new code, filename, version
       end
 
+      # @param code [String]
+      # @param filename [String]
+      # @return [Array(Parser::AST::Node, Array<Parser::Source::Comment>)]
       def parse_with_comments code, filename = nil
         buffer = Parser::Source::Buffer.new(filename, 0)
         buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')
         parser.parse_with_comments(buffer)
       end
 
+      # @param code [String]
+      # @param filename [String]
+      # @return [Parser::AST::Node]
       def parse code, filename = nil
         buffer = Parser::Source::Buffer.new(filename, 0)
         buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')