solargraph 0.59.1 → 0.60.0

data/lib/solargraph/rbs_map/conversions.rb

@@ -67,7 +67,6 @@ module Solargraph
           unless closure.name == '' || decl.name.absolute?
             Solargraph.assert_or_log(:rbs_closure, "Ignoring closure #{closure.inspect} on interface #{decl.inspect}")
           end
-          # STDERR.puts "Skipping interface #{decl.name.relative!}"
           interface_decl_to_pin decl
         when RBS::AST::Declarations::TypeAlias
           # @sg-ignore flow sensitive typing should support case/when
@@ -80,7 +79,7 @@ module Solargraph
             # @sg-ignore Wrong argument type for Solargraph::Pin::Reference::TypeAlias.new: return_type expected Solargraph::ComplexType, received Solargraph::ComplexType::UniqueType, Solargraph::ComplexType
             Solargraph::Pin::Reference::TypeAlias.new(
               # @sg-ignore Unresolved calls to name, type, type_location; return_type type mismatch
-              name: ComplexType.try_parse(decl.name.to_s).to_s, return_type: other_type_to_type(decl.type).force_rooted, closure: closure, source: :rbs, type_location: location_decl_to_pin_location(decl.location)
+              name: ComplexType.try_parse(decl.name.to_s).to_s, return_type: RbsTranslator.to_complex_type(decl.type).force_rooted, closure: closure, source: :rbs, type_location: location_decl_to_pin_location(decl.location)
             )
           )
         when RBS::AST::Declarations::Module
@@ -169,7 +168,8 @@ module Solargraph
         rbs_name = type_name.relative!.to_s
         base = RBS_TO_CLASS.fetch(rbs_name, rbs_name)
 
-        params = type_args.map { |a| other_type_to_type(a) }
+        params = type_args.map { |a| RbsTranslator.to_complex_type(a) }
+        # @todo Tuples are in flux
         # tuples have their own class and are handled in other_type_to_type
         if base == 'Hash' && params.length == 2
           ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: type_name.absolute?,
@@ -185,9 +185,9 @@ module Solargraph
       # @return [void]
       def convert_self_type_to_pins decl, closure
         type = build_type(decl.name, decl.args)
-        generic_values = type.all_params.map(&:rooted_tags)
+        generic_values = type.all_params.map(&:to_s)
         include_pin = Solargraph::Pin::Reference::Include.new(
-          name: type.name,
+          name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
           generic_values: generic_values,
           closure: closure,
@@ -274,7 +274,10 @@ module Solargraph
         # @type [Hash{String => ComplexType, ComplexType::UniqueType}]
         generic_defaults = {}
         decl.type_params.each do |param|
-          generic_defaults[param.name.to_s] = other_type_to_type param.default_type if param.default_type
+          if param.default_type
+            complex_type = RbsTranslator.to_complex_type(param.default_type).force_rooted
+            generic_defaults[param.name.to_s] = complex_type
+          end
         end
 
         class_name = fqns(decl.name)
@@ -297,7 +300,8 @@ module Solargraph
         pins.push class_pin
         if decl.super_class
           type = build_type(decl.super_class.name, decl.super_class.args)
-          generic_values = type.all_params.map(&:rooted_tags)
+          generic_values = type.all_params.map(&:to_s)
+          superclass_name = decl.super_class.name.to_s
           pins.push Solargraph::Pin::Reference::Superclass.new(
             type_location: location_decl_to_pin_location(decl.super_class.location),
             closure: class_pin,
@@ -316,7 +320,7 @@ module Solargraph
         class_pin = Solargraph::Pin::Namespace.new(
           type: :module,
           type_location: location_decl_to_pin_location(decl.location),
-          name: fqns(decl.name),
+          name: decl.name.relative!.to_s,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
           generics: type_parameter_names(decl),
@@ -335,7 +339,7 @@ module Solargraph
       def module_decl_to_pin decl
         module_pin = Solargraph::Pin::Namespace.new(
           type: :module,
-          name: fqns(decl.name),
+          name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
@@ -380,6 +384,9 @@ module Solargraph
         )
         rooted_tag = type.rooted_tags
         rooted_tag = "#{base}<#{rooted_tag}>" if base
+        # @todo alt version
+        # tag = "#{base}<#{tag}>" if base
+        # rooted_tag = ComplexType.parse(tag).force_rooted.rooted_tags
         constant_pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         constant_pin
       end
@@ -406,9 +413,8 @@ module Solargraph
       # @param decl [RBS::AST::Declarations::Constant]
       # @return [void]
       def constant_decl_to_pin decl
-        target_type = other_type_to_type(decl.type)
-        constant_name = fqns(decl.name)
-        pins.push create_constant(constant_name, target_type, decl.comment&.string, decl)
+        tag = RbsTranslator.to_complex_type(decl.type)
+        pins.push create_constant(decl.name.relative!.to_s, tag, decl.comment&.string, decl)
       end
 
       # @param decl [RBS::AST::Declarations::Global]
@@ -423,7 +429,7 @@ module Solargraph
           type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
-        rooted_tag = other_type_to_type(decl.type).rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -529,73 +535,69 @@ module Solargraph
             pin.instance_variable_set(:@return_type, ComplexType::VOID)
           end
         end
-        return unless decl.singleton?
-        final_scope = :class
-        name = decl.name.to_s
-        visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
-        pin = Solargraph::Pin::Method.new(
-          name: name,
-          closure: closure,
-          comments: decl.comment&.string,
-          type_location: location_decl_to_pin_location(decl.location),
-          visibility: visibility,
-          scope: final_scope,
-          signatures: [],
-          generics: generics,
-          source: :rbs
-        )
-        pin.signatures.concat method_def_to_sigs(decl, pin)
-        pins.push pin
+        if decl.singleton?
+          final_scope = :class
+          name = decl.name.to_s
+          visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
+          pin = Solargraph::Pin::Method.new(
+            name: name,
+            closure: closure,
+            comments: decl.comment&.string,
+            type_location: location_decl_to_pin_location(decl.location),
+            visibility: visibility,
+            scope: final_scope,
+            signatures: [],
+            generics: generics,
+            source: :rbs
+          )
+          pin.signatures.concat method_def_to_sigs(decl, pin)
+          pins.push pin
+        end
       end
 
       # @param decl [RBS::AST::Members::MethodDefinition]
       # @param pin [Pin::Method]
       # @return [void]
       def method_def_to_sigs decl, pin
-        # @param overload [RBS::AST::Members::MethodDefinition::Overload]
+        # rubocop:disable Style/SafeNavigationChainLength
+        implicit_nil = decl.overloads.first&.annotations&.map(&:string)&.include?('implicitly-returns-nil') || false
+        # rubocop:enable Style/SafeNavigationChainLength        # @param overload [RBS::AST::Members::MethodDefinition::Overload]
         decl.overloads.map do |overload|
-          # @sg-ignore Wrong argument type for Solargraph::RbsMap::Conversions#location_decl_to_pin_location:
-          #   location expected RBS::Location, nil, received RBS::Location<:type, :type_params>, RBS::AST::Members::Attribute::loc, nil
           type_location = location_decl_to_pin_location(overload.method_type.location)
-          generics = type_parameter_names(overload.method_type)
-          signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
-          rbs_block = overload.method_type.block
-          block = if rbs_block
-                    block_parameters, block_return_type = parts_of_function(rbs_block, pin)
-                    Pin::Signature.new(generics: generics, parameters: block_parameters,
-                                       return_type: block_return_type, source: :rbs,
+          generics = overload.method_type.type_params.map(&:name).map(&:to_s)
+          signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin, implicit_nil)
+          block = if overload.method_type.block
+                    block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin, implicit_nil)
+                    Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs,
                                        type_location: type_location, closure: pin)
                   end
-          Pin::Signature.new(generics: generics, parameters: signature_parameters,
-                             return_type: signature_return_type, block: block, source: :rbs,
+          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block, source: :rbs,
                              type_location: type_location, closure: pin)
         end
       end
 
       # @param location [RBS::Location, nil]
       # @return [Solargraph::Location, nil]
-      def location_decl_to_pin_location location
+      def location_decl_to_pin_location(location)
         return nil if location&.name.nil?
 
-        # @sg-ignore flow sensitive typing should handle return nil if location&.name.nil?
         start_pos = Position.new(location.start_line - 1, location.start_column)
-        # @sg-ignore flow sensitive typing should handle return nil if location&.name.nil?
         end_pos = Position.new(location.end_line - 1, location.end_column)
         range = Range.new(start_pos, end_pos)
-        # @sg-ignore flow sensitve typing should handle return nil if location&.name.nil?
         Location.new(location.name.to_s, range)
       end
 
       # @param type [RBS::MethodType, RBS::Types::Block]
       # @param pin [Pin::Method]
+      # @param implicit_nil [Boolean]
       # @return [Array(Array<Pin::Parameter>, ComplexType)]
-      def parts_of_function type, pin
+      def parts_of_function type, pin, implicit_nil
         type_location = pin.type_location
         if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
           return [
             [Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs,
                                             type_location: type_location)],
-            method_type_to_type(type)
+            method_type_to_type(type, implicit_nil)
           ]
         end
 
@@ -659,10 +661,21 @@ module Solargraph
                                                          source: :rbs, type_location: type_location)
         end
 
-        return_type = method_type_to_type(type)
+        return_type = method_type_to_type(type, implicit_nil)
         [parameters, return_type]
       end
 
+      # @param type [RBS::MethodType,RBS::Types::Block]
+      # @param pin [Pin::Method]
+      # @param implicit_nil [Boolean]
+      # @return [Array(Array<Pin::Parameter>, ComplexType)]
+      def parts_of_function type, pin, implicit_nil
+        [
+          RbsTranslator.to_parameter_pins(type, pin, pin.parameter_names),
+          extract_method_type_return_type(type, implicit_nil).force_rooted
+        ]
+      end
+
       # @param decl [RBS::AST::Members::AttrReader,RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
       # @param context [Context]
@@ -681,7 +694,7 @@ module Solargraph
           visibility: visibility,
           source: :rbs
         )
-        rooted_tag = other_type_to_type(decl.type).rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         logger.debug do
           "Conversions#attr_reader_to_pin(name=#{name.inspect}, visibility=#{visibility.inspect}) => #{pin.inspect}"
@@ -712,13 +725,13 @@ module Solargraph
         pin.parameters <<
           Solargraph::Pin::Parameter.new(
             name: 'value',
-            return_type: other_type_to_type(decl.type),
+            return_type: RbsTranslator.to_complex_type(decl.type).force_rooted,
             source: :rbs,
             closure: pin,
             type_location: type_location
           )
-        rooted_tags = other_type_to_type(decl.type).rooted_tags
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tags))
+        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         pins.push pin
       end
 
@@ -742,7 +755,7 @@ module Solargraph
           comments: decl.comment&.string,
           source: :rbs
         )
-        rooted_tag = other_type_to_type(decl.type).rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -759,7 +772,7 @@ module Solargraph
           type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
-        rooted_tag = other_type_to_type(decl.type).rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -776,7 +789,7 @@ module Solargraph
           type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
-        rooted_tag = other_type_to_type(decl.type).rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -786,9 +799,9 @@ module Solargraph
       # @return [void]
       def include_to_pin decl, closure
         type = build_type(decl.name, decl.args)
-        generic_values = type.all_params.map(&:rooted_tags)
+        generic_values = type.all_params.map(&:to_s)
         pins.push Solargraph::Pin::Reference::Include.new(
-          name: type.rooted_name, # reference pins use rooted names
+          name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
           generic_values: generic_values,
           closure: closure,
@@ -803,9 +816,8 @@ module Solargraph
         type = build_type(decl.name, decl.args)
         generic_values = type.all_params.map(&:rooted_tags)
         pins.push Solargraph::Pin::Reference::Prepend.new(
-          name: type.rooted_name, # reference pins use rooted names
+          name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
-          generic_values: generic_values,
           closure: closure,
           source: :rbs
         )
@@ -818,9 +830,8 @@ module Solargraph
         type = build_type(decl.name, decl.args)
         generic_values = type.all_params.map(&:rooted_tags)
         pins.push Solargraph::Pin::Reference::Extend.new(
-          name: type.rooted_name, # reference pins use rooted names
+          name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
-          generic_values: generic_values,
           closure: closure,
           source: :rbs
         )
@@ -841,90 +852,37 @@ module Solargraph
         )
       end
 
-      # @param type [RBS::MethodType, RBS::Types::Block]
-      # @return [ComplexType, ComplexType::UniqueType]
-      def method_type_to_type type
-        other_type_to_type type.type.return_type
-      end
+      RBS_TO_YARD_TYPE = {
+        'bool' => 'Boolean',
+        'string' => 'String',
+        'int' => 'Integer',
+        'untyped' => '',
+        'NilClass' => 'nil'
+      }
+      private_constant :RBS_TO_YARD_TYPE
 
-      # @param type [RBS::Types::Bases::Base,Object] RBS type object.
-      #   Note: Generally these extend from RBS::Types::Bases::Base,
-      #   but not all.
+      # Extract a ComplexType from a MethodType's return type.
       #
-      # @return [ComplexType, ComplexType::UniqueType]
-      def other_type_to_type type
-        case type
-        when RBS::Types::Optional
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          ComplexType.new([other_type_to_type(type.type),
-                           ComplexType::UniqueType::NIL])
-        when RBS::Types::Bases::Any
-          ComplexType::UNDEFINED
-        when RBS::Types::Bases::Bool
-          ComplexType::BOOLEAN
-        when RBS::Types::Tuple
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          tuple_types = type.types.map { |t| other_type_to_type(t) }
-          ComplexType::UniqueType.new('Array', [], tuple_types, rooted: true, parameters_type: :fixed)
-        when RBS::Types::Literal
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          ComplexType.try_parse(type.literal.inspect).force_rooted
-        when RBS::Types::Union
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          ComplexType.new(type.types.map { |t| other_type_to_type(t) })
-        when RBS::Types::Record
-          # @todo Better record support
-          ComplexType::UniqueType.new('Hash', rooted: true)
-        when RBS::Types::Bases::Nil
-          ComplexType::NIL
-        when RBS::Types::Bases::Self
-          ComplexType::SELF
-        when RBS::Types::Bases::Void
-          ComplexType::VOID
-        when RBS::Types::Variable
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          ComplexType.parse("generic<#{type.name}>").force_rooted
-        when RBS::Types::ClassInstance # && !type.args.empty?
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          build_type(type.name, type.args)
-        when RBS::Types::Bases::Instance
-          ComplexType::SELF
-        when RBS::Types::Bases::Top
-          # top is the most super superclass
-          ComplexType::UniqueType.new('BasicObject', rooted: true)
-        when RBS::Types::Bases::Bottom
-          # bottom is used in contexts where nothing will ever return
-          # - e.g., it could be the return type of 'exit()' or 'raise'
-          #
-          # @todo define a specific bottom type and use it to
-          #   determine dead code
-          ComplexType::UNDEFINED
-        when RBS::Types::Intersection
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          ComplexType.new(type.types.map { |member| other_type_to_type(member) })
-        when RBS::Types::Proc
-          ComplexType::UniqueType.new('Proc', rooted: true)
-        when RBS::Types::Alias
-          # type-level alias use - e.g., 'bool' in "type bool = true | false"
-          # @todo ensure these get resolved after processing all aliases
-          # @todo handle recursive aliases
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          build_type(type.name, type.args)
-        when RBS::Types::Interface
-          # represents a mix-in module which can be considered a
-          # subtype of a consumer of it
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          build_type(type.name, type.args)
-        when RBS::Types::ClassSingleton
-          # e.g., singleton(String)
-          # @sg-ignore flow based typing needs to understand case when class pattern
-          build_type(type.name)
+      # This method will convert type aliases to concrete types.
+      #
+      # @param type [RBS::MethodType]
+      # @return [ComplexType]
+      def extract_method_type_return_type type, implicit_nil
+          tag = RbsTranslator.to_complex_type(type.type.return_type)
+          return ComplexType.parse("#{tag}, nil") if tag && implicit_nil
+          tag
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @return [ComplexType::UniqueType]
+      def build_type(type_name, type_args = [])
+        base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
+        params = type_args.map { |arg| RbsTranslator.to_complex_type(arg).force_rooted }
+        if base == 'Hash' && params.length == 2
+          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
         else
-          # RBS doesn't provide a common base class for its type AST nodes
-          #
-          # @sg-ignore all types should include location
-          Solargraph.logger.warn "Unrecognized RBS type: #{type.class} at #{type.location}"
-          ComplexType::UNDEFINED
+          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
         end
       end
 
@@ -937,9 +895,9 @@ module Solargraph
           # @todo are we handling prepend correctly?
           klass = mixin.is_a?(RBS::AST::Members::Include) ? Pin::Reference::Include : Pin::Reference::Extend
           type = build_type(mixin.name, mixin.args)
-          generic_values = type.all_params.map(&:rooted_tags)
+          generic_values = type.all_params.map(&:to_s)
           pins.push klass.new(
-            name: type.rooted_name, # reference pins use rooted names
+            name: mixin.name.relative!.to_s,
             type_location: location_decl_to_pin_location(mixin.location),
             generic_values: generic_values,
             closure: namespace,

data/lib/solargraph/rbs_translator.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # Convert RBS types to complex types and pins.
+  #
+  module RbsTranslator
+    RBS_TO_YARD_TYPE = {
+      'bool' => 'Boolean',
+      'string' => 'String',
+      'int' => 'Integer',
+      'untyped' => '',
+      'NilClass' => 'nil'
+    }
+
+    # @param type [RBS::Types::Bases::Base]
+    # @return [ComplexType]
+    def self.to_complex_type(type)
+      tag = type_to_tag(type)
+      ComplexType.try_parse(tag).force_rooted
+    end
+
+    # @param param_type [RBS::Types::Function::Param]
+    # @param name [String]
+    # @param decl [Symbol]
+    # @param closure [Pin::Closure]
+    # @return [Pin::Parameter]
+    def self.to_parameter_pin(param_type, name, decl, closure)
+      return_type = if decl == :restarg
+        ComplexType.parse('Array')
+      elsif decl == :kwrestarg
+        ComplexType.parse('Hash{Symbol => Object}')
+      else
+        RbsTranslator.to_complex_type(param_type.type)
+      end
+      Solargraph::Pin::Parameter.new(decl: decl, name: name, closure: closure, return_type: return_type, source: :rbs, type_location: to_sg_location(param_type.location) || closure.type_location)
+    end
+
+    # @param method_type [RBS::MethodType]
+    # @param closure [Pin::Closure]
+    # @param parameter_names [Array<String>]
+    # @return [Array<Pin::Parameter>]
+    def self.to_parameter_pins method_type, closure, parameter_names = []
+      if defined?(RBS::Types::UntypedFunction) && method_type.type.is_a?(RBS::Types::UntypedFunction)
+        return [
+          Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: closure, source: :rbs)
+        ]
+      end
+
+      arg_num = 0
+      params = []
+      method_type.type.required_positionals.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :arg, closure)
+        arg_num += 1
+      end
+      method_type.type.optional_positionals.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :optarg, closure)
+        arg_num += 1
+      end
+      if method_type.type.rest_positionals
+        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_positionals, method_type.type.rest_positionals.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :restarg, closure)
+        arg_num += 1
+      end
+      method_type.type.required_keywords.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwarg, closure)
+        arg_num += 1
+      end
+      method_type.type.optional_keywords.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwoptarg, closure)
+        arg_num += 1
+      end
+      if method_type.type.rest_keywords
+        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_keywords, method_type.type.rest_keywords.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :kwrestarg, closure)
+      end
+      params
+    end
+
+    # @param method_type [RBS::MethodType]
+    # @param closure [Pin::Closure]
+    # @param parameter_names [Array<String>]
+    # @return [Pin::Signature]
+    def self.to_signature method_type, closure, parameter_names = []
+      # There may be edge cases here around different signatures
+      # having different type params / orders - we may need to match
+      # this data model and have generics live in signatures to
+      # handle those correctly
+      generics = method_type.type_params.map(&:name).map(&:to_s).uniq
+      parameters = to_parameter_pins(method_type, closure, parameter_names)
+      return_type = to_complex_type(method_type.type.return_type)
+      block = if method_type.block
+        block_parameters = to_parameter_pins(method_type.block, closure)
+        block_return_type = to_complex_type(method_type.block.type.return_type)
+        Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs, type_location: closure.location, closure: closure)
+      end
+      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, source: :rbs, type_location: closure.location, closure: closure)
+    end
+
+    # @param type_name [RBS::TypeName]
+    # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+    # @return [ComplexType::UniqueType]
+    def self.build_unique_type(type_name, type_args = [])
+      base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
+      params = type_args.map do |a|
+        RbsTranslator.to_complex_type(a)
+      end
+      if base == 'Hash' && params.length == 2
+        ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
+      else
+        ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
+      end
+    end
+
+    # @param location [RBS::Location, nil]
+    # @return [Solargraph::Location, nil]
+    def self.to_sg_location(location)
+      return nil if location&.name.nil?
+
+      start_pos = Position.new(location.start_line - 1, location.start_column)
+      end_pos = Position.new(location.end_line - 1, location.end_column)
+      range = Range.new(start_pos, end_pos)
+      Location.new(location.name.to_s, range)
+    end
+
+    class << self
+      private
+
+      # @param type [RBS::Types::Bases::Base]
+      # @return [String]
+      def type_to_tag type
+        case type
+        when RBS::Types::Optional
+          "#{type_to_tag(type.type)}, nil"
+        when RBS::Types::Bases::Bool
+          'Boolean'
+        when RBS::Types::Tuple
+          "Array(#{type.types.map { |t| type_to_tag(t) }.join(', ')})"
+        when RBS::Types::Literal
+          type.literal.inspect
+        when RBS::Types::Union
+          type.types.map { |t| type_to_tag(t) }.join(', ')
+        when RBS::Types::Record
+          # @todo Better record support
+          'Hash'
+        when RBS::Types::Bases::Nil
+          'nil'
+        when RBS::Types::Bases::Void
+          'void'
+        when RBS::Types::Variable
+          "#{Solargraph::ComplexType::GENERIC_TAG_NAME}<#{type.name}>"
+        when RBS::Types::Bases::Self, RBS::Types::Bases::Instance
+          'self'
+        when RBS::Types::Bases::Top
+          # `Top` is the most super superclass
+          'BasicObject'
+        when RBS::Types::Intersection
+          type.types.map { |member| type_to_tag(member) }.join(', ')
+        when RBS::Types::Proc
+          'Proc'
+        when RBS::Types::ClassInstance, RBS::Types::Alias, RBS::Types::Interface
+          # `Alias` is a top-level type alias, e.g., 'bool' in "type bool = true | false"
+          # @todo ensure these get resolved after processing all aliases
+          # @todo handle recursive aliases
+          #
+          # `Interface represents a mix-in module which can be considered a
+          # subtype of a consumer of it
+          #
+          type_tag(type.name, type.args)
+        when RBS::Types::ClassSingleton
+          # e.g., singleton(String)
+          type_tag(type.name)
+        when RBS::Types::Bases::Any, RBS::Types::Bases::Bottom
+          # `Bottom`` is used in contexts where nothing will ever return
+          # - e.g., it could be the return type of 'exit()' or 'raise'
+          # @todo define a specific bottom type and use it to
+          #   determine dead code
+          #
+          'undefined'
+        else
+          Solargraph.logger.warn "Unrecognized RBS type: #{type.class} at #{type.location}"
+          'undefined'
+        end
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @return [String]
+      def type_tag(type_name, type_args = [])
+        build_type(type_name, type_args).tags
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @return [ComplexType::UniqueType]
+      def build_type(type_name, type_args = [])
+        base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
+        params = type_args.map { |a| type_to_tag(a) }.map do |t|
+          ComplexType.try_parse(t)
+        end
+        if base == 'Hash' && params.length == 2
+          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
+        else
+          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
+        end
+      end
+    end
+  end
+end