solargraph 0.59.0.dev.1 → 0.59.0.dev.2

data/lib/solargraph/pin/callable.rb

@@ -14,6 +14,7 @@ module Solargraph
       # @param block [Signature, nil]
       # @param return_type [ComplexType, nil]
       # @param parameters [::Array<Pin::Parameter>]
+      # @param [Hash{Symbol => Object}] splat
       def initialize block: nil, return_type: nil, parameters: [], **splat
         super(**splat)
         @block = block
@@ -36,7 +37,7 @@ module Solargraph
       # @param other [self]
       #
       # @return [Pin::Signature, nil]
-      def combine_blocks(other)
+      def combine_blocks other
         if block.nil?
           other.block
         elsif other.block.nil?
@@ -51,10 +52,10 @@ module Solargraph
       # @param attrs [Hash{Symbol => Object}]
       #
       # @return [self]
-      def combine_with(other, attrs={})
+      def combine_with other, attrs = {}
         new_attrs = {
           block: combine_blocks(other),
-          return_type: combine_return_type(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)
@@ -72,8 +73,10 @@ module Solargraph
       # @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
+      def choose_parameters other
+        if other.arity != arity
+          raise "Trying to combine two pins with different arities - \nself =#{inspect}, \nother=#{other.inspect}, \n\n self.arity=#{arity}, \nother.arity=#{other.arity}"
+        end
         # @param param [Pin::Parameter]
         # @param other_param [Pin::Parameter]
         parameters.zip(other.parameters).map do |param, other_param|
@@ -129,16 +132,15 @@ module Solargraph
       # @param return_type_context [ComplexType, nil]
       # @param yield_arg_types [Array<ComplexType>, nil]
       # @param yield_return_type_context [ComplexType, nil]
-      # @param context [ComplexType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}]
       #
       # @return [self]
-      def resolve_generics_from_context(generics_to_resolve,
+      def resolve_generics_from_context generics_to_resolve,
                                         arg_types = nil,
                                         return_type_context = nil,
                                         yield_arg_types = nil,
                                         yield_return_type_context = nil,
-                                        resolved_generic_values: {})
+                                        resolved_generic_values: {}
         callable = super(generics_to_resolve, return_type_context, resolved_generic_values: resolved_generic_values)
         callable.parameters = callable.parameters.each_with_index.map do |param, i|
           if arg_types.nil?
@@ -149,10 +151,12 @@ module Solargraph
                                                 resolved_generic_values: resolved_generic_values)
           end
         end
-        callable.block = block.resolve_generics_from_context(generics_to_resolve,
-                                                              yield_arg_types,
-                                                              yield_return_type_context,
-                                                              resolved_generic_values: resolved_generic_values) if callable.block?
+        if callable.block?
+          callable.block = block.resolve_generics_from_context(generics_to_resolve,
+                                                               yield_arg_types,
+                                                               yield_return_type_context,
+                                                               resolved_generic_values: resolved_generic_values)
+        end
         callable
       end
 
@@ -171,7 +175,7 @@ module Solargraph
       # @sg-ignore Need to add nil check here
       # @return [String]
       def method_name
-        raise "closure was nil in #{self.inspect}" if closure.nil?
+        raise "closure was nil in #{inspect}" if closure.nil?
         # @sg-ignore Need to add nil check here
         @method_name ||= closure.name
       end
@@ -181,16 +185,15 @@ module Solargraph
       # @param return_type_context [ComplexType, nil]
       # @param yield_arg_types [Array<ComplexType>, nil]
       # @param yield_return_type_context [ComplexType, nil]
-      # @param context [ComplexType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}]
       #
       # @return [self]
-      def resolve_generics_from_context_until_complete(generics_to_resolve,
+      def resolve_generics_from_context_until_complete generics_to_resolve,
                                                        arg_types = nil,
                                                        return_type_context = nil,
                                                        yield_arg_types = nil,
                                                        yield_return_type_context = nil,
-                                                       resolved_generic_values: {})
+                                                       resolved_generic_values: {}
         # See
         # https://github.com/soutaro/steep/tree/master/lib/steep/type_inference
         # and
@@ -208,7 +211,7 @@ module Solargraph
                                                 resolved_generic_values: resolved_generic_values)
         if last_resolved_generic_values == resolved_generic_values
           # erase anything unresolved
-          return new_pin.erase_generics(self.generics)
+          return new_pin.erase_generics(generics)
         end
         new_pin.resolve_generics_from_context_until_complete(generics_to_resolve,
                                                              arg_types,
@@ -221,7 +224,7 @@ module Solargraph
       # @yieldparam [ComplexType]
       # @yieldreturn [ComplexType]
       # @return [self]
-      def transform_types(&transform)
+      def transform_types &transform
         # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
         callable = super(&transform)
         callable.block = block.transform_types(&transform) if block?
@@ -246,11 +249,6 @@ module Solargraph
         true
       end
 
-      def reset_generated!
-        super
-        @parameters.each(&:reset_generated!)
-      end
-
       # @return [Integer]
       def mandatory_positional_param_count
         parameters.count(&:arg?)
@@ -258,12 +256,11 @@ module Solargraph
 
       # @return [String]
       def parameters_to_rbs
-        # @sg-ignore Need to add nil check here
-        rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ')
+        "#{rbs_generics}(#{parameters.map(&:to_rbs).join(', ')}) #{"{ #{block.to_rbs} } " unless block.nil?}"
       end
 
       def to_rbs
-        parameters_to_rbs + '-> ' + (return_type&.to_rbs || 'untyped')
+        "#{parameters_to_rbs}-> #{return_type&.to_rbs || 'untyped'}"
       end
 
       def block?

data/lib/solargraph/pin/closure.rb

@@ -9,7 +9,8 @@ module Solargraph
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::String>, nil]
       # @param generic_defaults [Hash{String => ComplexType}]
-      def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
+      # @param [Hash{Symbol => Object}] splat
+      def initialize scope: :class, generics: nil, generic_defaults: {}, **splat
         super(**splat)
         @scope = scope
         @generics = generics
@@ -25,10 +26,10 @@ module Solargraph
       # @param attrs [Hash{Symbol => Object}]
       #
       # @return [self]
-      def combine_with(other, attrs={})
+      def combine_with other, attrs = {}
         new_attrs = {
           scope: assert_same(other, :scope),
-          generics: generics.empty? ? other.generics : generics,
+          generics: generics.empty? ? other.generics : generics
         }.merge(attrs)
         super(other, new_attrs)
       end
@@ -61,7 +62,7 @@ module Solargraph
       def rbs_generics
         return '' if generics.empty?
 
-        '[' + generics.map { |gen| gen.to_s }.join(', ') + '] '
+        "[#{generics.map(&:to_s).join(', ')}] "
       end
     end
   end

data/lib/solargraph/pin/common.rb

@@ -18,7 +18,7 @@ module Solargraph
 
       # @param value [Pin::Closure]
       # @return [void]
-      def closure=(value)
+      def closure= value
         @closure = value
         # remove cached values generated from closure
         reset_generated!
@@ -26,7 +26,10 @@ module Solargraph
 
       # @return [Pin::Closure, nil]
       def closure
-        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
+        unless @closure
+          Solargraph.assert_or_log(:closure,
+                                   "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}")
+        end
         @closure
       end
 

data/lib/solargraph/pin/compound_statement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Pin
     # A series of statements where if a given statement executes, /all
@@ -42,10 +44,8 @@ module Solargraph
     class CompoundStatement < Pin::Base
       attr_reader :node
 
-      # @param receiver [Parser::AST::Node, nil]
       # @param node [Parser::AST::Node, nil]
-      # @param context [ComplexType, nil]
-      # @param args [::Array<Parameter>]
+      # @param [Hash{Symbol => Object}] splat
       def initialize node: nil, **splat
         super(**splat)
         @node = node

data/lib/solargraph/pin/constant.rb

@@ -1,45 +1,43 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    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
-      end
-
-      def return_type
-        @return_type ||= generate_complex_type
-      end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::CONSTANT
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        LanguageServer::SymbolKinds::CONSTANT
-      end
-
-      def path
-        @path ||= context.namespace.to_s.empty? ? name : "#{context.namespace}::#{name}"
-      end
-
-      private
-
-      # @return [ComplexType]
-      def generate_complex_type
-        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
-        if tags.empty?
-          tags = docstring.tags(:type).map(&:types).flatten.reject(&:nil?)
-        end
-        return ComplexType::UNDEFINED if tags.empty?
-        ComplexType.try_parse *tags
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    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
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::CONSTANT
+      end
+
+      # @return [Integer]
+      def symbol_kind
+        LanguageServer::SymbolKinds::CONSTANT
+      end
+
+      def path
+        @path ||= context.namespace.to_s.empty? ? name : "#{context.namespace}::#{name}"
+      end
+
+      private
+
+      # @return [ComplexType]
+      def generate_complex_type
+        tags = docstring.tags(:return).map(&:types).flatten.compact
+        tags = docstring.tags(:type).map(&:types).flatten.compact if tags.empty?
+        return ComplexType::UNDEFINED if tags.empty?
+        ComplexType.try_parse(*tags)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/conversions.rb

@@ -43,8 +43,7 @@ module Solargraph
           data: {
             path: path,
             return_type: return_type.tag,
-            # @sg-ignore flow sensitive typing needs to handle attrs
-            location: (location ? location.to_hash : nil),
+            location: location&.to_hash,
             deprecated: deprecated?
           }
         }
@@ -73,7 +72,13 @@ module Solargraph
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
         detail = String.new
-        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
+        unless return_type.undefined?
+          detail += "=#{if probed?
+                          '~'
+                        else
+                          (proxied? ? '^' : '>')
+                        end} #{return_type}"
+        end
         detail.strip!
         return nil if detail.empty?
         detail
@@ -117,7 +122,7 @@ module Solargraph
       # @return [String]
       def escape_brackets text
         # text.gsub(/(\<|\>)/, "\\#{$1}")
-        text.gsub("<", '\<').gsub(">", '\>')
+        text.gsub('<', '\<').gsub('>', '\>')
       end
     end
   end

data/lib/solargraph/pin/delegated_method.rb

@@ -15,6 +15,7 @@ module Solargraph
       # @param receiver [Source::Chain, nil] the source code used to resolve the receiver for this delegated method.
       # @param name [String, nil]
       # @param receiver_method_name [String, nil] the method name that will be called on the receiver (defaults to :name).
+      # @param [Hash{Symbol => Object}] splat
       def initialize(method: nil, receiver: nil, name: method&.name, receiver_method_name: name, **splat)
         raise ArgumentError, 'either :method or :receiver is required' if (method && receiver) || (!method && !receiver)
         # @sg-ignore Need to add nil check here
@@ -35,7 +36,6 @@ module Solargraph
         @resolved_method&.send(:location)
       end
 
-
       def type_location
         return super if super
 
@@ -59,7 +59,7 @@ module Solargraph
       end
 
       # @param api_map [ApiMap]
-      def resolvable?(api_map)
+      def resolvable? api_map
         resolve_method(api_map)
         !!@resolved_method
       end
@@ -112,10 +112,10 @@ module Solargraph
       #
       # @param chain [Source::Chain]
       # @return [String]
-      def print_chain(chain)
+      def print_chain chain
         out = +''
         chain.links.each_with_index do |link, index|
-          if index > 0
+          if index.positive?
             if Source::Chain::Constant
               out << '::' unless link.word.start_with?('::')
             else

data/lib/solargraph/pin/documenting.rb

@@ -62,7 +62,7 @@ module Solargraph
 
         # @return [String]
         def to_code
-          "\n```ruby\n#{Documenting.normalize_indentation(@plaintext)}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n"
+          "\n```ruby\n#{Documenting.normalize_indentation(@plaintext)}#{"\n" unless @plaintext.end_with?("\n")}```\n\n"
         end
 
         # @return [String]
@@ -78,7 +78,8 @@ module Solargraph
           # line and at least two spaces of indentation. This is a common
           # convention in Ruby core documentation, e.g., String#split.
           sections = [DocSection.new(false)]
-          Documenting.normalize_indentation(Documenting.strip_html_comments(docstring.to_s.gsub("\t", '  '))).lines.each do |l|
+          Documenting.normalize_indentation(Documenting.strip_html_comments(docstring.to_s.gsub("\t",
+                                                                                                '  '))).lines.each do |l|
             if l.start_with?('  ')
               # Code block
               sections.push DocSection.new(true) unless sections.last.code?

data/lib/solargraph/pin/local_variable.rb

@@ -6,7 +6,7 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType, ComplexType::UniqueType]
       def probe api_map
-        if presence_certain? && return_type && return_type&.defined?
+        if presence_certain? && return_type&.defined?
           # flow sensitive typing has already figured out this type
           # has been downcast - use the type it figured out
           # @sg-ignore flow sensitive typing should support ivars
@@ -16,15 +16,15 @@ module Solargraph
         super
       end
 
-      def combine_with(other, attrs={})
+      def combine_with other, attrs = {}
         # keep this as a parameter
-        return other.combine_with(self, attrs) if other.is_a?(Parameter) && !self.is_a?(Parameter)
+        return other.combine_with(self, attrs) if other.is_a?(Parameter) && !is_a?(Parameter)
 
         super
       end
 
       def to_rbs
-        (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
+        "#{name || '(anon)'} #{return_type&.to_rbs || 'untyped'}"
       end
     end
   end