solargraph 0.39.7

data/lib/solargraph/source/chain/global_variable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class GlobalVariable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_global_variable_pins.select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/head.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
+      # either a class (`String`) or a function (`Kernel#String`).
+      #
+      # @note Chain::Head is only intended to handle `self` and `super`.
+      class Head < Link
+        def resolve api_map, name_pin, locals
+          return [Pin::ProxyType.anonymous(name_pin.binder)] if word == 'self'
+          # return super_pins(api_map, name_pin) if word == 'super'
+          []
+        end
+
+        # @todo This is temporary. Chain heads need to handle arguments to
+        #   `super`.
+        # def arguments
+        #   []
+        # end
+
+        private
+
+        # # @param api_map [ApiMap]
+        # # @param name_pin [Pin::Base]
+        # # @return [Array<Pin::Base>]
+        # def super_pins api_map, name_pin
+        #   pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+        #   pins.reject{|p| p.path == name_pin.path}
+        # end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/instance_variable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class InstanceVariable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_instance_variable_pins(name_pin.binder.namespace, name_pin.binder.scope).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/link.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Link
+        # @return [String]
+        attr_reader :word
+
+        attr_accessor :last_context
+
+        def initialize word = '<undefined>'
+          @word = word
+        end
+
+        def undefined?
+          word == '<undefined>'
+        end
+
+        def constant?
+          is_a?(Chain::Constant)
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        # @return [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          []
+        end
+
+        def head?
+          @head ||= false
+        end
+
+        def == other
+          self.class == other.class and word == other.word
+        end
+
+        # Make a copy of this link marked as the head of a chain
+        #
+        # @return [self]
+        def clone_head
+          clone.mark_head(true)
+        end
+
+        # Make a copy of this link unmarked as the head of a chain
+        #
+        # @return [self]
+        def clone_body
+          clone.mark_head(false)
+        end
+
+        protected
+
+        # Mark whether this link is the head of a chain
+        #
+        # @param bool [Boolean]
+        # @return [self]
+        def mark_head bool
+          @head = bool
+          self
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/literal.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Literal < Link
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        # @param type [String]
+        def initialize type
+          @type = type
+          @complex_type = ComplexType.try_parse(type)
+        end
+
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(@complex_type)]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/or.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Or < Link
+        def word
+          '<or>'
+        end
+
+        # @param type [String]
+        def initialize links
+          @links = links
+        end
+
+        def resolve api_map, name_pin, locals
+          types = @links.map { |link| link.infer(api_map, name_pin, locals) }
+          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.try_parse(types.map(&:tag).uniq.join(', ')))]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/variable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Variable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/z_super.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class ZSuper < Call
+        # @return [String]
+        attr_reader :word
+
+        # @return [Array<Chain>]
+        attr_reader :arguments
+
+        # @param word [String]
+        # @param arguments [Array<Chain>]
+        # @param with_block [Boolean] True if the chain is inside a block
+        # @param head [Boolean] True if the call is the start of its chain
+        def initialize word, with_block = false
+          super(word, [], with_block)
+        end
+
+        def with_block?
+          @with_block
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          return super_pins(api_map, name_pin)
+        end
+
+        private
+
+        # @param pins [Array<Pin::Base>]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::LocalVariable]
+        # @return [Array<Pin::Base>]
+        def inferred_pins pins, api_map, context, locals
+          result = pins.map do |p|
+            overloads = p.docstring.tags(:overload)
+            # next p if overloads.empty?
+            type = ComplexType::UNDEFINED
+            # @param [YARD::Tags::OverloadTag]
+            overloads.each do |ol|
+              next unless arguments_match(arguments, ol.parameters)
+              next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
+              match = true
+              arguments.each_with_index do |arg, idx|
+                achain = arguments[idx]
+                next if achain.nil?
+                param = ol.parameters[idx]
+                if param.nil?
+                  match = false unless ol.parameters.last && ol.parameters.last.first.start_with?('*')
+                  break
+                end
+                par = ol.tags(:param).select { |pp| pp.name == param.first }.first
+                next if par.nil? || par.types.nil? || par.types.empty?
+                atype = achain.infer(api_map, Pin::ProxyType.anonymous(context), locals)
+                other = ComplexType.try_parse(*par.types)
+                # @todo Weak type comparison
+                unless atype.tag == other.tag || api_map.super_and_sub?(other.tag, atype.tag)
+                  match = false
+                  break
+                end
+              end
+              if match
+                type = extra_return_type(ol, context)
+                type = ComplexType.try_parse(*ol.tag(:return).types).self_to(context.to_s).qualify(api_map, context.namespace) if ol.has_tag?(:return) && ol.tag(:return).types && !ol.tag(:return).types.empty? && (type.nil? || type.undefined?)
+                type ||= ComplexType::UNDEFINED
+              end
+              break if type.defined?
+            end
+            next p.proxy(type) if type.defined?
+            type = extra_return_type(p.docstring, context)
+            if type
+              next Solargraph::Pin::Method.new(
+                location: p.location,
+                closure: p.closure,
+                name: p.name,
+                comments: "@return [#{context.subtypes.first.to_s}]",
+                scope: p.scope,
+                visibility: p.visibility,
+                parameters: p.parameters,
+                node: p.node
+              )
+            end
+            if p.is_a?(Pin::Method) && !p.macros.empty?
+              result = process_macro(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
+            elsif !p.directives.empty?
+              result = process_directive(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
+            end
+            p
+          end
+          result.map do |pin|
+            next pin if pin.return_type.undefined?
+            selfy = pin.return_type.self_to(context.tag)
+            selfy == pin.return_type ? pin : pin.proxy(selfy)
+          end
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::Base]
+        # @return [Pin::Base]
+        def process_macro pin, api_map, context, locals
+          pin.macros.each do |macro|
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::Base]
+        # @return [Pin::ProxyType]
+        def process_directive pin, api_map, context, locals
+          pin.directives.each do |dir|
+            macro = api_map.named_macro(dir.tag.name)
+            next if macro.nil?
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous ComplexType::UNDEFINED
+        end
+
+        # @param pin [Pin]
+        # @param macro [YARD::Tags::MacroDirective]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Array<Pin::Base>]
+        # @return [Pin::ProxyType]
+        def inner_process_macro pin, macro, api_map, context, locals
+          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
+          txt = macro.tag.text.clone
+          if txt.empty? && macro.tag.name
+            named = api_map.named_macro(macro.tag.name)
+            txt = named.tag.text.clone if named
+          end
+          i = 1
+          vals.each do |v|
+            txt.gsub!(/\$#{i}/, v.context.namespace)
+            i += 1
+          end
+          docstring = Solargraph::Source.parse_docstring(txt).to_docstring
+          tag = docstring.tag(:return)
+          unless tag.nil? || tag.types.nil?
+            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types))
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+        end
+
+        # @param docstring [YARD::Docstring]
+        # @param context [ComplexType]
+        # @return [ComplexType]
+        def extra_return_type docstring, context
+          if docstring.has_tag?(:return_single_parameter) && context.subtypes.one?
+            return context.subtypes.first
+          elsif docstring.has_tag?(:return_value_parameter) && context.value_types.one?
+            return context.value_types.first
+          end
+          nil
+        end
+
+        # @param arguments [Array<Chain>]
+        # @param parameters [Array<String>]
+        # @return [Boolean]
+        def arguments_match arguments, parameters
+          argcount = arguments.length
+          # argcount -= 1 if !arguments.empty? && arguments.last.links.first.word.start_with?('&')
+          parcount = parameters.length
+          parcount -= 1 if !parameters.empty? && parameters.last.first.start_with?('&')
+          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.first.start_with?('*'))
+          true
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/change.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    # A change to be applied to text.
+    #
+    class Change
+      include EncodingFixes
+
+      # @return [Range]
+      attr_reader :range
+
+      # @return [String]
+      attr_reader :new_text
+
+      # @param range [Range] The starting and ending positions of the change.
+      #   If nil, the original text will be overwritten.
+      # @param new_text [String] The text to be changed.
+      def initialize range, new_text
+        @range = range
+        @new_text = new_text
+      end
+
+      # Write the change to the specified text.
+      #
+      # @param text [String] The text to be changed.
+      # @param nullable [Boolean] If true, minor changes that could generate
+      #   syntax errors will be repaired.
+      # @return [String] The updated text.
+      def write text, nullable = false
+        if nullable and !range.nil? and new_text.match(/[\.\[\{\(@\$:]$/)
+          [':', '@'].each do |dupable|
+            next unless new_text == dupable
+            offset = Position.to_offset(text, range.start)
+            if text[offset - 1] == dupable
+              p = Position.from_offset(text, offset - 1)
+              r = Change.new(Range.new(p, range.start), ' ')
+              text = r.write(text)
+            end
+            break
+          end
+          commit text, "#{new_text[0..-2]} "
+        elsif range.nil?
+          new_text
+        else
+          commit text, new_text
+        end
+      end
+
+      # Repair an update by replacing the new text with similarly formatted
+      # whitespace.
+      #
+      # @param text [String] The text to be changed.
+      # @return [String] The updated text.
+      def repair text
+        fixed = new_text.gsub(/[^\s]/, ' ')
+        if range.nil?
+          fixed
+        else
+          result = commit text, fixed
+          off = Position.to_offset(text, range.start)
+          match = result[0, off].match(/[\.:]+\z/)
+          if match
+            result = result[0, off].sub(/#{match[0]}\z/, ' ' * match[0].length) + result[off..-1]
+          end
+          result
+        end
+      end
+
+      private
+
+      def commit text, insert
+        start_offset = Position.to_offset(text, range.start)
+        end_offset = Position.to_offset(text, range.ending)
+        (start_offset == 0 ? '' : text[0..start_offset-1].to_s) + normalize(insert) + text[end_offset..-1].to_s
+      end
+    end
+  end
+end