solargraph 0.54.4 → 0.57.0

data/lib/solargraph/rbs_map/conversions.rb

@@ -6,7 +6,9 @@ module Solargraph
   class RbsMap
     # Functions for converting RBS declarations to Solargraph pins
     #
-    module Conversions
+    class Conversions
+      include Logging
+
       # A container for tracking the current context of the RBS conversion
       # process, e.g., what visibility is declared for methods in the current
       # scope
@@ -20,11 +22,19 @@ module Solargraph
         end
       end
 
-      # @return [Array<Pin::Base>]
-      def pins
-        @pins ||= []
+      # @param loader [RBS::EnvironmentLoader]
+      def initialize(loader:)
+        @loader = loader
+        @pins = []
+        load_environment_to_pins(loader)
       end
 
+      # @return [RBS::EnvironmentLoader]
+      attr_reader :loader
+
+      # @return [Array<Pin::Base>]
+      attr_reader :pins
+
       private
 
       # @return [Hash{String => RBS::AST::Declarations::TypeAlias}]
@@ -37,9 +47,11 @@ module Solargraph
       def load_environment_to_pins(loader)
         environment = RBS::Environment.from_loader(loader).resolve_type_names
         cursor = pins.length
+        if environment.declarations.empty?
+          Solargraph.logger.info "No RBS declarations found in environment for core_root #{loader.core_root.inspect}, libraries #{loader.libs} and directories #{loader.dirs}"
+          return
+        end
         environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
-        added_pins = pins[cursor..-1]
-        added_pins.each { |pin| pin.source = :rbs }
       end
 
       # @param decl [RBS::AST::Declarations::Base]
@@ -86,7 +98,8 @@ module Solargraph
           name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
           generic_values: generic_values,
-          closure: closure
+          closure: closure,
+          source: :rbs
         )
         pins.push include_pin
       end
@@ -95,24 +108,24 @@ module Solargraph
       # @param closure [Pin::Namespace]
       # @return [void]
       def convert_members_to_pins decl, closure
-        context = Context.new
+        context = Conversions::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]
+      # @return [Context]
       def convert_member_to_pin member, closure, context
         case member
         when RBS::AST::Members::MethodDefinition
-          method_def_to_pin(member, closure)
+          method_def_to_pin(member, closure, context)
         when RBS::AST::Members::AttrReader
-          attr_reader_to_pin(member, closure)
+          attr_reader_to_pin(member, closure, context)
         when RBS::AST::Members::AttrWriter
-          attr_writer_to_pin(member, closure)
+          attr_writer_to_pin(member, closure, context)
         when RBS::AST::Members::AttrAccessor
-          attr_accessor_to_pin(member, closure)
+          attr_accessor_to_pin(member, closure, context)
         when RBS::AST::Members::Include
           include_to_pin(member, closure)
         when RBS::AST::Members::Prepend
@@ -128,9 +141,9 @@ module Solargraph
         when RBS::AST::Members::InstanceVariable
           ivar_to_pin(member, closure)
         when RBS::AST::Members::Public
-          return Context.new(visibility: :public)
+          return Context.new(:public)
         when RBS::AST::Members::Private
-          return Context.new(visibility: :private)
+          return Context.new(:private)
         when RBS::AST::Declarations::Base
           convert_decl_to_pin(member, closure)
         else
@@ -142,23 +155,39 @@ module Solargraph
       # @param decl [RBS::AST::Declarations::Class]
       # @return [void]
       def class_decl_to_pin decl
+        generics = decl.type_params.map(&:name).map(&:to_s)
+        generic_defaults = {}
+        decl.type_params.each do |param|
+          if param.default_type
+            tag = other_type_to_tag param.default_type
+            generic_defaults[param.name.to_s] = ComplexType.parse(tag).force_rooted
+          end
+        end
+        class_name = decl.name.relative!.to_s
         class_pin = Solargraph::Pin::Namespace.new(
           type: :class,
-          name: decl.name.relative!.to_s,
+          name: class_name,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
           type_location: location_decl_to_pin_location(decl.location),
           # @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)
+          generics: generics,
+          generic_defaults: generic_defaults,
+          source: :rbs
         )
         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(&: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,
-            name: decl.super_class.name.relative!.to_s
+            generic_values: generic_values,
+            name: superclass_name,
+            source: :rbs
           )
         end
         add_mixins decl, class_pin
@@ -178,7 +207,8 @@ module Solargraph
           generics: decl.type_params.map(&:name).map(&:to_s),
           # HACK: Using :hidden to keep interfaces from appearing in
           # autocompletion
-          visibility: :hidden
+          visibility: :hidden,
+          source: :rbs
         )
         class_pin.docstring.add_tag(YARD::Tags::Tag.new(:abstract, '(RBS interface)'))
         pins.push class_pin
@@ -195,6 +225,7 @@ module Solargraph
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
           generics: decl.type_params.map(&:name).map(&:to_s),
+          source: :rbs
         )
         pins.push module_pin
         convert_self_types_to_pins decl, module_pin
@@ -223,7 +254,8 @@ module Solargraph
           name: name,
           closure: closure,
           type_location: location_decl_to_pin_location(decl.location),
-          comments: comments
+          comments: comments,
+          source: :rbs
         )
         tag = "#{base}<#{tag}>" if base
         rooted_tag = ComplexType.parse(tag).force_rooted.rooted_tags
@@ -267,32 +299,101 @@ module Solargraph
           name: name,
           closure: closure,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
+          source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
 
+
+      # Visibility overrides that will allow the Solargraph project
+      # and plugins to pass typechecking using SOLARGRAPH_ASSERTS=on,
+      # so that we can detect any regressions/issues elsewhere in the
+      # visibility logic.
+      #
+      # These should either reflect a bug upstream in the RBS
+      # definitions, or include a @todo indicating what needs to be
+      # fixed in Solargraph to properly understand it.
+      #
+      # @todo PR these fixes upstream and list open PRs here above
+      #   related overrides
+      # @todo externalize remaining overrides into yaml file, then
+      #   allow that to be extended via .solargraph.yml
+      # @type [Hash{Array(String, Symbol, String) => Symbol}
+      VISIBILITY_OVERRIDE = {
+        ["Rails::Engine", :instance, "run_tasks_blocks"] => :protected,
+        # Should have been marked as both instance and class method in module -e.g., 'module_function'
+        ["Kernel", :instance, "pretty_inspect"] => :private,
+        # marked incorrectly in RBS
+        ["WEBrick::HTTPUtils::FormData", :instance, "next_data"] => :protected,
+        ["Rails::Command", :class, "command_type"] => :private,
+        ["Rails::Command", :class, "lookup_paths"] => :private,
+        ["Rails::Command", :class, "file_lookup_paths"] => :private,
+        ["Rails::Railtie", :instance, "run_console_blocks"] => :protected,
+        ["Rails::Railtie", :instance, "run_generators_blocks"] => :protected,
+        ["Rails::Railtie", :instance, "run_runner_blocks"] => :protected,
+        ["Rails::Railtie", :instance, "run_tasks_blocks"] => :protected,
+        ["ActionController::Base", :instance, "_protected_ivars"] => :private,
+        ["ActionView::Template", :instance, "method_name"] => :public,
+        ["Module", :instance, "ruby2_keywords"] => :private,
+        ["Nokogiri::XML::Node", :instance, "coerce"] => :protected,
+        ["Nokogiri::XML::Document", :class, "empty_doc?"] => :private,
+        ["Nokogiri::Decorators::Slop", :instance, "respond_to_missing?"] => :public,
+        ["RuboCop::Cop::RangeHelp", :instance, "source_range"] => :private,
+        ["AST::Node", :instance, "original_dup"] => :private,
+        ["Rainbow::Presenter", :instance, "wrap_with_sgr"] => :private,
+      }
+
+      # @param decl [RBS::AST::Members::MethodDefinition, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrAccessor]
+      # @param closure [Pin::Closure]
+      # @param context [Context]
+      # @param scope [Symbol] :instance or :class
+      # @param name [String] The name of the method
+      # @sg-ignore
+      # @return [Symbol]
+      def calculate_method_visibility(decl, context, closure, scope, name)
+        override_key = [closure.path, scope, name]
+        visibility = VISIBILITY_OVERRIDE[override_key]
+        simple_override_key = [closure.path, scope]
+        visibility ||= VISIBILITY_OVERRIDE[simple_override_key]
+        visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(decl.name)
+        if decl.kind == :singleton_instance
+          # this is a 'module function'
+          visibility ||= :private
+        end
+        visibility ||= decl.visibility
+        visibility ||= context.visibility
+        visibility ||= :public
+        visibility
+      end
+
       # @param decl [RBS::AST::Members::MethodDefinition]
       # @param closure [Pin::Closure]
+      # @param context [Context]
       # @return [void]
-      def method_def_to_pin decl, closure
+      def method_def_to_pin decl, closure, context
         # 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?
+          name = decl.name.to_s
+          final_scope = :instance
+          visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
           pin = Solargraph::Pin::Method.new(
-            name: decl.name.to_s,
+            name: name,
             closure: closure,
             type_location: location_decl_to_pin_location(decl.location),
             comments: decl.comment&.string,
-            scope: :instance,
+            scope: final_scope,
             signatures: [],
             generics: generics,
-            # @todo RBS core has unreliable visibility definitions
-            visibility: closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(decl.name) ? :private : :public
+            visibility: visibility,
+            source: :rbs
           )
           pin.signatures.concat method_def_to_sigs(decl, pin)
           pins.push pin
@@ -302,14 +403,19 @@ module Solargraph
           end
         end
         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: decl.name.to_s,
+            name: name,
             closure: closure,
             comments: decl.comment&.string,
             type_location: location_decl_to_pin_location(decl.location),
-            scope: :class,
+            visibility: visibility,
+            scope: final_scope,
             signatures: [],
-            generics: generics
+            generics: generics,
+            source: :rbs
           )
           pin.signatures.concat method_def_to_sigs(decl, pin)
           pins.push pin
@@ -321,13 +427,16 @@ module Solargraph
       # @return [void]
       def method_def_to_sigs decl, pin
         decl.overloads.map do |overload|
+          type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = overload.method_type.type_params.map(&:name).map(&:to_s)
           signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
           block = if overload.method_type.block
                     block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin)
-                    Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type)
+                    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)
+          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
 
@@ -346,40 +455,52 @@ module Solargraph
       # @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)).force_rooted] if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
+        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)],
+            ComplexType.try_parse(method_type_to_tag(type)).force_rooted
+          ]
+        end
 
         parameters = []
         arg_num = -1
         type.type.required_positionals.each do |param|
-          name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
+          name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted, source: :rbs, type_location: type_location)
         end
         type.type.optional_positionals.each do |param|
-          name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
+          name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
-                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
+                                                         type_location: type_location,
+                                                         source: :rbs)
         end
         if type.type.rest_positionals
-          name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin)
+          name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg_#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin, source: :rbs, type_location: type_location)
         end
         type.type.trailing_positionals.each do |param|
-          name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin)
+          name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs, type_location: type_location)
         end
         type.type.required_keywords.each do |orig, param|
-          name = orig ? orig.to_s : "arg#{arg_num += 1}"
+          name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
-                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
+                                                         source: :rbs, type_location: type_location)
         end
         type.type.optional_keywords.each do |orig, param|
-          name = orig ? orig.to_s : "arg#{arg_num += 1}"
+          name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
-                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
+                                                         type_location: type_location,
+                                                         source: :rbs)
         end
         if type.type.rest_keywords
-          name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg, name: type.type.rest_keywords.name.to_s, closure: pin)
+          name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg_#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg, name: type.type.rest_keywords.name.to_s, closure: pin,
+                                                         source: :rbs, type_location: type_location)
         end
 
         rooted_tag = method_type_to_tag(type)
@@ -389,33 +510,56 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrReader,RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
-      def attr_reader_to_pin(decl, closure)
+      def attr_reader_to_pin(decl, closure, context)
+        name = decl.name.to_s
+        final_scope = decl.kind == :instance ? :instance : :class
+        visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
         pin = Solargraph::Pin::Method.new(
-          name: decl.name.to_s,
+          name: name,
           type_location: location_decl_to_pin_location(decl.location),
           closure: closure,
           comments: decl.comment&.string,
-          scope: :instance,
-          attribute: true
+          scope: final_scope,
+          attribute: true,
+          visibility: visibility,
+          source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
+        logger.debug { "Conversions#attr_reader_to_pin(name=#{name.inspect}, visibility=#{visibility.inspect}) => #{pin.inspect}" }
         pins.push pin
       end
 
       # @param decl [RBS::AST::Members::AttrWriter, RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
-      def attr_writer_to_pin(decl, closure)
+      def attr_writer_to_pin(decl, closure, context)
+        final_scope = decl.kind == :instance ? :instance : :class
+        name = "#{decl.name.to_s}="
+        visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
+        type_location = location_decl_to_pin_location(decl.location)
         pin = Solargraph::Pin::Method.new(
-          name: "#{decl.name.to_s}=",
-          type_location: location_decl_to_pin_location(decl.location),
+          name: name,
+          type_location: type_location,
           closure: closure,
+          parameters: [],
           comments: decl.comment&.string,
-          scope: :instance,
-          attribute: true
+          scope: final_scope,
+          attribute: true,
+          visibility: visibility,
+          source: :rbs
         )
+        pin.parameters <<
+          Solargraph::Pin::Parameter.new(
+            name: 'value',
+            return_type: ComplexType.try_parse(other_type_to_tag(decl.type)).force_rooted,
+            source: :rbs,
+            closure: pin,
+            type_location: type_location
+          )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         pins.push pin
@@ -423,10 +567,11 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
-      def attr_accessor_to_pin(decl, closure)
-        attr_reader_to_pin(decl, closure)
-        attr_writer_to_pin(decl, closure)
+      def attr_accessor_to_pin(decl, closure, context)
+        attr_reader_to_pin(decl, closure, context)
+        attr_writer_to_pin(decl, closure, context)
       end
 
       # @param decl [RBS::AST::Members::InstanceVariable]
@@ -437,7 +582,8 @@ module Solargraph
           name: decl.name.to_s,
           closure: closure,
           type_location: location_decl_to_pin_location(decl.location),
-          comments: decl.comment&.string
+          comments: decl.comment&.string,
+          source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
@@ -452,7 +598,9 @@ module Solargraph
         pin = Solargraph::Pin::ClassVariable.new(
           name: name,
           closure: closure,
-          comments: decl.comment&.string
+          comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
+          source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
@@ -467,7 +615,9 @@ module Solargraph
         pin = Solargraph::Pin::InstanceVariable.new(
           name: name,
           closure: closure,
-          comments: decl.comment&.string
+          comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
+          source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
@@ -484,7 +634,8 @@ module Solargraph
           name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
           generic_values: generic_values,
-          closure: closure
+          closure: closure,
+          source: :rbs
         )
       end
 
@@ -495,7 +646,8 @@ module Solargraph
         pins.push Solargraph::Pin::Reference::Prepend.new(
           name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
-          closure: closure
+          closure: closure,
+          source: :rbs
         )
       end
 
@@ -506,7 +658,8 @@ module Solargraph
         pins.push Solargraph::Pin::Reference::Extend.new(
           name: decl.name.relative!.to_s,
           type_location: location_decl_to_pin_location(decl.location),
-          closure: closure
+          closure: closure,
+          source: :rbs
         )
       end
 
@@ -514,11 +667,14 @@ module Solargraph
       # @param closure [Pin::Namespace]
       # @return [void]
       def alias_to_pin decl, closure
+        final_scope = decl.singleton? ? :class : :instance
         pins.push Solargraph::Pin::MethodAlias.new(
           name: decl.new_name.to_s,
           type_location: location_decl_to_pin_location(decl.location),
           original: decl.old_name.to_s,
-          closure: closure
+          closure: closure,
+          scope: final_scope,
+          source: :rbs,
         )
       end
 
@@ -545,13 +701,13 @@ module Solargraph
       # @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| other_type_to_tag(a) }.reject { |t| t == 'undefined' }.map do |t|
+        params = type_args.map { |a| other_type_to_tag(a) }.map do |t|
           ComplexType.try_parse(t).force_rooted
         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, rooted: true, parameters_type: :list)
+          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
         end
       end
 
@@ -568,14 +724,13 @@ module Solargraph
         if type.is_a?(RBS::Types::Optional)
           "#{other_type_to_tag(type.type)}, nil"
         elsif type.is_a?(RBS::Types::Bases::Any)
-          # @todo Not sure what to do with Any yet
-          'BasicObject'
+          'undefined'
         elsif type.is_a?(RBS::Types::Bases::Bool)
           'Boolean'
         elsif type.is_a?(RBS::Types::Tuple)
           "Array(#{type.types.map { |t| other_type_to_tag(t) }.join(', ')})"
         elsif type.is_a?(RBS::Types::Literal)
-          type.literal.to_s
+          type.literal.inspect
         elsif type.is_a?(RBS::Types::Union)
           type.types.map { |t| other_type_to_tag(t) }.join(', ')
         elsif type.is_a?(RBS::Types::Record)
@@ -637,7 +792,8 @@ module Solargraph
             name: mixin.name.relative!.to_s,
             type_location: location_decl_to_pin_location(mixin.location),
             generic_values: generic_values,
-            closure: namespace
+            closure: namespace,
+            source: :rbs
           )
         end
       end

data/lib/solargraph/rbs_map/core_fills.rb

@@ -13,38 +13,54 @@ module Solargraph
         'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
         'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
         'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
-      ].map { |k| Pin::Keyword.new(k) }
+      ].map { |k| Pin::Keyword.new(k, source: :core_fill) }
 
       MISSING = [
-        Solargraph::Pin::Method.new(name: 'tap', scope: :instance,
-                                    closure: Solargraph::Pin::Namespace.new(name: 'Object')),
         Solargraph::Pin::Method.new(name: 'class', scope: :instance,
-                                    closure: Solargraph::Pin::Namespace.new(name: 'Object'), comments: '@return [::Class<self>]')
+                                    closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill), comments: '@return [::Class<self>]',
+                                    source: :core_fill)
       ]
 
       OVERRIDES = [
-        Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]'),
-        Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]'),
-        Override.from_comment('Module#define_method', '@yieldreceiver [::Object<self>]'),
-        Override.from_comment('Module#class_eval', '@yieldreceiver [::Class<self>]'),
-        Override.from_comment('Module#class_exec', '@yieldreceiver [::Class<self>]'),
-        Override.from_comment('Module#module_eval', '@yieldreceiver [::Module<self>]'),
-        Override.from_comment('Module#module_exec', '@yieldreceiver [::Module<self>]'),
+        Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]',
+                              source: :core_fill),
+        Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]',
+                              source: :core_fill),
+        Override.from_comment('Module#define_method', '@yieldreceiver [::Object<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#class_eval', '@yieldreceiver [::Class<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#class_exec', '@yieldreceiver [::Class<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#module_eval', '@yieldreceiver [::Module<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#module_exec', '@yieldreceiver [::Module<self>]',
+                              source: :core_fill),
         # RBS does not define Class with a generic, so all calls to
         # generic() return an 'untyped'.  We can do better:
-        Override.method_return('Class#allocate', 'self')
+        Override.method_return('Class#allocate', 'self', source: :core_fill),
+      ]
+
+      # @todo I don't see any direct link in RBS to build this from -
+      #   presumably RBS is using duck typing to match interfaces
+      #   against concrete classes
+      INCLUDES = [
+        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill)
       ]
 
       # HACK: Add Errno exception classes
-      errno = Solargraph::Pin::Namespace.new(name: 'Errno')
+      errno = Solargraph::Pin::Namespace.new(name: 'Errno', source: :core_fill)
       errnos = []
       Errno.constants.each do |const|
-        errnos.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno)
-        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError')
+        errnos.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno, source: :core_fill)
+        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError', source: :core_fill)
       end
       ERRNOS = errnos
 
-      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS
+      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS + INCLUDES
     end
   end
 end