solargraph 0.58.0 → 0.59.0

data/lib/solargraph/api_map/index.rb

@@ -1,193 +1,204 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class ApiMap
-    class Index
-      include Logging
-
-      # @param pins [Array<Pin::Base>]
-      def initialize pins = []
-        catalog pins
-      end
-
-      # @return [Array<Pin::Base>]
-      def pins
-        @pins ||= []
-      end
-
-      # @return [Hash{String => Array<Pin::Namespace>}]
-      def namespace_hash
-        # @param h [String]
-        # @param k [Array<Pin::Namespace>]
-        @namespace_hash ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @return [Hash{String => Array<Pin::Base>}]
-      def pin_class_hash
-        # @param h [String]
-        # @param k [Array<Pin::Base>]
-        @pin_class_hash ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @return [Hash{String => Array<Pin::Base>}]
-      def path_pin_hash
-        # @param h [String]
-        # @param k [Array<Pin::Base>]
-        @path_pin_hash ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @generic T
-      # @param klass [Class<generic<T>>]
-      # @return [Set<generic<T>>]
-      def pins_by_class klass
-        # @type [Set<Solargraph::Pin::Base>]
-        s = Set.new
-        # @sg-ignore need to support destructured args in blocks
-        @pin_select_cache[klass] ||= pin_class_hash.each_with_object(s) { |(key, o), n| n.merge(o) if key <= klass }
-      end
-
-      # @return [Hash{String => Array<String>}]
-      def include_references
-        # @param h [String]
-        # @param k [Array<String>]
-        @include_references ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @return [Hash{String => Array<Pin::Reference::Include>}]
-      def include_reference_pins
-        # @param h [String]
-        # @param k [Array<Pin::Reference::Include>]
-        @include_reference_pins ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @return [Hash{String => Array<String>}]
-      def extend_references
-        # @param h [String]
-        # @param k [Array<String>]
-        @extend_references ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @return [Hash{String => Array<String>}]
-      def prepend_references
-        # @param h [String]
-        # @param k [Array<String>]
-        @prepend_references ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @return [Hash{String => Array<String>}]
-      def superclass_references
-        # @param h [String]
-        # @param k [Array<String>]
-        @superclass_references ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      # @param pins [Enumerable<Pin::Base>]
-      # @return [self]
-      def merge pins
-        deep_clone.catalog pins
-      end
-
-      protected
-
-      attr_writer :pins, :pin_select_cache, :namespace_hash, :pin_class_hash, :path_pin_hash, :include_references,
-                  :extend_references, :prepend_references, :superclass_references
-
-      # @return [self]
-      def deep_clone
-        Index.allocate.tap do |copy|
-          copy.pin_select_cache = {}
-          copy.pins = pins.clone
-          %i[
-            namespace_hash pin_class_hash path_pin_hash include_references extend_references prepend_references
-            superclass_references
-          ].each do |sym|
-            copy.send("#{sym}=", send(sym).clone)
-            copy.send(sym)&.transform_values!(&:clone)
-          end
-        end
-      end
-
-      # @param new_pins [Enumerable<Pin::Base>]
-      #
-      # @return [self]
-      def catalog new_pins
-        # @type [Hash{Class<generic<T>> => Set<generic<T>>}]
-        @pin_select_cache = {}
-        pins.concat new_pins
-        set = new_pins.to_set
-        # @param k [String]
-        # @param v [Set<Pin::Base>]
-        set.classify(&:class)
-          .map { |k, v| pin_class_hash[k].concat v.to_a }
-        # @param k [String]
-        # @param v [Set<Pin::Namespace>]
-        set.classify(&:namespace)
-          .map { |k, v| namespace_hash[k].concat v.to_a }
-        # @param k [String]
-        # @param v [Set<Pin::Base>]
-        set.classify(&:path)
-          .map { |k, v| path_pin_hash[k].concat v.to_a }
-        @namespaces = path_pin_hash.keys.compact.to_set
-        map_references Pin::Reference::Include, include_references
-        map_references Pin::Reference::Prepend, prepend_references
-        map_references Pin::Reference::Extend, extend_references
-        map_references Pin::Reference::Superclass, superclass_references
-        map_overrides
-        self
-      end
-
-      # @generic T
-      # @param klass [Class<generic<T>>]
-      # @param hash [Hash{String => generic<T>}]
-      #
-      # @return [void]
-      def map_references klass, hash
-        # @param pin [generic<T>]
-        pins_by_class(klass).each do |pin|
-          hash[pin.namespace].push pin
-        end
-      end
-
-      # @return [void]
-      def map_overrides
-        # @param ovr [Pin::Reference::Override]
-        pins_by_class(Pin::Reference::Override).each do |ovr|
-          logger.debug { "ApiMap::Index#map_overrides: Looking at override #{ovr} for #{ovr.name}" }
-          pins = path_pin_hash[ovr.name]
-          logger.debug { "ApiMap::Index#map_overrides: pins for path=#{ovr.name}: #{pins}" }
-          pins.each do |pin|
-            new_pin = if pin.path.end_with?('#initialize')
-                        path_pin_hash[pin.path.sub(/#initialize/, '.new')].first
-                      end
-            (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
-              pin.docstring.delete_tags tag
-              new_pin.docstring.delete_tags tag if new_pin
-            end
-            ovr.tags.each do |tag|
-              pin.docstring.add_tag(tag)
-              redefine_return_type pin, tag
-              if new_pin
-                new_pin.docstring.add_tag(tag)
-                redefine_return_type new_pin, tag
-              end
-            end
-          end
-        end
-      end
-
-      # @param pin [Pin::Method]
-      # @param tag [YARD::Tags::Tag]
-      # @return [void]
-      def redefine_return_type pin, tag
-        # @todo can this be made to not mutate existing pins and use
-        #   proxy() / proxy_with_signatures() instead?
-        return unless pin && tag.tag_name == 'return'
-        pin.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
-        pin.signatures.each do |sig|
-          sig.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
-        end
-        pin.reset_generated!
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class ApiMap
+    class Index
+      include Logging
+
+      # @param pins [Array<Pin::Base>]
+      def initialize pins = []
+        catalog pins
+      end
+
+      # @return [Array<Pin::Base>]
+      def pins
+        @pins ||= []
+      end
+
+      # @return [Hash{String => Array<Pin::Namespace>}]
+      def namespace_hash
+        # @param h [String]
+        # @param k [Array<Pin::Namespace>]
+        @namespace_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Base>}]
+      def pin_class_hash
+        # @param h [String]
+        # @param k [Array<Pin::Base>]
+        @pin_class_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Base>}]
+      def path_pin_hash
+        # @param h [String]
+        # @param k [Array<Pin::Base>]
+        @path_pin_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => ComplexType}]
+      def alias_hash
+        @alias_hash ||= {}
+      end
+
+      # @generic T
+      # @param klass [Class<generic<T>>]
+      # @return [Set<generic<T>>]
+      def pins_by_class klass
+        # @type [Set<generic<T>>]
+        s = Set.new
+        # @sg-ignore need to support destructured args in blocks
+        @pin_select_cache[klass] ||= pin_class_hash.each_with_object(s) { |(key, o), n| n.merge(o) if key <= klass }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
+      def include_references
+        # @param h [String]
+        # @param k [Array<String>]
+        @include_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
+      def include_reference_pins
+        # @param h [String]
+        # @param k [Array<Pin::Reference::Include>]
+        @include_reference_pins ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Extend>}]
+      def extend_references
+        # @param h [String]
+        # @param k [Array<String>]
+        @extend_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Prepend>}]
+      def prepend_references
+        # @param h [String]
+        # @param k [Array<String>]
+        @prepend_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Superclass>}]
+      def superclass_references
+        # @param h [String]
+        # @param k [Array<String>]
+        @superclass_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @param pins [Enumerable<Pin::Base>]
+      # @return [self]
+      def merge pins
+        deep_clone.catalog pins
+      end
+
+      protected
+
+      attr_writer :pins, :pin_select_cache, :namespace_hash, :pin_class_hash, :path_pin_hash, :include_references,
+                  :extend_references, :prepend_references, :superclass_references
+
+      # @return [self]
+      def deep_clone
+        Index.allocate.tap do |copy|
+          copy.pin_select_cache = {}
+          copy.pins = pins.clone
+          %i[
+            namespace_hash pin_class_hash path_pin_hash include_references extend_references prepend_references
+            superclass_references
+          ].each do |sym|
+            copy.send("#{sym}=", send(sym).clone)
+            copy.send(sym)&.transform_values!(&:clone)
+          end
+        end
+      end
+
+      # @param new_pins [Enumerable<Pin::Base>]
+      #
+      # @return [self]
+      def catalog new_pins
+        # @type [Hash{Class<generic<T>> => Set<generic<T>>}]
+        @pin_select_cache = {}
+        pins.concat new_pins
+        set = new_pins.to_set
+        # @param k [String]
+        # @param v [Set<Pin::Base>]
+        set.classify(&:class)
+           .map { |k, v| pin_class_hash[k].concat v.to_a }
+        # @param k [String]
+        # @param v [Set<Pin::Namespace>]
+        set.classify(&:namespace)
+           .map { |k, v| namespace_hash[k].concat v.to_a }
+        # @param k [String]
+        # @param v [Set<Pin::Base>]
+        set.classify(&:path)
+           .map { |k, v| path_pin_hash[k].concat v.to_a }
+        @namespaces = path_pin_hash.keys.compact.to_set
+        map_references Pin::Reference::Include, include_references
+        map_references Pin::Reference::Prepend, prepend_references
+        map_references Pin::Reference::Extend, extend_references
+        map_references Pin::Reference::Superclass, superclass_references
+        map_overrides
+        pins_by_class(Pin::Reference::TypeAlias).each { |pin| alias_hash[pin.name] = pin.return_type }
+        self
+      end
+
+      # @generic T
+      # @param klass [Class<generic<T>>]
+      # @param hash [Hash{String => Array<generic<T>>}]
+      #
+      # @return [void]
+      def map_references klass, hash
+        # @param pin [generic<T>]
+        pins_by_class(klass).each do |pin|
+          hash[pin.namespace].push pin
+        end
+      end
+
+      # @return [void]
+      def map_overrides
+        # @todo should complain when type for 'ovr' is not provided
+        # @param ovr [Pin::Reference::Override]
+        pins_by_class(Pin::Reference::Override).each do |ovr|
+          logger.debug { "ApiMap::Index#map_overrides: Looking at override #{ovr} for #{ovr.name}" }
+          pins = path_pin_hash[ovr.name]
+          logger.debug { "ApiMap::Index#map_overrides: pins for path=#{ovr.name}: #{pins}" }
+          pins.each do |pin|
+            new_pin = (path_pin_hash[pin.path.sub('#initialize', '.new')].first if pin.path.end_with?('#initialize'))
+            (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
+              # @sg-ignore Wrong argument type for
+              #   YARD::Docstring#delete_tags: name expected String,
+              #   received String, Symbol - delete_tags is ok with a
+              #   _ToS, but we should fix anyway
+              pin.docstring.delete_tags tag
+              new_pin&.docstring&.delete_tags tag
+            end
+            ovr.tags.each do |tag|
+              pin.docstring.add_tag(tag)
+              redefine_return_type pin, tag
+              pin.reset_generated!
+
+              next unless new_pin
+
+              new_pin.docstring.add_tag(tag)
+              redefine_return_type new_pin, tag
+              new_pin.reset_generated!
+            end
+          end
+        end
+      end
+
+      # @param pin [Pin::Method]
+      # @param tag [YARD::Tags::Tag]
+      # @return [void]
+      def redefine_return_type pin, tag
+        # @todo can this be made to not mutate existing pins and use
+        #   proxy() / proxy_with_signatures() instead?
+        return unless pin && tag.tag_name == 'return'
+        pin.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
+        pin.signatures.each do |sig|
+          sig.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/source_to_yard.rb

@@ -1,97 +1,110 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class ApiMap
-    module SourceToYard
-
-      # Get the YARD CodeObject at the specified path.
-      #
-      # @generic T
-      # @param path [String]
-      # @param klass [Class<generic<T>>]
-      # @return [generic<T>, nil]
-      def code_object_at path, klass = YARD::CodeObjects::Base
-        obj = code_object_map[path]
-        obj if obj&.is_a?(klass)
-      end
-
-      # @return [Array<String>]
-      def code_object_paths
-        code_object_map.keys
-      end
-
-      # @param store [ApiMap::Store] ApiMap pin store
-      # @return [void]
-      def rake_yard store
-        YARD::Registry.clear
-        code_object_map.clear
-        store.namespace_pins.each do |pin|
-          next if pin.path.nil? || pin.path.empty?
-          if pin.code_object
-            code_object_map[pin.path] ||= pin.code_object
-            next
-          end
-          if pin.type == :class
-            # @param obj [YARD::CodeObjects::RootObject]
-            code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path) { |obj|
-              next if pin.location.nil? || pin.location.filename.nil?
-              obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
-            }
-          else
-            # @param obj [YARD::CodeObjects::RootObject]
-            code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) { |obj|
-              next if pin.location.nil? || pin.location.filename.nil?
-              obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
-            }
-          end
-          code_object_map[pin.path].docstring = pin.docstring
-          store.get_includes(pin.path).each do |ref|
-            include_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
-            unless include_object.nil? || include_object.nil?
-              include_object.instance_mixins.push code_object_map[ref.type.to_s]
-            end
-          end
-          store.get_extends(pin.path).each do |ref|
-            extend_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
-            next unless extend_object
-            code_object = code_object_map[ref.type.to_s]
-            next unless code_object
-            extend_object.class_mixins.push code_object
-            # @todo add spec showing why this next line is necessary
-            extend_object.instance_mixins.push code_object
-          end
-        end
-        store.method_pins.each do |pin|
-          if pin.code_object
-            code_object_map[pin.path] ||= pin.code_object
-            next
-          end
-
-          # @param obj [YARD::CodeObjects::RootObject]
-          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace, YARD::CodeObjects::NamespaceObject), pin.name, pin.scope) { |obj|
-            next if pin.location.nil? || pin.location.filename.nil?
-            obj.add_file pin.location.filename, pin.location.range.start.line
-          }
-          method_object = code_object_at(pin.path, YARD::CodeObjects::MethodObject)
-          method_object.docstring = pin.docstring
-          method_object.visibility = pin.visibility || :public
-          method_object.parameters = pin.parameters.map do |p|
-            [p.full_name, p.asgn_code]
-          end
-        end
-      end
-
-      private
-
-      # @return [Hash{String => YARD::CodeObjects::Base}]
-      def code_object_map
-        @code_object_map ||= {}
-      end
-
-      # @return [YARD::CodeObjects::RootObject]
-      def root_code_object
-        @root_code_object ||= YARD::CodeObjects::RootObject.new(nil, 'root')
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class ApiMap
+    module SourceToYard
+      # Get the YARD CodeObject at the specified path.
+      #
+      # @sg-ignore Declared return type generic<T>, nil does not match
+      #   inferred type ::YARD::CodeObjects::Base, nil for
+      #   Solargraph::ApiMap::SourceToYard#code_object_at
+      # @generic T
+      # @param path [String]
+      # @param klass [Class<generic<T>>]
+      # @return [generic<T>, nil]
+      def code_object_at path, klass = YARD::CodeObjects::Base
+        obj = code_object_map[path]
+        obj if obj.is_a?(klass)
+      end
+
+      # @return [Array<String>]
+      def code_object_paths
+        code_object_map.keys
+      end
+
+      # @param store [ApiMap::Store] ApiMap pin store
+      # @return [void]
+      def rake_yard store
+        YARD::Registry.clear
+        code_object_map.clear
+        store.namespace_pins.each do |pin|
+          next if pin.path.nil? || pin.path.empty?
+          if pin.code_object
+            code_object_map[pin.path] ||= pin.code_object
+            next
+          end
+          if pin.type == :class
+            # @param obj [YARD::CodeObjects::RootObject]
+            code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path) do |obj|
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              next if pin.location.nil? || pin.location.filename.nil?
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
+            end
+          else
+            # @param obj [YARD::CodeObjects::RootObject]
+            code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) do |obj|
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              next if pin.location.nil? || pin.location.filename.nil?
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
+            end
+          end
+          code_object_map[pin.path].docstring = pin.docstring
+          store.get_includes(pin.path).each do |ref|
+            include_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
+            unless include_object.nil? || include_object.nil?
+              include_object.instance_mixins.push code_object_map[ref.type.to_s]
+            end
+          end
+          store.get_extends(pin.path).each do |ref|
+            extend_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
+            next unless extend_object
+            code_object = code_object_map[ref.type.to_s]
+            next unless code_object
+            extend_object.class_mixins.push code_object
+            extend_object.instance_mixins.push code_object
+          end
+        end
+        store.method_pins.each do |pin|
+          if pin.code_object
+            code_object_map[pin.path] ||= pin.code_object
+            next
+          end
+
+          # @sg-ignore Need to add nil check here
+          # @param obj [YARD::CodeObjects::RootObject]
+          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(
+            code_object_at(pin.namespace, YARD::CodeObjects::NamespaceObject), pin.name, pin.scope
+          ) do |obj|
+            # @sg-ignore flow sensitive typing needs to handle attrs
+            next if pin.location.nil? || pin.location.filename.nil?
+            # @sg-ignore flow sensitive typing needs to handle attrs
+            obj.add_file pin.location.filename, pin.location.range.start.line
+          end
+          method_object = code_object_at(pin.path, YARD::CodeObjects::MethodObject)
+          # @sg-ignore Need to add nil check here
+          method_object.docstring = pin.docstring
+          # @sg-ignore Need to add nil check here
+          method_object.visibility = pin.visibility || :public
+          # @sg-ignore Need to add nil check here
+          method_object.parameters = pin.parameters.map do |p|
+            [p.full_name, p.asgn_code]
+          end
+        end
+      end
+
+      private
+
+      # @return [Hash{String => YARD::CodeObjects::Base}]
+      def code_object_map
+        @code_object_map ||= {}
+      end
+
+      # @return [YARD::CodeObjects::RootObject]
+      def root_code_object
+        @root_code_object ||= YARD::CodeObjects::RootObject.new(nil, 'root')
+      end
+    end
+  end
+end