solargraph 0.54.4 → 0.57.0

data/lib/solargraph/pin/callable.rb

@@ -6,7 +6,7 @@ module Solargraph
       # @return [Signature]
       attr_reader :block
 
-      attr_reader :parameters
+      attr_accessor :parameters
 
       # @return [ComplexType, nil]
       attr_reader :return_type
@@ -21,11 +21,74 @@ module Solargraph
         @parameters = parameters
       end
 
+      # @return [String]
+      def method_namespace
+        closure.namespace
+      end
+
+      # @param other [self]
+      # @return [Pin::Block, nil]
+      def combine_blocks(other)
+        if block.nil?
+          other.block
+        elsif other.block.nil?
+          block
+        else
+          choose_pin_attr(other, :block)
+        end
+      end
+
+      # @param other [self]
+      # @param attrs [Hash{Symbol => Object}]
+      #
+      # @return [self]
+      def combine_with(other, attrs={})
+        new_attrs = {
+          block: combine_blocks(other),
+          return_type: combine_return_type(other),
+        }.merge(attrs)
+        new_attrs[:parameters] = choose_parameters(other).clone.freeze unless new_attrs.key?(:parameters)
+        super(other, new_attrs)
+      end
+
       # @return [::Array<String>]
       def parameter_names
         @parameter_names ||= parameters.map(&:name)
       end
 
+      def generics
+        []
+      end
+
+      # @param other [self]
+      # @return [Array<Pin::Parameter>]
+      def choose_parameters(other)
+        raise "Trying to combine two pins with different arities - \nself =#{inspect}, \nother=#{other.inspect}, \n\n self.arity=#{self.arity}, \nother.arity=#{other.arity}" if other.arity != arity
+        parameters.zip(other.parameters).map do |param, other_param|
+          if param.nil? && other_param.block?
+            other_param
+          elsif other_param.nil? && param.block?
+            param
+          else
+            param.combine_with(other_param)
+          end
+        end
+      end
+
+      # @return [Array<Pin::Parameter>]
+      def blockless_parameters
+        if parameters.last&.block?
+          parameters[0..-2]
+        else
+          parameters
+        end
+      end
+
+      # @return [Array]
+      def arity
+        [generics, blockless_parameters.map(&:arity_decl), block&.arity]
+      end
+
       # @param generics_to_resolve [Enumerable<String>]
       # @param arg_types [Array<ComplexType>, nil]
       # @param return_type_context [ComplexType, nil]
@@ -57,6 +120,24 @@ module Solargraph
         callable
       end
 
+      def typify api_map
+        type = super
+        return type if type.defined?
+        if method_name.end_with?('?')
+          logger.debug { "Callable#typify(self=#{self}) => Boolean (? suffix)" }
+          ComplexType::BOOLEAN
+        else
+          logger.debug { "Callable#typify(self=#{self}) => undefined" }
+          ComplexType::UNDEFINED
+        end
+      end
+
+      # @return [String]
+      def method_name
+        raise "closure was nil in #{self.inspect}" if closure.nil?
+        @method_name ||= closure.name
+      end
+
       # @param generics_to_resolve [::Array<String>]
       # @param arg_types [Array<ComplexType>, nil]
       # @param return_type_context [ComplexType, nil]
@@ -124,6 +205,7 @@ module Solargraph
         true
       end
 
+      # @return [Integer]
       def mandatory_positional_param_count
         parameters.count(&:arg?)
       end
@@ -140,8 +222,6 @@ module Solargraph
       protected
 
       attr_writer :block
-
-      attr_writer :parameters
     end
   end
 end

data/lib/solargraph/pin/closure.rb

@@ -8,10 +8,29 @@ module Solargraph
 
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::Parameter>, nil]
-      def initialize scope: :class, generics: nil, **splat
+      # @param generic_defaults [Hash{String => ComplexType}]
+      def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
         super(**splat)
         @scope = scope
         @generics = generics
+        @generic_defaults = generic_defaults
+      end
+
+      # @return [Hash{String => ComplexType}]
+      def generic_defaults
+        @generic_defaults ||= {}
+      end
+
+      # @param other [self]
+      # @param attrs [Hash{Symbol => Object}]
+      #
+      # @return [self]
+      def combine_with(other, attrs={})
+        new_attrs = {
+          scope: assert_same(other, :scope),
+          generics: generics.empty? ? other.generics : generics,
+        }.merge(attrs)
+        super(other, new_attrs)
       end
 
       def context

data/lib/solargraph/pin/common.rb

@@ -3,11 +3,20 @@
 module Solargraph
   module Pin
     module Common
+      # @!method source
+      #   @abstract
+      #   @return [Source, nil]
+      # @type @closure [Pin::Closure, nil]
+
       # @return [Location]
       attr_reader :location
 
+      # @sg-ignore Solargraph::Pin::Common#closure return type could not be inferred
       # @return [Pin::Closure, nil]
-      attr_reader :closure
+      def closure
+        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
+        @closure
+      end
 
       # @return [String]
       def name

data/lib/solargraph/pin/constant.rb

@@ -5,6 +5,8 @@ module Solargraph
     class Constant < BaseVariable
       attr_reader :visibility
 
+      # @param visibility [::Symbol] The visibility of the constant (:public, :protected, or :private)
+      # @param splat [Hash] Additional options supported by superclasses
       def initialize visibility: :public, **splat
         super(**splat)
         @visibility = visibility

data/lib/solargraph/pin/delegated_method.rb

@@ -24,8 +24,26 @@ module Solargraph
         @receiver_method_name = receiver_method_name
       end
 
-      %i[comments parameters return_type location].each do |method|
+      def inner_desc
+        "#{name} => #{@receiver_chain}##{@receiver_method_name}"
+      end
+
+      def location
+        return super if super
+
+        @resolved_method&.send(:location)
+      end
+
+
+      def type_location
+        return super if super
+
+        @resolved_method&.send(:type_location)
+      end
+
+      %i[comments parameters return_type signatures].each do |method|
         define_method(method) do
+          # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method) : super()
         end
       end
@@ -33,7 +51,9 @@ module Solargraph
       %i[typify realize infer probe].each do |method|
         # @param api_map [ApiMap]
         define_method(method) do |api_map|
+          # @sg-ignore Unresolved call to resolve_method
           resolve_method(api_map)
+          # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)
         end
       end

data/lib/solargraph/pin/documenting.rb

@@ -9,6 +9,22 @@ require 'solargraph/converters/dt'
 require 'solargraph/converters/dd'
 require 'solargraph/converters/misc'
 
+# @todo upstream this definition
+
+# @!parse
+#   module ::Kramdown
+#     class Document
+#       # @return [String]
+#       def to_html; end
+#     end
+#   end
+#   module ReverseMarkdown
+#     # @param input [String]
+#     # @param options [Hash]
+#     # @return [String]
+#     def self.convert(input, options = {}); end
+#   end
+
 module Solargraph
   module Pin
     # A module to add the Pin::Base#documentation method.

data/lib/solargraph/pin/keyword.rb

@@ -3,8 +3,13 @@
 module Solargraph
   module Pin
     class Keyword < Base
-      def initialize name
-        super(name: name)
+      def initialize(name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(name: name, **kwargs)
+      end
+
+      def closure
+        @closure ||= Pin::ROOT_PIN
       end
 
       def name

data/lib/solargraph/pin/local_variable.rb

@@ -6,20 +6,32 @@ module Solargraph
       # @return [Range]
       attr_reader :presence
 
+      def presence_certain?
+        @presence_certain
+      end
+
       # @param assignment [AST::Node, nil]
       # @param presence [Range, nil]
+      # @param presence_certain [Boolean]
       # @param splat [Hash]
-      def initialize assignment: nil, presence: nil, **splat
+      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
         super(**splat)
         @assignment = assignment
         @presence = presence
+        @presence_certain = presence_certain
       end
 
-      # @param pin [self]
-      def try_merge! pin
-        return false unless super
-        @presence = pin.presence
-        true
+      def combine_with(other, attrs={})
+        new_attrs = {
+          assignment: assert_same(other, :assignment),
+          presence_certain: assert_same(other, :presence_certain?),
+        }.merge(attrs)
+        # @sg-ignore Wrong argument type for
+        #   Solargraph::Pin::Base#assert_same: other expected
+        #   Solargraph::Pin::Base, received self
+        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
+
+        super(other, new_attrs)
       end
 
       # @param other_closure [Pin::Closure]