solargraph 0.32.5 → 0.33.0

data/lib/solargraph/pin/method.rb

@@ -9,38 +9,21 @@ module Solargraph
       # @return [Parser::AST::Node]
       attr_reader :node
 
-      def initialize location, namespace, name, comments, scope, visibility, args, node = nil
-        super(location, namespace, name, comments)
-        @scope = scope
-        @visibility = visibility
+      def initialize args: [], node: nil, **splat
+        super(splat)
         @parameters = args
         @node = node
       end
 
       # @return [Array<String>]
       def parameter_names
-        @parameter_names ||= parameters.map{|p| p.split(/[ =:]/).first}
+        @parameter_names ||= parameters.map{|p| p.split(/[ =:]/).first.gsub(/^(\*{1,2}|&)/, '')}
       end
 
       def kind
         Solargraph::Pin::METHOD
       end
 
-      def path
-        @path ||= namespace + (scope == :instance ? '#' : '.') + name
-      end
-
-      def context
-        @context ||= begin
-          if scope == :class
-            # @todo Determine whether the namespace is a class or a module
-            ComplexType.try_parse("Class<#{namespace}>")
-          else
-            ComplexType.try_parse(namespace)
-          end
-        end
-      end
-
       def completion_item_kind
         Solargraph::LanguageServer::CompletionItemKinds::METHOD
       end
@@ -59,14 +42,14 @@ module Solargraph
             lines = []
             param_tags.each do |p|
               l = "* #{p.name}"
-              l += " [#{p.types.join(', ')}]" unless p.types.nil? or p.types.empty?
+              l += " [#{p.types.map { |t| HTMLEntities.new.encode(t) }.join(', ')}]" unless p.types.nil? or p.types.empty?
               l += " #{p.text}"
               lines.push l
             end
             @documentation += lines.join("\n")
           end
         end
-        @documentation
+        @documentation.to_s
       end
 
       def nearly? other
@@ -80,14 +63,6 @@ module Solargraph
         infer_from_return_nodes(api_map)
       end
 
-      # @deprecated Use #typify and/or #probe instead
-      def infer api_map
-        Solargraph::Logging.logger.warn '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
@@ -96,7 +71,7 @@ module Solargraph
 
       private
 
-      # @return [Parser::AST:Node, nil]
+      # @return [Parser::AST::Node, nil]
       def method_body_node
         return nil if node.nil?
         return node.children[2] if node.type == :def
@@ -108,18 +83,29 @@ module Solargraph
       # @return [ComplexType]
       def infer_from_return_nodes api_map
         result = []
+        has_nil = false
         returns_from(method_body_node).each do |n|
-          next if n.loc.nil?
-          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?
+          if n.nil? || n.type == :nil
+            has_nil = true
+            next
+          end
+          literal = infer_literal_node_type(n)
+          if literal
+            result.push ComplexType.try_parse(literal)
+          else
+            next if n.loc.nil? || n.loc.expression.nil?
+            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
         end
+        result.push ComplexType::NIL if has_nil
         return ComplexType::UNDEFINED if result.empty?
-        ComplexType.try_parse(*result.map(&:tag))
+        ComplexType.try_parse(*result.map(&:tag).uniq)
       end
     end
   end

data/lib/solargraph/pin/method_alias.rb

@@ -4,16 +4,15 @@ module Solargraph
     # examples that defer mapping are aliases for superclass methods or
     # methods from included modules.
     #
-    class MethodAlias < Base
+    class MethodAlias < BaseMethod
+      # @return [::Symbol]
       attr_reader :scope
 
+      # @return [String]
       attr_reader :original
 
-      def initialize location, namespace, name, scope, original
-        # @todo Determine how to handle these parameters. Among other things,
-        #   determine if the visibility is defined by the location of the
-        #   alias call or the original method.
-        super(location, namespace, name, '')
+      def initialize scope: :instance, original: nil, **splat
+        super(splat)
         @scope = scope
         @original = original
       end
@@ -22,6 +21,10 @@ module Solargraph
         Pin::METHOD_ALIAS
       end
 
+      def visibility
+        :public
+      end
+
       def path
         @path ||= namespace + (scope == :instance ? '#' : '.') + name
       end

data/lib/solargraph/pin/namespace.rb

@@ -1,24 +1,47 @@
 module Solargraph
   module Pin
-    class Namespace < Pin::Base
-      # @return [Symbol] :public or :private
+    class Namespace < Closure
+      # @return [::Symbol] :public or :private
       attr_reader :visibility
 
-      # @return [Symbol] :class or :module
+      # @return [::Symbol] :class or :module
       attr_reader :type
 
-      def initialize location, namespace, name, comments, type, visibility
-        super(location, namespace, name, comments)
+      # def initialize location, namespace, name, comments, type, visibility
+      def initialize type: :class, visibility: :public, **splat
+        # super(location, namespace, name, comments)
+        super(splat)
         @type = type
         @visibility = visibility
+        if name.start_with?('::')
+          @name = name[2..-1]
+          @closure = Pin::ROOT_PIN
+        end
+        @gate = @name
+        if @gate.include?('::')
+          parts = @gate.split('::')
+          @name = parts.last
+          adjusted = (@closure ? @closure.path : Pin::ROOT_PIN.path).split('::') + parts[0..-2]
+          # @closure = Pin::Base.new(kind: NAMESPACE, name: adjusted.join('::'))
+          @closure = Pin::Namespace.new(name: adjusted.join('::'))
+          @context = nil
+        end
+      end
+
+      def namespace
+        context.namespace
       end
 
       def kind
         Pin::NAMESPACE
       end
 
-      def context
-        @context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
+      def full_context
+        @full_context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
+      end
+
+      def binder
+        full_context
       end
 
       def scope
@@ -38,8 +61,8 @@ module Solargraph
         @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
       end
 
-      def return_complex_type
-        @return_complex_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
+      def return_type
+        @return_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
       end
 
       def domains
@@ -47,7 +70,7 @@ module Solargraph
       end
 
       def typify api_map
-        return_complex_type
+        return_type
       end
     end
   end

data/lib/solargraph/pin/parameter.rb

@@ -0,0 +1,150 @@
+module Solargraph
+  module Pin
+    class Parameter < LocalVariable
+      def return_type
+        if @return_type.nil?
+          @return_type = ComplexType.new
+          found = param_tag
+          @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
+        end
+        super
+        @return_type
+      end
+
+      # The parameter's zero-based location in the block's signature.
+      #
+      # @return [Integer]
+      def index
+        closure.parameter_names.index(name)
+      end
+
+      # @param api_map [ApiMap]
+      def typify api_map
+        return return_type.qualify(api_map, closure.context.namespace) unless return_type.undefined?
+        closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
+      end
+
+      def try_merge! pin
+        return false unless super && closure.nearly?(pin.closure)
+        @return_type = pin.return_type
+        reset_conversions
+        true
+      end
+
+      def documentation
+        tag = param_tag
+        return '' if tag.nil? || tag.text.nil?
+        tag.text
+      end
+
+      private
+
+      # @return [YARD::Tags::Tag]
+      def param_tag
+        found = nil
+        params = closure.docstring.tags(:param)
+        params.each do |p|
+          next unless p.name == name
+          found = p
+          break
+        end
+        if found.nil? and !index.nil?
+          found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+        end
+        found
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def typify_block_param api_map
+        if closure.is_a?(Pin::Block) && closure.receiver
+          chain = Source::NodeChainer.chain(closure.receiver, filename)
+          clip = api_map.clip_at(location.filename, location.range.start)
+          locals = clip.locals - [self]
+          meths = chain.define(api_map, closure, locals)
+          meths.each do |meth|
+            if (Solargraph::CoreFills::METHODS_WITH_YIELDPARAM_SUBTYPES.include?(meth.path))
+              bmeth = chain.base.define(api_map, closure, locals).first
+              return ComplexType::UNDEFINED if bmeth.nil? || bmeth.return_type.undefined? || bmeth.return_type.subtypes.empty?
+              return bmeth.return_type.subtypes.first.qualify(api_map, bmeth.context.namespace)
+            elsif (Solargraph::CoreFills::METHODS_WITH_YIELDPARAM_SELF.include?(meth.path))
+              bmeth = chain.base.define(api_map, closure, locals).first
+              return ComplexType::UNDEFINED if bmeth.nil?
+              return bmeth.typify(api_map)
+            else
+              yps = meth.docstring.tags(:yieldparam)
+              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
+                return ComplexType.try_parse(yps[index].types.first).qualify(api_map, meth.context.namespace)
+              end
+            end
+          end
+        end
+        ComplexType::UNDEFINED
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def typify_method_param api_map
+        meths = api_map.get_method_stack(closure.full_context.namespace, closure.name, scope: closure.scope)
+        # meths.shift # Ignore the first one
+        meths.each do |meth|
+          found = nil
+          params = meth.docstring.tags(:param)
+          if params.empty?
+            params = see_reference(docstring, api_map)
+          end
+          params.each do |p|
+            next unless p.name == name
+            found = p
+            break
+          end
+          if found.nil? and !index.nil?
+            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          end
+          return ComplexType.try_parse(*found.types).qualify(api_map, meth.context.namespace) unless found.nil? || found.types.nil?
+        end
+        ComplexType::UNDEFINED
+      end
+
+      # @param heredoc [YARD::Docstring]
+      # @param api_map [ApiMap]
+      # @param skip [Array]
+      # @return [ComplexType]
+      def see_reference heredoc, api_map, skip = []
+        heredoc.ref_tags.each do |ref|
+          next unless ref.tag_name == 'param' && ref.owner
+          result = resolve_reference(ref.owner.to_s, api_map, skip)
+          return result unless result.nil?
+        end
+        []
+      end
+
+      # @param ref [String]
+      # @param api_map [ApiMap]
+      # @param skip [Array]
+      # @return [ComplexType]
+      def resolve_reference ref, api_map, skip
+        return nil if skip.include?(ref)
+        skip.push ref
+        parts = ref.split(/[\.#]/)
+        if parts.first.empty?
+          path = "#{namespace}#{ref}"
+        else
+          fqns = api_map.qualify(parts.first, namespace)
+          return ComplexType::UNDEFINED if fqns.nil?
+          path = fqns + ref[parts.first.length] + parts.last
+        end
+        pins = api_map.get_path_pins(path)
+        pins.each do |pin|
+          params = pin.docstring.tags(:param)
+          return params unless params.empty?
+        end
+        pins.each do |pin|
+          params = see_reference(pin.docstring, api_map, skip)
+          return params unless params.empty?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/solargraph/pin/proxy_type.rb

@@ -1,13 +1,10 @@
 module Solargraph
   module Pin
     class ProxyType < Base
-      # @param location [Solargraph::Location]
-      # @param namespace [String]
-      # @param name [String]
       # @param return_type [ComplexType]
-      def initialize location, namespace, name, return_type
-        super(location, namespace, name, '')
-        @return_complex_type = return_type
+      def initialize return_type: ComplexType::UNDEFINED, **splat
+        super(splat)
+        @return_type = return_type
       end
 
       def path
@@ -19,7 +16,7 @@ module Solargraph
       end
 
       def context
-        @return_complex_type
+        @return_type
       end
 
       # @param return_type [ComplexType]
@@ -28,7 +25,10 @@ module Solargraph
         parts = return_type.namespace.split('::')
         namespace = parts[0..-2].join('::').to_s
         name = parts.last.to_s
-        ProxyType.new(nil, namespace, name, return_type)
+        # ProxyType.new(nil, namespace, name, return_type)
+        ProxyType.new(
+          closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type
+        )
       end
     end
   end

data/lib/solargraph/pin/reference.rb

@@ -5,18 +5,7 @@ module Solargraph
       autoload :Superclass, 'solargraph/pin/reference/superclass'
       autoload :Include,    'solargraph/pin/reference/include'
       autoload :Extend,     'solargraph/pin/reference/extend'
-
-      def initialize location, namespace, name
-        super(location, namespace, name, '')
-      end
-
-      # @todo Should Reference.new be protected?
-      # class << self
-      #   protected
-      #   def new *args
-      #     super
-      #   end
-      # end
+      autoload :Override,   'solargraph/pin/reference/override'
     end
   end
 end

data/lib/solargraph/pin/reference/override.rb

@@ -0,0 +1,18 @@
+module Solargraph
+  module Pin
+    class Reference
+      class Override < Reference
+        attr_reader :tags
+
+        def initialize location, name, tags
+          super(location: location, name: name)
+          @tags = tags
+        end
+
+        def kind
+          Pin::OVERRIDE_REFERENCE
+        end
+      end
+    end
+  end
+end