solargraph 0.58.0 → 0.59.0

data/lib/solargraph/rbs_map/core_fills.rb

@@ -1,84 +1,91 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class RbsMap
-    # Override pins to fill gaps in RbsMap::CoreMap coverage
-    #
-    module CoreFills
-      Override = Pin::Reference::Override
-
-      KEYWORDS = [
-        '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
-        'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
-        '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, source: :core_fill) }
-
-      MISSING = [
-        Solargraph::Pin::Method.new(name: 'class', scope: :instance,
-                                    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]',
-                              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', 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', source: :core_fill)
-      errnos = []
-      Errno.constants.each do |const|
-        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 + INCLUDES
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class RbsMap
+    # Override pins to fill gaps in RbsMap::CoreMap coverage
+    #
+    module CoreFills
+      Override = Pin::Reference::Override
+
+      KEYWORDS = [
+        '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
+        'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
+        '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, source: :core_fill) }
+
+      MISSING = [
+        Solargraph::Pin::Method.new(name: 'class', scope: :instance,
+                                    closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill), comments: '@return [::Class<self>]',
+                                    source: :core_fill)
+      ].freeze
+
+      OVERRIDES = [
+        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', source: :core_fill)
+      ].freeze
+
+      # @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)
+      ].freeze
+
+      # HACK: Add Errno exception classes
+      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, 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 + INCLUDES
+    end
+  end
+end

data/lib/solargraph/rbs_map/core_map.rb

@@ -1,58 +1,65 @@
-# 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
+# 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
+
+      # @param out [IO, nil] output stream for logging
+      # @return [Enumerable<Pin::Base>]
+      def pins out: $stderr
+        return @pins if @pins
+        @pins = cache_core(out: out)
+      end
+
+      # @param out [StringIO, IO, nil] output stream for logging
+      # @return [Array<Pin::Base>]
+      def cache_core out: $stderr
+        new_pins = []
+        cache = PinCache.deserialize_core
+        return cache if cache
+        new_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))
+        out&.puts 'Caching RBS pins for Ruby core'
+        fill_conversions = Conversions.new(loader: fill_loader)
+        new_pins.concat fill_conversions.pins
+
+        # add some overrides
+        new_pins.concat RbsMap::CoreFills::ALL
+
+        # process overrides, then remove any which couldn't be resolved
+        processed = ApiMap::Store.new(new_pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
+        new_pins.replace processed
+
+        PinCache.serialize_core new_pins
+
+        new_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,43 +1,71 @@
-# 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
+# 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 rebuild [Boolean] build pins regardless of whether we
+      #   have cached them already
+      # @param library [String]
+      # @param out [StringIO, IO, nil] where to log messages
+      def initialize library, rebuild: false, out: $stderr
+        cached_pins = PinCache.deserialize_stdlib_require library
+        if cached_pins && !rebuild
+          @pins = cached_pins
+          @resolved = true
+          @loaded = true
+          logger.debug { "Deserialized #{cached_pins.length} cached pins for stdlib require #{library.inspect}" }
+        elsif self.class.source.has? library, nil
+          super(library, out: out)
+          unless resolved?
+            @pins = []
+            logger.debug { "StdlibMap 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
+
+      # @return [RBS::Collection::Sources::Stdlib]
+      def self.source
+        @source ||= RBS::Collection::Sources::Stdlib.instance
+      end
+
+      # @param name [String]
+      # @param version [String, nil]
+      # @return [Array<Hash{String => String}>, nil]
+      def self.stdlib_dependencies name, version = nil
+        if source.has?(name, version)
+          # @sg-ignore we are relying on undocumented behavior where
+          #   passing version=nil gives the latest version it has
+          source.dependencies_of(name, version)
+        else
+          []
+        end
+      end
+
+      def resolve_dependencies?
+        # there are 'virtual' dependencies for stdlib gems in RBS that
+        # aren't represented in the actual gemspecs that we'd
+        # otherwise use
+        true
+      end
+
+      # @param library [String]
+      # @return [StdlibMap]
+      def self.load library
+        @stdlib_maps_hash[library] ||= StdlibMap.new(library)
+      end
+    end
+  end
+end