solargraph 0.54.5 → 0.58.2

data/lib/solargraph/rbs_map/core_fills.rb

@@ -13,38 +13,72 @@ 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),
+        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill),
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'String', source: :core_fill),
+                                                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

data/lib/solargraph/rbs_map/core_map.rb

@@ -1,28 +1,58 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class RbsMap
-    # Ruby core pins
-    #
-    class CoreMap
-      include Conversions
-
-      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
-          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)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class RbsMap
+    # Ruby core pins
+    #
+    class CoreMap
+      include Logging
+
+      def resolved?
+        true
+      end
+
+      FILLS_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills'))
+
+      def initialize; end
+
+      # @return [Enumerable<Pin::Base>]
+      def pins
+        return @pins if @pins
+
+        @pins = []
+        cache = PinCache.deserialize_core
+        if cache
+          @pins.replace cache
+        else
+          @pins.concat conversions.pins
+
+          # Avoid RBS::DuplicatedDeclarationError by loading in a different EnvironmentLoader
+          fill_loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: false))
+          fill_loader.add(path: Pathname(FILLS_DIRECTORY))
+          fill_conversions = Conversions.new(loader: fill_loader)
+          @pins.concat fill_conversions.pins
+
+          @pins.concat RbsMap::CoreFills::ALL
+
+          processed = ApiMap::Store.new(pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
+          @pins.replace processed
+
+          PinCache.serialize_core @pins
+        end
+        @pins
+      end
+
+      private
+
+      # @return [RBS::EnvironmentLoader]
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
+      end
+
+      # @return [Conversions]
+      def conversions
+        @conversions ||= Conversions.new(loader: loader)
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/stdlib_map.rb

@@ -1,33 +1,43 @@
-# frozen_string_literal: true
-
-require 'rbs'
-
-module Solargraph
-  class RbsMap
-    # Ruby stdlib pins
-    #
-    class StdlibMap < RbsMap
-      # @type [Hash{String => RbsMap}]
-      @stdlib_maps_hash = {}
-
-      # @param library [String]
-      def initialize library
-        cache = Cache.load('stdlib', "#{library}.ser")
-        if cache
-          pins.replace cache
-          @resolved = true
-        else
-          super
-          return unless resolved?
-          Cache.save('stdlib', "#{library}.ser", pins)
-        end
-      end
-
-      # @param library [String]
-      # @return [StdlibMap]
-      def self.load library
-        @stdlib_maps_hash[library] ||= StdlibMap.new(library)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Solargraph
+  class RbsMap
+    # Ruby stdlib pins
+    #
+    class StdlibMap < RbsMap
+      include Logging
+
+      # @type [Hash{String => RbsMap}]
+      @stdlib_maps_hash = {}
+
+      # @param library [String]
+      def initialize library
+        cached_pins = PinCache.deserialize_stdlib_require library
+        if cached_pins
+          @pins = cached_pins
+          @resolved = true
+          @loaded = true
+          logger.debug { "Deserialized #{cached_pins.length} cached pins for stdlib require #{library.inspect}" }
+        else
+          super
+          unless resolved?
+            @pins = []
+            logger.info { "Could not resolve #{library.inspect}" }
+            return
+          end
+          generated_pins = pins
+          logger.debug { "Found #{generated_pins.length} pins for stdlib library #{library}" }
+          PinCache.serialize_stdlib_require library, generated_pins
+        end
+      end
+
+      # @param library [String]
+      # @return [StdlibMap]
+      def self.load library
+        @stdlib_maps_hash[library] ||= StdlibMap.new(library)
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map.rb

@@ -1,93 +1,163 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require 'rbs'
-
-module Solargraph
-  class RbsMap
-    autoload :Conversions, 'solargraph/rbs_map/conversions'
-    autoload :CoreMap,     'solargraph/rbs_map/core_map'
-    autoload :CoreFills,   'solargraph/rbs_map/core_fills'
-    autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
-
-    include Conversions
-
-    # @type [Hash{String => RbsMap}]
-    @@rbs_maps_hash = {}
-
-    attr_reader :library
-
-    # @param library [String]
-    # @param version [String, nil]
-    # @param directories [Array<Pathname, String>]
-    def initialize library, version = nil, directories: []
-      @library = library
-      @version = version
-      @collection = nil
-      @directories = directories
-      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
-      add_library loader, library, version
-      return unless resolved?
-      load_environment_to_pins(loader)
-    end
-
-    # @generic T
-    # @param path [String]
-    # @param klass [Class<generic<T>>]
-    # @return [generic<T>, nil]
-    def path_pin path, klass = Pin::Base
-      pin = pins.find { |p| p.path == path }
-      pin if pin&.is_a?(klass)
-    end
-
-    # @param path [String]
-    # @return [Array<Pin::Base>]
-    def path_pins path
-      pins.select { |p| p.path == path }
-    end
-
-    def resolved?
-      @resolved
-    end
-
-    def repository
-      @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
-        # @todo Temporarily ignoring external directories due to issues with
-        #   incomplete/broken gem_rbs_collection installations
-        # @directories.each { |dir| repo.add(Pathname.new(dir)) }
-      end
-    end
-
-    # @param library [String]
-    # @return [RbsMap]
-    def self.load library
-      @@rbs_maps_hash[library] ||= RbsMap.new(library)
-    end
-
-    # @param gemspec [Gem::Specification]
-    def self.from_gemspec(gemspec)
-      RbsMap.new(gemspec.name, gemspec.version)
-    end
-
-    private
-
-    # @param loader [RBS::EnvironmentLoader]
-    # @param library [String]
-    # @return [Boolean] true if adding the library succeeded
-    def add_library loader, library, version
-      @resolved = if loader.has_library?(library: library, version: version)
-        loader.add library: library, version: version
-        Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
-        true
-      else
-        Solargraph.logger.info "#{short_name} failed to load library #{library}"
-        false
-      end
-    end
-
-    # @return [String]
-    def short_name
-      self.class.name.split('::').last
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'digest'
+require 'pathname'
+require 'rbs'
+
+module Solargraph
+  class RbsMap
+    autoload :Conversions, 'solargraph/rbs_map/conversions'
+    autoload :CoreMap,     'solargraph/rbs_map/core_map'
+    autoload :CoreFills,   'solargraph/rbs_map/core_fills'
+    autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
+
+    include Logging
+
+    # @type [Hash{String => RbsMap}]
+    @@rbs_maps_hash = {}
+
+    attr_reader :library
+
+    attr_reader :rbs_collection_paths
+
+    attr_reader :rbs_collection_config_path
+
+    # @param library [String]
+    # @param version [String, nil]
+    # @param rbs_collection_config_path [String, Pathname, nil]
+    # @param rbs_collection_paths [Array<Pathname, String>]
+    def initialize library, version = nil, rbs_collection_config_path: nil, rbs_collection_paths: []
+      if rbs_collection_config_path.nil? && !rbs_collection_paths.empty?
+        raise 'Please provide rbs_collection_config_path if you provide rbs_collection_paths'
+      end
+      @library = library
+      @version = version
+      @rbs_collection_config_path = rbs_collection_config_path
+      @rbs_collection_paths = rbs_collection_paths
+      add_library loader, library, version
+    end
+
+    # @return [RBS::EnvironmentLoader]
+    def loader
+      @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+    end
+
+    # @return [String] representing the version of the RBS info fetched
+    #   for the given library.  Must change when the RBS info is
+    #   updated upstream for the same library and version.  May change
+    #   if the config for where information comes form changes.
+    def cache_key
+      @hextdigest ||= begin
+        # @type [String, nil]
+        data = nil
+        if rbs_collection_config_path
+          lockfile_path = RBS::Collection::Config.to_lockfile_path(Pathname.new(rbs_collection_config_path))
+          if lockfile_path.exist?
+            collection_config = RBS::Collection::Config.from_path lockfile_path
+            gem_config = collection_config.gem(library)
+            data = gem_config&.to_s
+          end
+        end
+        if data.nil? || data.empty?
+          if resolved?
+            # definitely came from the gem itself and not elsewhere -
+            # only one version per gem
+            'gem-export'
+          else
+            'unresolved'
+          end
+        else
+          Digest::SHA1.hexdigest(data)
+        end
+      end
+    end
+
+    # @param gemspec [Gem::Specification, Bundler::LazySpecification]
+    # @param rbs_collection_path [String, Pathname, nil]
+    # @param rbs_collection_config_path [String, Pathname, nil]
+    # @return [RbsMap]
+    def self.from_gemspec gemspec, rbs_collection_path, rbs_collection_config_path
+      rbs_map = RbsMap.new(gemspec.name, gemspec.version,
+                           rbs_collection_paths: [rbs_collection_path].compact,
+                           rbs_collection_config_path: rbs_collection_config_path)
+      return rbs_map if rbs_map.resolved?
+
+      # try any version of the gem in the collection
+      RbsMap.new(gemspec.name, nil,
+                 rbs_collection_paths: [rbs_collection_path].compact,
+                 rbs_collection_config_path: rbs_collection_config_path)
+    end
+
+    # @return [Array<Pin::Base>]
+    def pins
+      @pins ||= resolved? ? conversions.pins : []
+    end
+
+    # @generic T
+    # @param path [String]
+    # @param klass [Class<generic<T>>]
+    # @return [generic<T>, nil]
+    def path_pin path, klass = Pin::Base
+      pin = pins.find { |p| p.path == path }
+      pin if pin&.is_a?(klass)
+    end
+
+    # @param path [String]
+    # @return [Array<Pin::Base>]
+    def path_pins path
+      pins.select { |p| p.path == path }
+    end
+
+    def resolved?
+      @resolved
+    end
+
+    # @return [RBS::Repository]
+    def repository
+      @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
+        @rbs_collection_paths.each do |dir|
+          dir_path = Pathname.new(dir)
+          repo.add(dir_path) if dir_path.exist? && dir_path.directory?
+        end
+      end
+    end
+
+    # @param library [String]
+    # @return [RbsMap]
+    def self.load library
+      @@rbs_maps_hash[library] ||= RbsMap.new(library)
+    end
+
+    private
+
+    # @return [RBS::EnvironmentLoader]
+    def loader
+      @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+    end
+
+    # @return [Conversions]
+    def conversions
+      @conversions ||= Conversions.new(loader: loader)
+    end
+
+    # @param loader [RBS::EnvironmentLoader]
+    # @param library [String]
+    # @param version [String, nil]
+    # @return [Boolean] true if adding the library succeeded
+    def add_library loader, library, version
+      @resolved = if loader.has_library?(library: library, version: version)
+        loader.add library: library, version: version
+        logger.debug { "#{short_name} successfully loaded library #{library}:#{version}" }
+        true
+      else
+        logger.info { "#{short_name} did not find data for library #{library}:#{version}" }
+        false
+      end
+    end
+
+    # @return [String]
+    def short_name
+      self.class.name.split('::').last
+    end
+  end
+end