solargraph 0.56.0 → 0.58.2

data/lib/solargraph/source_map.rb

@@ -1,200 +1,212 @@
-# frozen_string_literal: true
-
-require 'yard'
-require 'solargraph/yard_tags'
-
-module Solargraph
-  # An index of Pins and other ApiMap-related data for a single Source
-  # that can be queried.
-  #
-  class SourceMap
-    autoload :Mapper,        'solargraph/source_map/mapper'
-    autoload :Clip,          'solargraph/source_map/clip'
-    autoload :Completion,    'solargraph/source_map/completion'
-    autoload :Data,          'solargraph/source_map/data'
-
-    # @return [Source]
-    attr_reader :source
-
-    # @return [Array<Pin::Base>]
-    def pins
-      data.pins
-    end
-
-    # @return [Array<Pin::LocalVariable>]
-    def locals
-      data.locals
-    end
-
-    # @param source [Source]
-    def initialize source
-      @source = source
-
-      environ.merge Convention.for_local(self) unless filename.nil?
-      self.convention_pins = environ.pins
-      @pin_select_cache = {}
-    end
-
-    # @param klass [Class]
-    # @return [Array<Pin::Base>]
-    def pins_by_class klass
-      @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
-    end
-
-    # A hash representing the state of the source map's API.
-    #
-    # ApiMap#catalog uses this value to determine whether it needs to clear its
-    # cache.
-    #
-    # @return [Integer]
-    def api_hash
-      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
-    end
-
-    # @return [String]
-    def filename
-      source.filename
-    end
-
-    # @return [String]
-    def code
-      source.code
-    end
-
-    # @return [Array<Pin::Reference::Require>]
-    def requires
-      pins_by_class(Pin::Reference::Require)
-    end
-
-    # @return [Environ]
-    def environ
-      @environ ||= Environ.new
-    end
-
-    # all pins except Solargraph::Pin::Reference::Reference
-    # @return [Array<Pin::Base>]
-    def document_symbols
-      @document_symbols ||= (pins + convention_pins).select do |pin|
-        pin.path && !pin.path.empty?
-      end
-    end
-
-    # @param query [String]
-    # @return [Array<Pin::Base>]
-    def query_symbols query
-      Pin::Search.new(document_symbols, query).results
-    end
-
-    # @param position [Position]
-    # @return [Source::Cursor]
-    def cursor_at position
-      Source::Cursor.new(source, position)
-    end
-
-    # @param path [String]
-    # @return [Pin::Base]
-    def first_pin path
-      pins.select { |p| p.path == path }.first
-    end
-
-    # @param location [Solargraph::Location]
-    # @return [Array<Solargraph::Pin::Base>]
-    def locate_pins location
-      # return nil unless location.start_with?("#{filename}:")
-      (pins + locals).select { |pin| pin.location == location }
-    end
-
-    # @param line [Integer]
-    # @param character [Integer]
-    # @return [Pin::Method,Pin::Namespace]
-    def locate_named_path_pin line, character
-      _locate_pin line, character, Pin::Namespace, Pin::Method
-    end
-
-    # @param line [Integer]
-    # @param character [Integer]
-    # @return [Pin::Namespace,Pin::Method,Pin::Block]
-    def locate_block_pin line, character
-      _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
-    end
-
-    # @param name [String]
-    # @return [Array<Location>]
-    def references name
-      source.references name
-    end
-
-    # @param location [Location]
-    # @return [Array<Pin::LocalVariable>]
-    def locals_at(location)
-      return [] if location.filename != filename
-      closure = locate_named_path_pin(location.range.start.line, location.range.start.character)
-      locals.select { |pin| pin.visible_at?(closure, location) }
-    end
-
-    class << self
-      # @param filename [String]
-      # @return [SourceMap]
-      def load filename
-        source = Solargraph::Source.load(filename)
-        SourceMap.map(source)
-      end
-
-      # @param code [String]
-      # @param filename [String, nil]
-      # @return [SourceMap]
-      def load_string code, filename = nil
-        source = Solargraph::Source.load_string(code, filename)
-        SourceMap.map(source)
-      end
-
-      # @deprecated
-      # @param source [Source]
-      # @return [SourceMap]
-      def map source
-        new(source)
-      end
-    end
-
-    private
-
-    def pin_class_hash
-      @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
-    end
-
-    def data
-      @data ||= Data.new(source)
-    end
-
-    # @return [Array<Pin::Base>]
-    def convention_pins
-      @convention_pins || []
-    end
-
-    # @param pins [Array<Pin::Base>]
-    # @return [Array<Pin::Base>]
-    def convention_pins=(pins)
-      # unmemoizing the document_symbols in case it was called from any of conventions
-      @document_symbols = nil
-      @convention_pins = pins
-    end
-
-    # @param line [Integer]
-    # @param character [Integer]
-    # @param klasses [Array<Class>]
-    # @return [Pin::Base, nil]
-    def _locate_pin line, character, *klasses
-      position = Position.new(line, character)
-      found = nil
-      pins.each do |pin|
-        # @todo Attribute pins should not be treated like closures, but
-        #   there's probably a better way to handle it
-        next if pin.is_a?(Pin::Method) && pin.attribute?
-        found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
-        break if pin.location.range.start.line > line
-      end
-      # Assuming the root pin is always valid
-      found || pins.first
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'yard'
+require 'solargraph/yard_tags'
+
+module Solargraph
+  # An index of Pins and other ApiMap-related data for a single Source
+  # that can be queried.
+  #
+  class SourceMap
+    autoload :Mapper,        'solargraph/source_map/mapper'
+    autoload :Clip,          'solargraph/source_map/clip'
+    autoload :Completion,    'solargraph/source_map/completion'
+    autoload :Data,          'solargraph/source_map/data'
+
+    # @return [Source]
+    attr_reader :source
+
+    # @return [Array<Pin::Base>]
+    def pins
+      data.pins
+    end
+
+    # @return [Array<Pin::Base>]
+    def all_pins
+      pins + convention_pins
+    end
+
+    # @return [Array<Pin::LocalVariable>]
+    def locals
+      data.locals
+    end
+
+    # @param source [Source]
+    def initialize source
+      @source = source
+
+      conventions_environ.merge Convention.for_local(self) unless filename.nil?
+      # FIXME: unmemoizing the document_symbols in case it was called and memoized from any of conventions above
+      # this is to ensure that the convention_pins from all conventions are used in the document_symbols.
+      # solargraph-rails is known to use this method to get the document symbols. It should probably be removed.
+      @document_symbols = nil
+      self.convention_pins = conventions_environ.pins
+      # @type [Hash{Class<Pin::Base> => Array<Pin::Base>}]
+      @pin_select_cache = {}
+    end
+
+    # @generic T
+    # @param klass [Class<generic<T>>]
+    #
+    # @return [Array<generic<T>>]
+    def pins_by_class klass
+      @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
+    end
+
+    # A hash representing the state of the source map's API.
+    #
+    # ApiMap#catalog uses this value to determine whether it needs to clear its
+    # cache.
+    #
+    # @return [Integer]
+    def api_hash
+      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
+    end
+
+    # @return [String]
+    def filename
+      source.filename
+    end
+
+    # @return [String]
+    def code
+      source.code
+    end
+
+    # @return [Array<Pin::Reference::Require>]
+    def requires
+      pins_by_class(Pin::Reference::Require)
+    end
+
+    # @return [Environ]
+    def conventions_environ
+      @conventions_environ ||= Environ.new
+    end
+
+    # all pins except Solargraph::Pin::Reference::Reference
+    # @return [Array<Pin::Base>]
+    def document_symbols
+      @document_symbols ||= (pins + convention_pins).select do |pin|
+        pin.path && !pin.path.empty?
+      end
+    end
+
+    # @param query [String]
+    # @return [Array<Pin::Base>]
+    def query_symbols query
+      Pin::Search.new(document_symbols, query).results
+    end
+
+    # @param position [Position]
+    # @return [Source::Cursor]
+    def cursor_at position
+      Source::Cursor.new(source, position)
+    end
+
+    # @param path [String]
+    # @return [Pin::Base]
+    def first_pin path
+      pins.select { |p| p.path == path }.first
+    end
+
+    # @param location [Solargraph::Location]
+    # @return [Array<Solargraph::Pin::Base>]
+    def locate_pins location
+      # return nil unless location.start_with?("#{filename}:")
+      (pins + locals).select { |pin| pin.location == location }
+    end
+
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Pin::Method,Pin::Namespace]
+    def locate_named_path_pin line, character
+      _locate_pin line, character, Pin::Namespace, Pin::Method
+    end
+
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Pin::Namespace,Pin::Method,Pin::Block]
+    def locate_closure_pin line, character
+      _locate_pin line, character, Pin::Closure
+    end
+
+    # @deprecated Please use locate_closure_pin instead
+    alias locate_block_pin locate_closure_pin
+
+    # @param name [String]
+    # @return [Array<Location>]
+    def references name
+      source.references name
+    end
+
+    # @param location [Location]
+    # @return [Array<Pin::LocalVariable>]
+    def locals_at(location)
+      return [] if location.filename != filename
+      closure = locate_named_path_pin(location.range.start.line, location.range.start.character)
+      locals.select { |pin| pin.visible_at?(closure, location) }
+    end
+
+    class << self
+      # @param filename [String]
+      # @return [SourceMap]
+      def load filename
+        source = Solargraph::Source.load(filename)
+        SourceMap.map(source)
+      end
+
+      # @param code [String]
+      # @param filename [String, nil]
+      # @return [SourceMap]
+      def load_string code, filename = nil
+        source = Solargraph::Source.load_string(code, filename)
+        SourceMap.map(source)
+      end
+
+      # @deprecated
+      # @param source [Source]
+      # @return [SourceMap]
+      def map source
+        new(source)
+      end
+    end
+
+    private
+
+    # @return [Array<Pin::Base>]
+    attr_writer :convention_pins
+
+    # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
+    def pin_class_hash
+      @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
+    end
+
+    # @return [Data]
+    def data
+      @data ||= Data.new(source)
+    end
+
+    # @return [Array<Pin::Base>]
+    def convention_pins
+      @convention_pins || []
+    end
+
+    # @param line [Integer]
+    # @param character [Integer]
+    # @param klasses [Array<Class>]
+    # @return [Pin::Base, nil]
+    def _locate_pin line, character, *klasses
+      position = Position.new(line, character)
+      found = nil
+      pins.each do |pin|
+        # @todo Attribute pins should not be treated like closures, but
+        #   there's probably a better way to handle it
+        next if pin.is_a?(Pin::Method) && pin.attribute?
+        found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
+        break if pin.location.range.start.line > line
+      end
+      # Assuming the root pin is always valid
+      found || pins.first
+    end
+  end
+end

data/lib/solargraph/type_checker/checks.rb

@@ -1,124 +1,124 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class TypeChecker
-    # Helper methods for performing type checks
-    #
-    module Checks
-      module_function
-
-      # Compare an expected type with an inferred type. Common usage is to
-      # check if the type declared in a method's @return tag matches the type
-      # inferred from static analysis of the code.
-      #
-      # @param api_map [ApiMap]
-      # @param expected [ComplexType]
-      # @param inferred [ComplexType]
-      # @return [Boolean]
-      def types_match? api_map, expected, inferred
-        return true if expected.to_s == inferred.to_s
-        matches = []
-        expected.each do |exp|
-          found = false
-          inferred.each do |inf|
-            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
-            if either_way?(api_map, inf, exp)
-              found = true
-              matches.push inf
-              break
-            end
-          end
-          return false unless found
-        end
-        inferred.each do |inf|
-          next if matches.include?(inf)
-          found = false
-          expected.each do |exp|
-            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
-            if either_way?(api_map, inf, exp)
-              found = true
-              break
-            end
-          end
-          return false unless found
-        end
-        true
-      end
-
-      # @param api_map [ApiMap]
-      # @param expected [ComplexType]
-      # @param inferred [ComplexType]
-      # @return [Boolean]
-      def any_types_match? api_map, expected, inferred
-        expected = expected.downcast_to_literal_if_possible
-        inferred = inferred.downcast_to_literal_if_possible
-        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
-        # walk through the union expected type and see if any members
-        # of the union match the inferred type
-        expected.each do |exp|
-          next if exp.duck_type?
-          # @todo: there should be a level of typechecking where all
-          #   unique types in the inferred must match one of the
-          #   expected unique types
-          inferred.each do |inf|
-            # return true if exp == inf || api_map.super_and_sub?(fuzz(inf), fuzz(exp))
-            return true if exp == inf || either_way?(api_map, inf, exp)
-          end
-        end
-        false
-      end
-
-      # @param api_map [ApiMap]
-      # @param inferred [ComplexType]
-      # @param expected [ComplexType]
-      # @return [Boolean]
-      def all_types_match? api_map, inferred, expected
-        expected = expected.downcast_to_literal_if_possible
-        inferred = inferred.downcast_to_literal_if_possible
-        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
-        inferred.each do |inf|
-          next if inf.duck_type?
-          return false unless expected.any? { |exp| exp == inf || either_way?(api_map, inf, exp) }
-        end
-        true
-      end
-
-      # @param api_map [ApiMap]
-      # @param expected [ComplexType]
-      # @param inferred [ComplexType]
-      # @return [Boolean]
-      def duck_types_match? api_map, expected, inferred
-        raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
-        expected.each do |exp|
-          next unless exp.duck_type?
-          quack = exp.to_s[1..-1]
-          return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
-        end
-        true
-      end
-
-      # @param type [ComplexType::UniqueType]
-      # @return [String]
-      def fuzz type
-        if type.parameters?
-          type.name
-        else
-          type.tag
-        end
-      end
-
-      # @param api_map [ApiMap]
-      # @param cls1 [ComplexType::UniqueType]
-      # @param cls2 [ComplexType::UniqueType]
-      # @return [Boolean]
-      def either_way?(api_map, cls1, cls2)
-        # @todo there should be a level of typechecking which uses the
-        #   full tag with parameters to determine compatibility
-        f1 = cls1.name
-        f2 = cls2.name
-        api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
-        # api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class TypeChecker
+    # Helper methods for performing type checks
+    #
+    module Checks
+      module_function
+
+      # Compare an expected type with an inferred type. Common usage is to
+      # check if the type declared in a method's @return tag matches the type
+      # inferred from static analysis of the code.
+      #
+      # @param api_map [ApiMap]
+      # @param expected [ComplexType]
+      # @param inferred [ComplexType]
+      # @return [Boolean]
+      def types_match? api_map, expected, inferred
+        return true if expected.to_s == inferred.to_s
+        matches = []
+        expected.each do |exp|
+          found = false
+          inferred.each do |inf|
+            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
+            if either_way?(api_map, inf, exp)
+              found = true
+              matches.push inf
+              break
+            end
+          end
+          return false unless found
+        end
+        inferred.each do |inf|
+          next if matches.include?(inf)
+          found = false
+          expected.each do |exp|
+            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
+            if either_way?(api_map, inf, exp)
+              found = true
+              break
+            end
+          end
+          return false unless found
+        end
+        true
+      end
+
+      # @param api_map [ApiMap]
+      # @param expected [ComplexType]
+      # @param inferred [ComplexType]
+      # @return [Boolean]
+      def any_types_match? api_map, expected, inferred
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
+        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+        # walk through the union expected type and see if any members
+        # of the union match the inferred type
+        expected.each do |exp|
+          next if exp.duck_type?
+          # @todo: there should be a level of typechecking where all
+          #   unique types in the inferred must match one of the
+          #   expected unique types
+          inferred.each do |inf|
+            # return true if exp == inf || api_map.super_and_sub?(fuzz(inf), fuzz(exp))
+            return true if exp == inf || either_way?(api_map, inf, exp)
+          end
+        end
+        false
+      end
+
+      # @param api_map [ApiMap]
+      # @param inferred [ComplexType]
+      # @param expected [ComplexType]
+      # @return [Boolean]
+      def all_types_match? api_map, inferred, expected
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
+        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+        inferred.each do |inf|
+          next if inf.duck_type?
+          return false unless expected.any? { |exp| exp == inf || either_way?(api_map, inf, exp) }
+        end
+        true
+      end
+
+      # @param api_map [ApiMap]
+      # @param expected [ComplexType]
+      # @param inferred [ComplexType]
+      # @return [Boolean]
+      def duck_types_match? api_map, expected, inferred
+        raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
+        expected.each do |exp|
+          next unless exp.duck_type?
+          quack = exp.to_s[1..-1]
+          return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
+        end
+        true
+      end
+
+      # @param type [ComplexType::UniqueType]
+      # @return [String]
+      def fuzz type
+        if type.parameters?
+          type.name
+        else
+          type.tag
+        end
+      end
+
+      # @param api_map [ApiMap]
+      # @param cls1 [ComplexType::UniqueType]
+      # @param cls2 [ComplexType::UniqueType]
+      # @return [Boolean]
+      def either_way?(api_map, cls1, cls2)
+        # @todo there should be a level of typechecking which uses the
+        #   full tag with parameters to determine compatibility
+        f1 = cls1.name
+        f2 = cls2.name
+        api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
+        # api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
+      end
+    end
+  end
+end