solargraph 0.52.0 → 0.53.4

data/lib/solargraph/pin/signature.rb

@@ -1,7 +1,7 @@
 module Solargraph
   module Pin
     class Signature < Base
-      # @return [Array<Parameter>]
+      # @return [::Array<Parameter>]
       attr_reader :parameters
 
       # @return [ComplexType]
@@ -10,15 +10,121 @@ module Solargraph
       # @return [self]
       attr_reader :block
 
+      # @param generics [Array<String>]
       # @param parameters [Array<Parameter>]
       # @param return_type [ComplexType]
       # @param block [Signature, nil]
-      def initialize parameters, return_type, block = nil
+      def initialize generics, parameters, return_type, block = nil
+        @generics = generics
         @parameters = parameters
         @return_type = return_type
         @block = block
       end
 
+      def generics
+        @generics ||= [].freeze
+      end
+
+      # @return [String]
+      def to_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]
+      def transform_types(&transform)
+        # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
+        signature = super(&transform)
+        signature.parameters = signature.parameters.map do |param|
+          param.transform_types(&transform)
+        end
+        signature.block = block.transform_types(&transform) if signature.block?
+        signature
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param arg_types [Array<ComplexType>, nil]
+      # @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,
+                                        arg_types = nil,
+                                        return_type_context = nil,
+                                        yield_arg_types = nil,
+                                        yield_return_type_context = nil,
+                                        resolved_generic_values: {})
+        signature = super(generics_to_resolve, return_type_context, resolved_generic_values: resolved_generic_values)
+        signature.parameters = signature.parameters.each_with_index.map do |param, i|
+          if arg_types.nil?
+            param.dup
+          else
+            param.resolve_generics_from_context(generics_to_resolve,
+                                                arg_types[i],
+                                                resolved_generic_values: resolved_generic_values)
+          end
+        end
+        signature.block = block.resolve_generics_from_context(generics_to_resolve,
+                                                              yield_arg_types,
+                                                              yield_return_type_context,
+                                                              resolved_generic_values: resolved_generic_values) if signature.block?
+        signature
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param arg_types [Array<ComplexType>, nil]
+      # @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,
+                                                       arg_types = nil,
+                                                       return_type_context = nil,
+                                                       yield_arg_types = nil,
+                                                       yield_return_type_context = nil,
+                                                       resolved_generic_values: {})
+        # See
+        # https://github.com/soutaro/steep/tree/master/lib/steep/type_inference
+        # and
+        # https://github.com/sorbet/sorbet/blob/master/infer/inference.cc
+        # for other implementations
+
+        return self if generics_to_resolve.empty?
+
+        last_resolved_generic_values = resolved_generic_values.dup
+        new_pin = resolve_generics_from_context(generics_to_resolve,
+                                                arg_types,
+                                                return_type_context,
+                                                yield_arg_types,
+                                                yield_return_type_context,
+                                                resolved_generic_values: resolved_generic_values)
+        if last_resolved_generic_values == resolved_generic_values
+          # erase anything unresolved
+          return new_pin.erase_generics(self.generics)
+        end
+        new_pin.resolve_generics_from_context_until_complete(generics_to_resolve,
+                                                             arg_types,
+                                                             return_type_context,
+                                                             yield_arg_types,
+                                                             yield_return_type_context,
+                                                             resolved_generic_values: resolved_generic_values)
+      end
+
       def identity
         @identity ||= "signature#{object_id}"
       end
@@ -26,6 +132,12 @@ module Solargraph
       def block?
         !!@block
       end
+
+      protected
+
+      attr_writer :block
+
+      attr_writer :parameters
     end
   end
 end

data/lib/solargraph/pin.rb

@@ -27,7 +27,6 @@ module Solargraph
     autoload :Reference,        'solargraph/pin/reference'
     autoload :Documenting,      'solargraph/pin/documenting'
     autoload :Block,            'solargraph/pin/block'
-    autoload :Localized,        'solargraph/pin/localized'
     autoload :ProxyType,        'solargraph/pin/proxy_type'
     autoload :DuckMethod,       'solargraph/pin/duck_method'
     autoload :Singleton,        'solargraph/pin/singleton'

data/lib/solargraph/range.rb

@@ -62,8 +62,8 @@ module Solargraph
 
     # Get a range from a node.
     #
-    # @param node [RubyVM::AbstractSyntaxTree::Node, Parser::AST::Node]
-    # @return [Range]
+    # @param node [Parser::AST::Node]
+    # @return [Range, nil]
     def self.from_node node
       if Parser.rubyvm? && node.is_a?(RubyVM::AbstractSyntaxTree::Node)
         Solargraph::Range.from_to(node.first_lineno - 1, node.first_column, node.last_lineno - 1, node.last_column)

data/lib/solargraph/rbs_map/conversions.rb

@@ -27,7 +27,7 @@ module Solargraph
 
       private
 
-      # @return Hash{String => RBS::AST::Declarations::TypeAlias}
+      # @return [Hash{String => RBS::AST::Declarations::TypeAlias}]
       def type_aliases
         @type_aliases ||= {}
       end
@@ -39,24 +39,7 @@ module Solargraph
         cursor = pins.length
         environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
         added_pins = pins[cursor..-1]
-        add_back_implicit_pins(added_pins)
-      end
-
-      # @param added_pins [Range<Pin>]
-      # @return [void]
-      def add_back_implicit_pins(added_pins)
-        added_pins.each do |pin|
-          pin.source = :rbs
-          next unless pin.is_a?(Pin::Namespace) && pin.type == :class
-          next if pins.any? { |p| p.path == "#{pin.path}.new"}
-          pins.push Solargraph::Pin::Method.new(
-                      location: nil,
-                      closure: pin,
-                      name: 'new',
-                      comments: pin.comments,
-                      scope: :class
-          )
-        end
+        added_pins.each { |pin| pin.source = :rbs }
       end
 
       # @param decl [RBS::AST::Declarations::Base]
@@ -68,7 +51,7 @@ module Solargraph
           class_decl_to_pin decl
         when RBS::AST::Declarations::Interface
           # STDERR.puts "Skipping interface #{decl.name.relative!}"
-          interface_decl_to_pin decl
+          interface_decl_to_pin decl, closure
         when RBS::AST::Declarations::TypeAlias
           type_aliases[decl.name.to_s] = decl
         when RBS::AST::Declarations::Module
@@ -77,16 +60,46 @@ module Solargraph
           constant_decl_to_pin decl
         when RBS::AST::Declarations::ClassAlias
           class_alias_decl_to_pin decl
+        when RBS::AST::Declarations::ModuleAlias
+          module_alias_decl_to_pin decl
+        when RBS::AST::Declarations::Global
+          global_decl_to_pin decl
         else
-          Solargraph.logger.info "Skipping declaration #{decl.class}"
+          Solargraph.logger.warn "Skipping declaration #{decl.class}"
         end
       end
 
-      def convert_members_to_pin decl, closure
+      # @param decl [RBS::AST::Declarations::Module]
+      # @param module_pin [Pin::Namespace]
+      # @return [void]
+      def convert_self_types_to_pins decl, module_pin
+        decl.self_types.each { |self_type| context = convert_self_type_to_pins(self_type, module_pin) }
+      end
+
+      # @param decl [RBS::AST::Declarations::Module::Self]
+      # @param closure [Pin::Namespace]
+      # @return [void]
+      def convert_self_type_to_pins decl, closure
+        include_pin = Solargraph::Pin::Reference::Include.new(
+          name: decl.name.relative!.to_s,
+          location: rbs_location_to_location(decl.location),
+          closure: closure
+        )
+        pins.push include_pin
+      end
+
+      # @param decl [RBS::AST::Declarations::Module,RBS::AST::Declarations::Class,RBS::AST::Declarations::Interface]
+      # @param closure [Pin::Namespace]
+      # @return [void]
+      def convert_members_to_pins decl, closure
         context = Context.new
         decl.members.each { |m| context = convert_member_to_pin(m, closure, context) }
       end
 
+      # @param member [RBS::AST::Members::Base,RBS::AST::Declarations::Base]
+      # @param closure [Pin::Namespace]
+      # @param context [Context]
+      # @return [void]
       def convert_member_to_pin member, closure, context
         case member
         when RBS::AST::Members::MethodDefinition
@@ -105,6 +118,10 @@ module Solargraph
           extend_to_pin(member, closure)
         when RBS::AST::Members::Alias
           alias_to_pin(member, closure)
+        when RBS::AST::Members::ClassInstanceVariable
+          civar_to_pin(member, closure)
+        when RBS::AST::Members::ClassVariable
+          cvar_to_pin(member, closure)
         when RBS::AST::Members::InstanceVariable
           ivar_to_pin(member, closure)
         when RBS::AST::Members::Public
@@ -114,7 +131,7 @@ module Solargraph
         when RBS::AST::Declarations::Base
           convert_decl_to_pin(member, closure)
         else
-          Solargraph.logger.warn "Skipping member #{member.class}"
+          Solargraph.logger.warn "Skipping member type #{member.class}"
         end
         context
       end
@@ -127,6 +144,9 @@ module Solargraph
           name: decl.name.relative!.to_s,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
+          # @todo some type parameters in core/stdlib have default
+          #   values; Solargraph doesn't support that yet as so these
+          #   get treated as undefined if not specified
           generics: decl.type_params.map(&:name).map(&:to_s)
         )
         pins.push class_pin
@@ -136,24 +156,27 @@ module Solargraph
             name: decl.super_class.name.relative!.to_s
           )
         end
-        convert_members_to_pin decl, class_pin
+        add_mixins decl, class_pin
+        convert_members_to_pins decl, class_pin
       end
 
       # @param decl [RBS::AST::Declarations::Interface]
+      # @param closure [Pin::Closure]
       # @return [void]
-      def interface_decl_to_pin decl
+      def interface_decl_to_pin decl, closure
         class_pin = Solargraph::Pin::Namespace.new(
           type: :module,
           name: decl.name.relative!.to_s,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
+          generics: decl.type_params.map(&:name).map(&:to_s),
           # HACK: Using :hidden to keep interfaces from appearing in
           # autocompletion
           visibility: :hidden
         )
         class_pin.docstring.add_tag(YARD::Tags::Tag.new(:abstract, '(RBS interface)'))
         pins.push class_pin
-        convert_members_to_pin decl, class_pin
+        convert_members_to_pins decl, class_pin
       end
 
       # @param decl [RBS::AST::Declarations::Module]
@@ -167,15 +190,19 @@ module Solargraph
           generics: decl.type_params.map(&:name).map(&:to_s),
         )
         pins.push module_pin
-        convert_members_to_pin decl, module_pin
+        convert_self_types_to_pins decl, module_pin
+        convert_members_to_pins decl, module_pin
+
+        add_mixins decl, module_pin.closure
       end
 
       # @param name [String]
       # @param tag [String]
       # @param comments [String]
+      # @param base [String, nil] Optional conversion of tag to base<tag>
       #
       # @return [Solargraph::Pin::Constant]
-      def create_constant(name, tag, comments)
+      def create_constant(name, tag, comments, base = nil)
         parts = name.split('::')
         if parts.length > 1
           name = parts.last
@@ -189,8 +216,8 @@ module Solargraph
           closure: closure,
           comments: comments
         )
-        # @todo Class or Module?
-        constant_pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', "Class<#{tag}>"))
+        tag = "#{base}<#{tag}>" if base
+        constant_pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', tag))
         constant_pin
       end
 
@@ -201,7 +228,17 @@ module Solargraph
         new_name = decl.new_name.relative!.to_s
         old_name = decl.old_name.relative!.to_s
 
-        pins.push create_constant(new_name, old_name, decl.comment&.string)
+        pins.push create_constant(new_name, old_name, decl.comment&.string, 'Class')
+      end
+
+      # @param decl [RBS::AST::Declarations::ModuleAlias]
+      # @return [void]
+      def module_alias_decl_to_pin decl
+        # See https://www.rubydoc.info/gems/rbs/3.4.3/RBS/AST/Declarations/ModuleAlias
+        new_name = decl.new_name.relative!.to_s
+        old_name = decl.old_name.relative!.to_s
+
+        pins.push create_constant(new_name, old_name, decl.comment&.string, 'Module')
       end
 
       # @param decl [RBS::AST::Declarations::Constant]
@@ -211,40 +248,46 @@ module Solargraph
         pins.push create_constant(decl.name.relative!.to_s, tag, decl.comment&.string)
       end
 
+      # @param decl [RBS::AST::Declarations::Global]
+      # @return [void]
+      def global_decl_to_pin decl
+        closure = Solargraph::Pin::ROOT_PIN
+        name = decl.name.to_s
+        tag = other_type_to_tag(decl.type)
+        pin = Solargraph::Pin::GlobalVariable.new(
+          name: name,
+          closure: closure,
+          comments: decl.comment&.string,
+        )
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', tag))
+        pins.push pin
+      end
+
       # @param decl [RBS::AST::Members::MethodDefinition]
       # @param closure [Pin::Closure]
       # @return [void]
       def method_def_to_pin decl, closure
+        # 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 = decl.overloads.map(&:method_type).flat_map(&:type_params).map(&:name).map(&:to_s).uniq
         if decl.instance?
           pin = Solargraph::Pin::Method.new(
             name: decl.name.to_s,
             closure: closure,
             comments: decl.comment&.string,
             scope: :instance,
-            signatures: []
+            signatures: [],
+            generics: generics,
+            # @todo RBS core has unreliable visibility definitions
+            visibility: closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(decl.name) ? :private : :public
           )
           pin.signatures.concat method_def_to_sigs(decl, pin)
           pins.push pin
           if pin.name == 'initialize'
-            pins.push Solargraph::Pin::Method.new(
-              location: pin.location,
-              closure: pin.closure,
-              name: 'new',
-              comments: pin.comments,
-              scope: :class,
-              signatures: pin.signatures
-            )
-            pins.last.signatures.replace(
-              pin.signatures.map do |p|
-                Pin::Signature.new(
-                  p.parameters,
-                  ComplexType::SELF
-                )
-              end
-            )
-            # @todo Is this necessary?
-            # pin.instance_variable_set(:@visibility, :private)
-            # pin.instance_variable_set(:@return_type, ComplexType::VOID)
+            pin.instance_variable_set(:@visibility, :private)
+            pin.instance_variable_set(:@return_type, ComplexType::VOID)
           end
         end
         if decl.singleton?
@@ -253,7 +296,8 @@ module Solargraph
             closure: closure,
             comments: decl.comment&.string,
             scope: :class,
-            signatures: []
+            signatures: [],
+            generics: generics
           )
           pin.signatures.concat method_def_to_sigs(decl, pin)
           pins.push pin
@@ -262,17 +306,33 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::MethodDefinition]
       # @param pin [Pin::Method]
+      # @return [void]
       def method_def_to_sigs decl, pin
         decl.overloads.map do |overload|
+          generics = overload.method_type.type_params.map(&:to_s)
           parameters, return_type = parts_of_function(overload.method_type, pin)
           block = if overload.method_type.block
-                    Pin::Signature.new(*parts_of_function(overload.method_type.block, pin))
+                    Pin::Signature.new(generics, *parts_of_function(overload.method_type.block, pin))
           end
           return_type = ComplexType.try_parse(method_type_to_tag(overload.method_type))
-          Pin::Signature.new(parameters, return_type, block)
+          Pin::Signature.new(generics, parameters, return_type, block)
         end
       end
 
+      # @param location [RBS::Location, nil]
+      # @return [Solargraph::Location, nil]
+      def rbs_location_to_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, range)
+      end
+
+      # @param type [RBS::MethodType,RBS::Types::Block]
+      # @param pin [Pin::Method]
+      # @return [Array<Array<Pin::Parameter>, ComplexType>]
       def parts_of_function type, pin
         return [[Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin)], ComplexType.try_parse(method_type_to_tag(type))] if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
 
@@ -313,6 +373,9 @@ module Solargraph
         [parameters, return_type]
       end
 
+      # @param decl [RBS::AST::Members::AttrReader,RBS::AST::Members::AttrAccessor]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def attr_reader_to_pin(decl, closure)
         pin = Solargraph::Pin::Method.new(
           name: decl.name.to_s,
@@ -325,6 +388,9 @@ module Solargraph
         pins.push pin
       end
 
+      # @param decl [RBS::AST::Members::AttrWriter, RBS::AST::Members::AttrAccessor]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def attr_writer_to_pin(decl, closure)
         pin = Solargraph::Pin::Method.new(
           name: "#{decl.name.to_s}=",
@@ -337,11 +403,17 @@ module Solargraph
         pins.push pin
       end
 
+      # @param decl [RBS::AST::Members::AttrAccessor]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def attr_accessor_to_pin(decl, closure)
         attr_reader_to_pin(decl, closure)
         attr_writer_to_pin(decl, closure)
       end
 
+      # @param decl [RBS::AST::Members::InstanceVariable]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def ivar_to_pin(decl, closure)
         pin = Solargraph::Pin::InstanceVariable.new(
           name: decl.name.to_s,
@@ -352,13 +424,50 @@ module Solargraph
         pins.push pin
       end
 
+      # @param decl [RBS::AST::Members::ClassVariable]
+      # @param closure [Pin::Namespace]
+      # @return [void]
+      def cvar_to_pin(decl, closure)
+        name = decl.name.to_s
+        pin = Solargraph::Pin::ClassVariable.new(
+          name: name,
+          closure: closure,
+          comments: decl.comment&.string
+        )
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', other_type_to_tag(decl.type)))
+        pins.push pin
+      end
+
+      # @param decl [RBS::AST::Members::ClassInstanceVariable]
+      # @param closure [Pin::Namespace]
+      # @return [void]
+      def civar_to_pin(decl, closure)
+        name = decl.name.to_s
+        pin = Solargraph::Pin::InstanceVariable.new(
+          name: name,
+          closure: closure,
+          comments: decl.comment&.string
+        )
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', other_type_to_tag(decl.type)))
+        pins.push pin
+      end
+
+      # @param decl [RBS::AST::Members::Include]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def include_to_pin decl, closure
+        type = generic_type(decl.name, decl.args)
+        generic_values = type.all_params.map(&:to_s)
         pins.push Solargraph::Pin::Reference::Include.new(
           name: decl.name.relative!.to_s,
+          generic_values: generic_values,
           closure: closure
         )
       end
 
+      # @param decl [RBS::AST::Members::Prepend]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def prepend_to_pin decl, closure
         pins.push Solargraph::Pin::Reference::Prepend.new(
           name: decl.name.relative!.to_s,
@@ -366,6 +475,9 @@ module Solargraph
         )
       end
 
+      # @param decl [RBS::AST::Members::Extend]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def extend_to_pin decl, closure
         pins.push Solargraph::Pin::Reference::Extend.new(
           name: decl.name.relative!.to_s,
@@ -374,6 +486,8 @@ module Solargraph
       end
 
       # @param decl [RBS::AST::Members::Alias]
+      # @param closure [Pin::Namespace]
+      # @return [void]
       def alias_to_pin decl, closure
         pins.push Solargraph::Pin::MethodAlias.new(
           name: decl.new_name.to_s,
@@ -390,7 +504,7 @@ module Solargraph
         'NilClass' => 'nil'
       }
 
-      # @param type [RBS::AST::Members::MethodDefinition::Overload]
+      # @param type [RBS::MethodType]
       # @return [String]
       def method_type_to_tag type
         if type_aliases.key?(type.type.return_type.to_s)
@@ -400,6 +514,25 @@ module Solargraph
         end
       end
 
+      # @param type_name [RBS::TypeName]
+      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @return [ComplexType]
+      def generic_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| other_type_to_tag(a) }.reject { |t| t == 'undefined' }
+        params_str = params.empty? ? '' : "<#{params.join(', ')}>"
+        type_string = "#{base}#{params_str}"
+        ComplexType.parse(type_string)
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @return [String]
+      def generic_type_tag(type_name, type_args)
+        generic_type(type_name, type_args).tag
+      end
+
+      # @param type [RBS::Types::Bases::Base]
       # @return [String]
       def other_type_to_tag type
         if type.is_a?(RBS::Types::Optional)
@@ -427,14 +560,19 @@ module Solargraph
         elsif type.is_a?(RBS::Types::Variable)
           "#{Solargraph::ComplexType::GENERIC_TAG_NAME}<#{type.name}>"
         elsif type.is_a?(RBS::Types::ClassInstance) #&& !type.args.empty?
-          base = RBS_TO_YARD_TYPE[type.name.relative!.to_s] || type.name.relative!.to_s
-          params = type.args.map { |a| other_type_to_tag(a) }.reject { |t| t == 'undefined' }
-          return base if params.empty?
-          "#{base}<#{params.join(', ')}>"
+          generic_type_tag(type.name, type.args)
         elsif type.is_a?(RBS::Types::Bases::Instance)
           'self'
-        elsif type.is_a?(RBS::Types::Bases::Top) || type.is_a?(RBS::Types::Bases::Bottom)
-          'self'
+        elsif type.is_a?(RBS::Types::Bases::Top)
+          # top is the most super superclass
+          'BasicObject'
+        elsif type.is_a?(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'
         elsif type.is_a?(RBS::Types::Intersection)
           type.types.map { |member| other_type_to_tag(member) }.join(', ')
         elsif type.is_a?(RBS::Types::Proc)
@@ -446,6 +584,20 @@ module Solargraph
           'undefined'
         end
       end
+
+      # @param decl [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
+      # @param closure [Pin::Namespace]
+      # @return [void]
+      def add_mixins decl, namespace
+        decl.each_mixin do |mixin|
+          klass = mixin.is_a?(RBS::AST::Members::Include) ? Pin::Reference::Include : Pin::Reference::Extend
+          pins.push klass.new(
+            name: mixin.name.relative!.to_s,
+            location: rbs_location_to_location(mixin.location),
+            closure: namespace
+          )
+        end
+      end
     end
   end
 end