solargraph 0.55.3 → 0.55.4

data/lib/solargraph/rbs_map/conversions.rb

@@ -7,6 +7,8 @@ module Solargraph
     # Functions for converting RBS declarations to Solargraph pins
     #
     module 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
@@ -38,8 +40,6 @@ module Solargraph
         environment = RBS::Environment.from_loader(loader).resolve_type_names
         cursor = pins.length
         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 +86,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
@@ -106,13 +107,13 @@ module Solargraph
       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 +129,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,6 +143,14 @@ 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_pin = Solargraph::Pin::Namespace.new(
           type: :class,
           name: decl.name.relative!.to_s,
@@ -151,14 +160,20 @@ module Solargraph
           # @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)
           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: decl.super_class.name.relative!.to_s,
+            source: :rbs
           )
         end
         add_mixins decl, class_pin
@@ -178,7 +193,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 +211,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 +240,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 +285,92 @@ module Solargraph
           name: name,
           closure: closure,
           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))
         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
+      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,
+      }
+
+      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 +380,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
@@ -325,9 +408,11 @@ module Solargraph
           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,
+                                       closure: pin, source: :rbs)
                   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,
+                             closure: pin, source: :rbs)
         end
       end
 
@@ -346,40 +431,44 @@ 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)
+        return [[Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs)], ComplexType.try_parse(method_type_to_tag(type)).force_rooted] if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
 
         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)
+          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)
         end
         type.type.optional_positionals.each do |param|
           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,
+                                                         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)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin, source: :rbs)
         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)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs)
         end
         type.type.required_keywords.each do |orig, param|
           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)
         end
         type.type.optional_keywords.each do |orig, param|
           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,
+                                                         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)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg, name: type.type.rest_keywords.name.to_s, closure: pin,
+                                                         source: :rbs)
         end
 
         rooted_tag = method_type_to_tag(type)
@@ -390,32 +479,51 @@ module Solargraph
       # @param decl [RBS::AST::Members::AttrReader,RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
       # @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
+          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]
       # @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)
         pin = Solargraph::Pin::Method.new(
-          name: "#{decl.name.to_s}=",
+          name: name,
           type_location: location_decl_to_pin_location(decl.location),
           closure: closure,
+          parameters: [],
           comments: decl.comment&.string,
           scope: :instance,
-          attribute: true
+          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
+          )
         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
@@ -424,9 +532,9 @@ module Solargraph
       # @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)
+      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 +545,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 +561,8 @@ module Solargraph
         pin = Solargraph::Pin::ClassVariable.new(
           name: name,
           closure: closure,
-          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))
@@ -467,7 +577,8 @@ module Solargraph
         pin = Solargraph::Pin::InstanceVariable.new(
           name: name,
           closure: closure,
-          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))
@@ -484,7 +595,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 +607,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 +619,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
 
@@ -518,7 +632,8 @@ module Solargraph
           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,
+          source: :rbs,
         )
       end
 
@@ -637,7 +752,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,24 +13,32 @@ 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: '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 -
@@ -38,16 +46,17 @@ module Solargraph
       #   against concrete classes
       INCLUDES = [
         Solargraph::Pin::Reference::Include.new(name: '_ToAry',
-                                                closure: Solargraph::Pin::Namespace.new(name: 'Array'),
-                                                generic_values: ['generic<Elem>'])
+                                                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
 

data/lib/solargraph/rbs_map/core_map.rb

@@ -7,17 +7,18 @@ module Solargraph
     class CoreMap
       include Conversions
 
+      FILLS_DIRECTORY = File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills')
+
       def initialize
         cache = Cache.load('core.ser')
         if cache
           pins.replace cache
         else
           loader = RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
-          RBS::Environment.from_loader(loader).resolve_type_names
+          loader.add(path: Pathname(FILLS_DIRECTORY))
           load_environment_to_pins(loader)
           pins.concat RbsMap::CoreFills::ALL
           processed = ApiMap::Store.new(pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
-          processed.each { |pin| pin.source = :rbs }
           pins.replace processed
 
           Cache.save('core.ser', pins)

data/lib/solargraph/shell.rb

@@ -206,6 +206,7 @@ module Solargraph
     # @return [void]
     def scan
       directory = File.realpath(options[:directory])
+      # @type [Solargraph::ApiMap, nil]
       api_map = nil
       time = Benchmark.measure {
         api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)

data/lib/solargraph/source/chain/array.rb

@@ -20,13 +20,16 @@ module Solargraph
           child_types = @children.map do |child|
             child.infer(api_map, name_pin, locals).simplify_literals
           end
-
-          type = if child_types.uniq.length == 1 && child_types.first.defined?
+          type = if child_types.length == 0 || child_types.any?(&:undefined?)
+                   ComplexType::UniqueType.new('Array', rooted: true)
+                 elsif child_types.uniq.length == 1 && child_types.first.defined?
                    ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
+                 elsif child_types.length == 0
+                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
                  else
-                   ComplexType::UniqueType.new('Array', rooted: true)
+                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
                  end
-          [Pin::ProxyType.anonymous(type)]
+          [Pin::ProxyType.anonymous(type, source: :chain)]
         end
       end
     end

data/lib/solargraph/source/chain/block_symbol.rb

@@ -5,7 +5,7 @@ module Solargraph
     class Chain
       class BlockSymbol < Link
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'))]
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
         end
       end
     end

data/lib/solargraph/source/chain/block_variable.rb

@@ -5,7 +5,7 @@ module Solargraph
     class Chain
       class BlockVariable < Link
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'))]
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
         end
       end
     end

data/lib/solargraph/source/chain/call.rb

@@ -85,6 +85,7 @@ module Solargraph
 
             with_block, without_block = overloads.partition(&:block?)
             sorted_overloads = with_block + without_block
+            # @type [Pin::Signature, nil]
             new_signature_pin = nil
             sorted_overloads.each do |ol|
               next unless ol.arity_matches?(arguments, with_block?)
@@ -97,8 +98,7 @@ module Solargraph
                   match = ol.parameters.any?(&:restarg?)
                   break
                 end
-
-                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context), locals)
+                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context, source: :chain), locals)
                 unless param.compatible_arg?(atype, api_map) || param.restarg?
                   match = false
                   break
@@ -114,6 +114,7 @@ module Solargraph
                     blocktype = block_call_type(api_map, name_pin, locals)
                   end
                 end
+                # @type new_signature_pin [Pin::Signature]
                 new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil, blocktype)
                 new_return_type = new_signature_pin.return_type
                 if head?
@@ -181,7 +182,7 @@ module Solargraph
             result = inner_process_macro(pin, macro, api_map, context, locals)
             return result unless result.return_type.undefined?
           end
-          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
         end
 
         # @param pin [Pin::Method]
@@ -196,7 +197,7 @@ module Solargraph
             result = inner_process_macro(pin, macro, api_map, context, locals)
             return result unless result.return_type.undefined?
           end
-          Pin::ProxyType.anonymous ComplexType::UNDEFINED
+          Pin::ProxyType.anonymous ComplexType::UNDEFINED, source: :chain
         end
 
         # @param pin [Pin::Base]
@@ -206,7 +207,7 @@ module Solargraph
         # @param locals [::Array<Pin::LocalVariable, Pin::Parameter>]
         # @return [Pin::ProxyType]
         def inner_process_macro pin, macro, api_map, context, locals
-          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
+          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals), source: :chain) }
           txt = macro.tag.text.clone
           if txt.empty? && macro.tag.name
             named = api_map.named_macro(macro.tag.name)
@@ -220,9 +221,9 @@ module Solargraph
           docstring = Solargraph::Source.parse_docstring(txt).to_docstring
           tag = docstring.tag(:return)
           unless tag.nil? || tag.types.nil?
-            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types))
+            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types), source: :chain)
           end
-          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
         end
 
         # @param docstring [YARD::Docstring]