Add #to_rbs methods to pins, use for better .inspect() output (#789)

* Add #to_rbs methods to pins, use for better .inspect() output

* Add inspect() to Chain::Link, to_rbs to Pin::Namespace

* Fix typo

* Show variable assignments in #desc

* Method generics resolution via argument types (#794)

* Improve block handling in signature selection

Fixes #777

* Resolve method generics

* Track generics in method signatures from RBS and YARD

* Erase method generics that couldn't be resolved

* Refactor Pin#resolve_types to use Pin#transform_types

* Fix issues with UniqueType#transform()

* Cleanups

* Move to keyword parameters for resolved_generic_values

* Add type erasure, method pin rewrite code

* Populate Method parameter/return_type/block from signature

* Mark completed TODOs

* Ruby 3.0 compatibility

* Add erase_generics() to ComplexType::TypeMethods

* TODO -> @todo

* Resolve some TODOs

* Resolve TODOs

* Revert accidental change

* Bring back spec

* Provide full tag to get_method_stack() for better inference

* Fix a missed spot referring to allowlist

* Ensure Signature#generics is not nil

* Various #to_rbs and #inspect improvements

* Clean up code

* Drop accidental addition

* Improve RBS generation from UniqueType

* Use rooted names when generating RBS when available

* Drop bad documentation

Author: apiology

lib/solargraph/complex_type.rb

@@ -47,10 +47,9 @@ def first
 
     # @return [String]
     def to_rbs
-      ((@items.length > 1 ? '(' : '') + @items.map do |item|
-        "#{item.namespace}#{item.parameters? ? "[#{item.subtypes.map { |s| s.to_rbs }.join(', ')}]" : ''}"
-      end.join(' | ') + (@items.length > 1 ? ')' : '')).gsub(/undefined/, 'untyped')
-      # "
+      ((@items.length > 1 ? '(' : '') +
+       @items.map(&:to_rbs).join(' | ') +
+       (@items.length > 1 ? ')' : ''))
     end
 
     # @yieldparam [UniqueType]

lib/solargraph/complex_type/type_methods.rb

@@ -115,6 +115,12 @@ def rooted_namespace
         "::#{namespace}"
       end
 
+      # @return [String]
+      def rooted_name
+        return name unless rooted?
+        "::#{name}"
+      end
+
       # @return [::Symbol] :class or :instance
       def scope
         @scope ||= :instance if duck_type? || nil_type?

lib/solargraph/complex_type/unique_type.rb

@@ -65,10 +65,34 @@ def items
         [self]
       end
 
+      # @return [String]
+      def rbs_name
+        if name == 'undefined'
+          'untyped'
+        else
+          rooted_name
+        end
+      end
+
       # @return [String]
       def to_rbs
-        "#{namespace}#{parameters? ? "[#{subtypes.map { |s| s.to_rbs }.join(', ')}]" : ''}"
-        # "
+        if ['Tuple', 'Array'].include?(name) && fixed_parameters?
+          # tuples don't have a name; they're just [foo, bar, baz].
+          if substring == '()'
+            # but there are no zero element tuples, so we go with an array
+            'Array[]'
+          else
+            # already generated surrounded by []
+            parameters_as_rbs
+          end
+        else
+          "#{rbs_name}#{parameters_as_rbs}"
+        end
+      end
+
+      # @return [String]
+      def parameters_as_rbs
+        parameters? ? "[#{all_params.map { |s| s.to_rbs }.join(', ')}]" : ''
       end
 
       def generic?
@@ -180,7 +204,7 @@ def recreate(new_name: nil, new_key_types: nil, new_subtypes: nil)
       def transform(new_name = nil, &transform_type)
         new_key_types = @key_types.flat_map { |ct| ct.map { |ut| ut.transform(&transform_type) } }.compact
         new_subtypes = @subtypes.flat_map { |ct| ct.map { |ut| ut.transform(&transform_type) } }.compact
-        new_type = recreate(new_name: new_name || name, new_key_types: new_key_types, new_subtypes: new_subtypes)
+        new_type = recreate(new_name: new_name || rooted_name, new_key_types: new_key_types, new_subtypes: new_subtypes)
         yield new_type
       end
 

lib/solargraph/pin/base.rb

@@ -94,7 +94,7 @@ def symbol_kind
       end
 
       def to_s
-        name.to_s
+        to_rbs
       end
 
       # @return [Boolean]
@@ -257,8 +257,26 @@ def identity
         @identity ||= "#{closure.path}|#{name}"
       end
 
+      # @return [String, nil]
+      def to_rbs
+        return_type.to_rbs
+      end
+
+      # @return [String, nil]
+      def desc
+        if path
+          if to_rbs
+            path + ' ' + to_rbs
+          else
+            path
+          end
+        else
+          to_rbs
+        end
+      end
+
       def inspect
-        "#<#{self.class} `#{self.path}` at #{self.location.inspect}>"
+        "#<#{self.class} `#{self.desc}` at #{self.location.inspect}>"
       end
 
       protected

lib/solargraph/pin/base_variable.rb

@@ -71,6 +71,10 @@ def try_merge! pin
         true
       end
 
+      def desc
+        "#{to_rbs} = #{assignment&.type.inspect}"
+      end
+
       private
 
       # @return [ComplexType]

lib/solargraph/pin/closure.rb

@@ -40,6 +40,13 @@ def gates
       def generics
         @generics ||= docstring.tags(:generic).map(&:name)
       end
+
+      # @return [String]
+      def generics_as_rbs
+        return '' if generics.empty?
+
+        generics.join(', ') + ' '
+      end
     end
   end
 end

lib/solargraph/pin/local_variable.rb

@@ -30,6 +30,11 @@ def visible_at?(other_closure, other_loc)
           match_named_closure(other_closure, closure)
       end
 
+      # @return [String]
+      def to_rbs
+        (name || '(anon)') + ' ' + (@return_type&.to_rbs || 'untyped')
+      end
+
       private
 
       # @param tag1 [String]

lib/solargraph/pin/method.rb

@@ -166,6 +166,27 @@ def signature_help
         end
       end
 
+      def desc
+        # ensure the signatures line up when logged
+        if signatures.length > 1
+          "\n#{to_rbs}\n"
+        else
+          to_rbs
+        end
+      end
+
+      def to_rbs
+        return nil if signatures.empty?
+
+        rbs = "def #{name}: #{signatures.first.to_rbs}"
+        signatures[1..].each do |sig|
+          rbs += "\n"
+          rbs += (' ' * (4 + name.length))
+          rbs += "| #{name}: #{sig.to_rbs}"
+        end
+        rbs
+      end
+
       def path
         @path ||= "#{namespace}#{(scope == :instance ? '#' : '.')}#{name}"
       end

lib/solargraph/pin/namespace.rb

@@ -40,6 +40,18 @@ def initialize type: :class, visibility: :public, gates: [''], **splat
         end
       end
 
+      def to_rbs
+        "#{@type.to_s} #{generics_as_rbs}#{return_type.to_rbs}"
+      end
+
+      def desc
+        if name.nil?
+          '(top-level)'
+        else
+          to_rbs
+        end
+      end
+
       def namespace
         context.namespace
       end

lib/solargraph/pin/parameter.rb

@@ -36,6 +36,23 @@ def block?
         [:block, :blockarg].include?(decl)
       end
 
+      def to_rbs
+        case decl
+        when :optarg
+          "?#{super}"
+        when :kwarg
+          "#{name}: #{return_type.to_rbs}"
+        when :kwoptarg
+          "#?{name}: #{return_type.to_rbs}"
+        when :restarg
+          "*#{super}"
+        when :kwrestarg
+          "**#{super}"
+        else
+          super
+        end
+      end
+
       def full
         case decl
         when :optarg

lib/solargraph/pin/signature.rb

@@ -21,11 +21,25 @@ def initialize generics, parameters, return_type, block = nil
         @block = block
       end
 
-      # @return [Array<String>]
       def generics
-        @generics ||= []
+        @generics ||= [].freeze
+      end
+
+      # @return [String]
+      def to_rbs
+        @rbs ||= rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ') + '-> ' + return_type.to_rbs
       end
 
+      # @return [String]
+      def rbs_generics
+        if generics.empty?
+          return ''
+        else
+          return '[' + generics.map { |gen| gen.to_s }.join(', ') + '] '
+        end
+      end
+
+      # @return [Array<String>]
       # @yieldparam [ComplexType]
       # @yieldreturn [ComplexType]
       # @return [self]

lib/solargraph/source/chain/link.rb

@@ -31,6 +31,10 @@ def resolve api_map, name_pin, locals
           []
         end
 
+        def inspect
+          "#{self.class} #{word}"
+        end
+
         def head?
           @head ||= false
         end