solargraph 0.54.4 → 0.57.0

data/lib/solargraph/api_map/index.rb

@@ -3,8 +3,10 @@
 module Solargraph
   class ApiMap
     class Index
+      include Logging
+
       # @param pins [Array<Pin::Base>]
-      def initialize pins
+      def initialize pins = []
         catalog pins
       end
 
@@ -13,6 +15,9 @@ module Solargraph
         @pins ||= []
       end
 
+      # @return [Set<String>]
+      attr_reader :namespaces
+
       # @return [Hash{String => Array<Pin::Namespace>}]
       def namespace_hash
         @namespace_hash ||= Hash.new { |h, k| h[k] = [] }
@@ -34,30 +39,37 @@ module Solargraph
       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<Pin::Reference::Include>}]
+      # @return [Hash{String => Array<String>}]
       def include_references
         @include_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<Pin::Reference::Extend>}]
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
+      def include_reference_pins
+        @include_reference_pins ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<String>}]
       def extend_references
         @extend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<Pin::Reference::Prepend>}]
+      # @return [Hash{String => Array<String>}]
       def prepend_references
         @prepend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<Pin::Reference::Superclass>}]
+      # @return [Hash{String => Array<String>}]
       def superclass_references
         @superclass_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @param pins [Array<Pin::Base>]
+      # @param pins [Enumerable<Pin::Base>]
+      # @return [self]
       def merge pins
         deep_clone.catalog pins
       end
@@ -67,6 +79,7 @@ module Solargraph
       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 = {}
@@ -81,8 +94,10 @@ module Solargraph
         end
       end
 
-      # @param new_pins [Array<Pin::Base>]
+      # @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
@@ -106,47 +121,31 @@ module Solargraph
       # @return [void]
       def map_references klass, hash
         pins_by_class(klass).each do |pin|
-          store_parametric_reference(hash, pin)
+          hash[pin.namespace].push pin
         end
       end
 
-      # Add references to a map
-      #
-      # @param hash [Hash{String => Array<Pin::Reference>}]
-      # @param reference_pin [Pin::Reference]
-      #
-      # @return [void]
-      def store_parametric_reference(hash, reference_pin)
-        referenced_ns = reference_pin.name
-        referenced_tag_params = reference_pin.generic_values
-        referenced_tag = referenced_ns +
-                         if referenced_tag_params && referenced_tag_params.length > 0
-                           "<" + referenced_tag_params.join(', ') + ">"
-                         else
-                           ''
-                         end
-        referencing_ns = reference_pin.namespace
-        hash[referencing_ns].push referenced_tag
-      end
-
       # @return [void]
       def map_overrides
         pins_by_class(Pin::Reference::Override).each do |ovr|
-          pin = path_pin_hash[ovr.name].first
-          next if pin.nil?
-          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
+          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
@@ -156,11 +155,14 @@ module Solargraph
       # @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

data/lib/solargraph/api_map/source_to_yard.rb

@@ -45,12 +45,18 @@ module Solargraph
           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)
-            include_object.instance_mixins.push code_object_map[ref] unless include_object.nil? or include_object.nil?
+            unless include_object.nil? || include_object.nil?
+              include_object.instance_mixins.push code_object_map[ref.parametrized_tag.to_s]
+            end
           end
           store.get_extends(pin.path).each do |ref|
             extend_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
-            extend_object.instance_mixins.push code_object_map[ref] unless extend_object.nil? or extend_object.nil?
-            extend_object.class_mixins.push code_object_map[ref] unless extend_object.nil? or extend_object.nil?
+            next unless extend_object
+            code_object = code_object_map[ref.parametrized_tag.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|
@@ -67,7 +73,7 @@ module Solargraph
           method_object.docstring = pin.docstring
           method_object.visibility = pin.visibility || :public
           method_object.parameters = pin.parameters.map do |p|
-            [p.name, p.asgn_code]
+            [p.full_name, p.asgn_code]
           end
         end
       end

data/lib/solargraph/api_map/store.rb

@@ -1,18 +1,15 @@
 # frozen_string_literal: true
 
-
 module Solargraph
   class ApiMap
     # Queryable collection of Pins representing a Workspace, gems and the Ruby
     # core.
     #
     class Store
-      # @param static [Enumerable<Pin::Base>]
-      # @param dynamic [Enumerable<Pin::Base>]
-      def initialize static = [], dynamic = []
-        @static_index = Index.new(static)
-        @dynamic = dynamic
-        @index = @static_index.merge(dynamic)
+      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      def initialize *pinsets
+        @pinsets = pinsets
+        catalog pinsets
       end
 
       # @return [Array<Solargraph::Pin::Base>]
@@ -20,19 +17,34 @@ module Solargraph
         index.pins
       end
 
-      # @param static [Enumerable<Pin::Base>]
-      # @param dynamic [Enumerable<Pin::Base>]
-      def update! static = [], dynamic = []
+      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      #   - pinsets[0] = core Ruby pins
+      #   - pinsets[1] = documentation/gem pins
+      #   - pinsets[2] = convention pins
+      #   - pinsets[3] = workspace source pins
+      #   - pinsets[4] = currently open file pins
+      # @return [Boolean] True if the index was updated
+      def update *pinsets
+        return catalog(pinsets) if pinsets.length != @pinsets.length
+
+        changed = pinsets.find_index.with_index { |pinset, idx| @pinsets[idx] != pinset }
+        return false unless changed
+
         # @todo Fix this map
         @fqns_pins_map = nil
-        if @static_index.pins == static
-          return self if @dynamic == dynamic
-        else
-          @static_index = Index.new(static)
+        return catalog(pinsets) if changed == 0
+
+        pinsets[changed..].each_with_index do |pins, idx|
+          @pinsets[changed + idx] = pins
+          @indexes[changed + idx] = if pins.empty?
+            @indexes[changed + idx - 1]
+          else
+            @indexes[changed + idx - 1].merge(pins)
+          end
         end
-        @dynamic = dynamic
-        @index = @static_index.merge(dynamic)
-        self
+        constants.clear
+        cached_qualify_superclass.clear
+        true
       end
 
       def to_s
@@ -57,35 +69,51 @@ module Solargraph
       # @param visibility [Array<Symbol>]
       # @return [Enumerable<Solargraph::Pin::Method>]
       def get_methods fqns, scope: :instance, visibility: [:public]
-        namespace_children(fqns).select do |pin|
+        all_pins = namespace_children(fqns).select do |pin|
           pin.is_a?(Pin::Method) && pin.scope == scope && visibility.include?(pin.visibility)
         end
+        GemPins.combine_method_pins_by_path(all_pins)
       end
 
+      BOOLEAN_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Boolean', closure: Pin::ROOT_PIN, source: :solargraph)
+      OBJECT_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Object', closure: Pin::ROOT_PIN, source: :solargraph)
+
       # @param fqns [String]
-      # @return [String, nil]
+      # @return [Pin::Reference::Superclass]
       def get_superclass fqns
-        raise "Do not prefix fully qualified namespaces with '::' - #{fqns.inspect}" if fqns.start_with?('::')
-        return superclass_references[fqns].first if superclass_references.key?(fqns)
-        return 'Object' if fqns != 'BasicObject' && namespace_exists?(fqns)
-        return 'Object' if fqns == 'Boolean'
-        nil
+        return nil if fqns.nil? || fqns.empty?
+        return BOOLEAN_SUPERCLASS_PIN if %w[TrueClass FalseClass].include?(fqns)
+
+        superclass_references[fqns].first || try_special_superclasses(fqns)
+      end
+
+      # @param fq_sub_tag [String]
+      # @return [String, nil]
+      def qualify_superclass fq_sub_tag
+        cached_qualify_superclass[fq_sub_tag] || qualify_and_cache_superclass(fq_sub_tag)
+        type = ComplexType.try_parse(fq_sub_tag)
+        return type.simplify_literals.to_s if type.literal?
+        ref = get_superclass(fq_sub_tag)
+        return unless ref
+        res = constants.dereference(ref)
+        return unless res
+        res + type.substring
       end
 
       # @param fqns [String]
-      # @return [Array<String>]
+      # @return [Array<Pin::Reference::Include>]
       def get_includes fqns
         include_references[fqns] || []
       end
 
       # @param fqns [String]
-      # @return [Array<String>]
+      # @return [Array<Pin::Reference::Prepend>]
       def get_prepends fqns
         prepend_references[fqns] || []
       end
 
       # @param fqns [String]
-      # @return [Array<String>]
+      # @return [Array<Pin::Reference::Extend>]
       def get_extends fqns
         extend_references[fqns] || []
       end
@@ -108,7 +136,7 @@ module Solargraph
       # @param fqns [String]
       # @return [Enumerable<Solargraph::Pin::Base>]
       def get_class_variables(fqns)
-        namespace_children(fqns).select{|pin| pin.is_a?(Pin::ClassVariable)}
+        namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable)}
       end
 
       # @return [Enumerable<Solargraph::Pin::Base>]
@@ -188,9 +216,74 @@ module Solargraph
         fqns_pins_map[[base, name]]
       end
 
+      # Get all ancestors (superclasses, includes, prepends, extends) for a namespace
+      # @param fqns [String] The fully qualified namespace
+      # @return [Array<String>] Array of ancestor namespaces including the original
+      def get_ancestors(fqns)
+        return [] if fqns.nil? || fqns.empty?
+
+        ancestors = [fqns]
+        visited = Set.new
+        queue = [fqns]
+
+        until queue.empty?
+          current = queue.shift
+          next if current.nil? || current.empty? || visited.include?(current)
+          visited.add(current)
+
+          current = current.gsub(/^::/, '')
+
+          # Add superclass
+          ref = get_superclass(current)
+          superclass = ref && constants.dereference(ref)
+          if superclass && !superclass.empty? && !visited.include?(superclass)
+            ancestors << superclass
+            queue << superclass
+          end
+
+          # Add includes, prepends, and extends
+          [get_includes(current), get_prepends(current), get_extends(current)].each do |refs|
+            next if refs.nil?
+            refs.map(&:parametrized_tag).map(&:to_s).each do |ref|
+              next if ref.nil? || ref.empty? || visited.include?(ref)
+              ancestors << ref
+              queue << ref
+            end
+          end
+        end
+
+        ancestors.compact.uniq
+      end
+
+      # @return [Constants]
+      def constants
+        @constants ||= Constants.new(self)
+      end
+
       private
 
-      attr_reader :index
+      # @return [Index]
+      def index
+        @indexes.last
+      end
+
+      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      # @return [Boolean]
+      def catalog pinsets
+        @pinsets = pinsets
+        # @type [Array<Index>]
+        @indexes = []
+        pinsets.each do |pins|
+          if @indexes.last && pins.empty?
+            @indexes.push @indexes.last
+          else
+            @indexes.push(@indexes.last&.merge(pins) || Solargraph::ApiMap::Index.new(pins))
+          end
+        end
+        constants.clear
+        cached_qualify_superclass.clear
+        true
+      end
 
       # @return [Hash{::Array(String, String) => ::Array<Pin::Namespace>}]
       def fqns_pins_map
@@ -210,17 +303,22 @@ module Solargraph
         index.superclass_references
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
       def include_references
         index.include_references
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Solargraph::Pin::Reference::Include>}]
+      def include_reference_pins
+        index.include_reference_pins
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Prepend>}]
       def prepend_references
         index.prepend_references
       end
 
-      # @return [Hash{String => Array<String>}]
+      # @return [Hash{String => Array<Pin::Reference::Extend>}]
       def extend_references
         index.extend_references
       end
@@ -236,6 +334,41 @@ module Solargraph
       def all_instance_variables
         index.pins_by_class(Pin::InstanceVariable)
       end
+
+      # @param fqns [String]
+      # @return [Pin::Reference::Superclass, nil]
+      def try_special_superclasses(fqns)
+        return OBJECT_SUPERCLASS_PIN if fqns == 'Boolean'
+        return OBJECT_SUPERCLASS_PIN if !%w[BasicObject Object].include?(fqns) && namespace_exists?(fqns)
+
+        sub = ComplexType.try_parse(fqns)
+        return get_superclass(sub.simplify_literals.name) if sub.literal?
+
+        get_superclass(sub.namespace) if sub.namespace != fqns
+      end
+
+      # @param fq_sub_tag [String]
+      # @return [String, nil]
+      def qualify_and_cache_superclass fq_sub_tag
+        cached_qualify_superclass[fq_sub_tag] = uncached_qualify_superclass(fq_sub_tag)
+      end
+
+      # @return [Hash{String => String, nil}]
+      def cached_qualify_superclass
+        @cached_qualify_superclass ||= {}
+      end
+
+      # @param fq_sub_tag [String]
+      # @return [String, nil]
+      def uncached_qualify_superclass fq_sub_tag
+        type = ComplexType.try_parse(fq_sub_tag)
+        return type.simplify_literals.to_s if type.literal?
+        ref = get_superclass(fq_sub_tag)
+        return unless ref
+        res = constants.dereference(ref)
+        return unless res
+        res + type.substring
+      end
     end
   end
 end