solargraph 0.39.7

data/lib/solargraph/parser/rubyvm/node_processors/sclass_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class SclassNode < Parser::NodeProcessor::Base
+          def process
+            # @todo Temporarily skipping remote metaclasses
+            return unless node.children[0].is_a?(RubyVM::AbstractSyntaxTree::Node) && node.children[0].type == :SELF
+            pins.push Solargraph::Pin::Singleton.new(
+              location: get_node_location(node),
+              closure: region.closure
+            )
+            process_children region.update(visibility: :public, scope: :class, closure: pins.last)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/rubyvm/node_processors/scope_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class ScopeNode < Parser::NodeProcessor::Base
+          def process
+            process_children region.update(lvars: node.children[0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/rubyvm/node_processors/send_node.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class SendNode < Parser::NodeProcessor::Base
+          include Rubyvm::NodeMethods
+
+          def process
+            if [:private, :public, :protected].include?(node.children[0])
+              if node.type == :FCALL && Parser.is_ast_node?(node.children.last)
+                node.children.last.children[0..-2].each do |child|
+                  # next unless child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
+                  next unless child.type == :LIT || child.type == :STR
+                  name = child.children[0].to_s
+                  matches = pins.select{ |pin| pin.is_a?(Pin::BaseMethod) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
+                  matches.each do |pin|
+                    # @todo Smelly instance variable access
+                    pin.instance_variable_set(:@visibility, node.children[0])
+                  end
+                end
+              else
+                # @todo Smelly instance variable access
+                region.instance_variable_set(:@visibility, node.children[0])
+              end
+            elsif node.children[0] == :module_function
+              process_module_function
+            elsif node.children[0] == :require
+              process_require
+            elsif node.children[0] == :alias_method
+              process_alias_method
+            elsif node.children[0] == :private_class_method
+              # Processing a private class can potentially handle children on its own
+              return if process_private_class_method
+            elsif [:attr_reader, :attr_writer, :attr_accessor].include?(node.children[0])
+              process_attribute
+            elsif node.children[0] == :include
+              process_include
+            elsif node.children[0] == :extend
+              process_extend
+            elsif node.children[0] == :prepend
+              process_prepend
+            elsif node.children[0] == :private_constant
+              process_private_constant
+            elsif node.children[1] == :require && unpack_name(node.children[0]) == 'Bundler'
+              pins.push Pin::Reference::Require.new(Solargraph::Location.new(region.filename, Solargraph::Range.from_to(0, 0, 0, 0)), 'bundler/require')
+            end
+            process_children
+          end
+
+          private
+
+          # @return [void]
+          def process_attribute
+            return unless Parser.is_ast_node?(node.children[1])
+            node.children[1].children[0..-2].each do |a|
+              next unless a.type == :LIT
+              loc = get_node_location(node)
+              clos = region.closure
+              cmnt = comments_for(node)
+              if node.children[0] == :attr_reader || node.children[0] == :attr_accessor
+                pins.push Solargraph::Pin::Attribute.new(
+                  location: loc,
+                  closure: clos,
+                  name: a.children[0].to_s,
+                  comments: cmnt,
+                  access: :reader,
+                  scope: region.scope || :instance,
+                  visibility: region.visibility
+                )
+              end
+              if node.children[0] == :attr_writer || node.children[0] == :attr_accessor
+                pins.push Solargraph::Pin::Attribute.new(
+                  location: loc,
+                  closure: clos,
+                  name: "#{a.children[0]}=",
+                  comments: cmnt,
+                  access: :writer,
+                  scope: region.scope || :instance,
+                  visibility: region.visibility
+                )
+              end
+            end
+          end
+
+          # @return [void]
+          def process_include
+            return unless Parser.is_ast_node?(node.children.last)
+            node.children.last.children[0..-2].each do |i|
+              next unless [:COLON2, :COLON3, :CONST].include?(i.type)
+              pins.push Pin::Reference::Include.new(
+                location: get_node_location(i),
+                closure: region.closure,
+                name: unpack_name(i)
+              )
+            end
+          end
+
+          # @return [void]
+          def process_prepend
+            return unless Parser.is_ast_node?(node.children.last)
+            node.children.last.children[0..-2].each do |i|
+              next unless [:COLON2, :COLON3, :CONST].include?(i.type)
+              pins.push Pin::Reference::Prepend.new(
+                location: get_node_location(i),
+                closure: region.closure,
+                name: unpack_name(i)
+              )
+            end
+          end
+
+          # @return [void]
+          def process_extend
+            return unless Parser.is_ast_node?(node.children.last)
+            node.children.last.children[0..-2].each do |i|
+              next unless [:COLON2, :COLON3, :CONST, :SELF].include?(i.type)
+              loc = get_node_location(node)
+              if i.type == :SELF
+                pins.push Pin::Reference::Extend.new(
+                  location: loc,
+                  closure: region.closure,
+                  name: region.closure.full_context.namespace
+                )
+              else
+                pins.push Pin::Reference::Extend.new(
+                  location: loc,
+                  closure: region.closure,
+                  name: unpack_name(i)
+                )
+              end
+            end
+          end
+
+          # @return [void]
+          def process_require
+            return unless Parser.is_ast_node?(node.children[1])
+            node.children[1].children.each do |arg|
+              next unless Parser.is_ast_node?(arg)
+              if arg.type == :STR
+                pins.push Pin::Reference::Require.new(get_node_location(arg), arg.children[0])
+              end
+            end
+          end
+
+          # @return [void]
+          def process_module_function
+            if node.type == :VCALL
+              # @todo Smelly instance variable access
+              region.instance_variable_set(:@visibility, :module_function)
+            elsif node.children.last.children[0].type == :DEFN
+              NodeProcessor.process node.children.last.children[0], region.update(visibility: :module_function), pins, locals
+            else
+              node.children.last.children[0..-2].each do |x|
+                next unless [:LIT, :STR].include?(x.type)
+                cn = x.children[0].to_s
+                ref = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn}.first
+                unless ref.nil?
+                  pins.delete ref
+                  mm = Solargraph::Pin::Method.new(
+                    location: ref.location,
+                    closure: ref.closure,
+                    name: ref.name,
+                    comments: ref.comments,
+                    scope: :class,
+                    visibility: :public,
+                    parameters: ref.parameters,
+                    node: ref.node
+                  )
+                  cm = Solargraph::Pin::Method.new(
+                    location: ref.location,
+                    closure: ref.closure,
+                    name: ref.name,
+                    comments: ref.comments,
+                    scope: :instance,
+                    visibility: :private,
+                    parameters: ref.parameters,
+                    node: ref.node)
+                  pins.push mm, cm
+                  pins.select{|pin| pin.is_a?(Pin::InstanceVariable) && pin.closure.path == ref.path}.each do |ivar|
+                    pins.delete ivar
+                    pins.push Solargraph::Pin::InstanceVariable.new(
+                      location: ivar.location,
+                      closure: cm,
+                      name: ivar.name,
+                      comments: ivar.comments,
+                      assignment: ivar.assignment
+                      # scope: :instance
+                    )
+                    pins.push Solargraph::Pin::InstanceVariable.new(
+                      location: ivar.location,
+                      closure: mm,
+                      name: ivar.name,
+                      comments: ivar.comments,
+                      assignment: ivar.assignment
+                      # scope: :class
+                    )
+                  end
+                end
+              end
+            end
+          end
+
+          # @return [void]
+          def process_private_constant
+            node.children.last.children[0..-2].each do |child|
+              if [:LIT, :STR].include?(child.type)
+                cn = child.children[0].to_s
+                ref = pins.select{|p| [Solargraph::Pin::Namespace, Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn}.first
+                # HACK: Smelly instance variable access
+                ref.instance_variable_set(:@visibility, :private) unless ref.nil?
+              end
+            end
+          end
+
+          # @return [void]
+          def process_alias_method
+            arr = node.children[1]
+            return if arr.nil?
+            first = arr.children[0]
+            second = arr.children[1]
+            return unless first && second && [:LIT, :STR].include?(first.type) && [:LIT, :STR].include?(second.type)
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::MethodAlias.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: first.children[0].to_s,
+              original: second.children[0].to_s,
+              scope: region.scope || :instance
+            )
+          end
+
+          # @return [Boolean]
+          def process_private_class_method
+            return false unless Parser.is_ast_node?(node.children.last)
+            if node.children.last.children.first.type == :DEFN
+              process_children region.update(scope: :class, visibility: :private)
+              true
+            else
+              node.children.last.children[0..-2].each do |child|
+                if child.type == :LIT && child.children.first.is_a?(::Symbol)
+                  sym_name = child.children.first.to_s
+                  ref = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == sym_name}.first
+                  # HACK: Smelly instance variable access
+                  ref.instance_variable_set(:@visibility, :private) unless ref.nil?
+                  false
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/rubyvm/node_processors/sym_node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class SymNode < Parser::NodeProcessor::Base
+          def process
+            pins.push Solargraph::Pin::Symbol.new(
+              get_node_location(node),
+              ":#{node.children[0]}"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/snippet.rb

@@ -0,0 +1,13 @@
+module Solargraph
+  module Parser
+    class Snippet
+      attr_reader :range
+      attr_reader :text
+
+      def initialize range, text
+        @range = range
+        @text = text
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'yard'
+
+module Solargraph
+  # The namespace for pins used in maps.
+  #
+  module Pin
+    autoload :Common,           'solargraph/pin/common'
+    autoload :Conversions,      'solargraph/pin/conversions'
+    autoload :Base,             'solargraph/pin/base'
+    autoload :BaseMethod,       'solargraph/pin/base_method'
+    autoload :Method,           'solargraph/pin/method'
+    autoload :MethodAlias,      'solargraph/pin/method_alias'
+    autoload :Attribute,        'solargraph/pin/attribute'
+    autoload :BaseVariable,     'solargraph/pin/base_variable'
+    autoload :InstanceVariable, 'solargraph/pin/instance_variable'
+    autoload :ClassVariable,    'solargraph/pin/class_variable'
+    autoload :LocalVariable,    'solargraph/pin/local_variable'
+    autoload :GlobalVariable,   'solargraph/pin/global_variable'
+    autoload :Constant,         'solargraph/pin/constant'
+    autoload :Symbol,           'solargraph/pin/symbol'
+    autoload :Closure,          'solargraph/pin/closure'
+    autoload :Namespace,        'solargraph/pin/namespace'
+    autoload :Keyword,          'solargraph/pin/keyword'
+    autoload :Parameter,        'solargraph/pin/parameter'
+    autoload :Reference,        'solargraph/pin/reference'
+    autoload :Documenting,      'solargraph/pin/documenting'
+    autoload :Block,            'solargraph/pin/block'
+    autoload :Localized,        'solargraph/pin/localized'
+    autoload :ProxyType,        'solargraph/pin/proxy_type'
+    autoload :DuckMethod,       'solargraph/pin/duck_method'
+    autoload :YardPin,          'solargraph/pin/yard_pin'
+    autoload :Singleton,        'solargraph/pin/singleton'
+    autoload :KeywordParam,     'solargraph/pin/keyword_param'
+
+    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil)
+  end
+end

data/lib/solargraph/pin/attribute.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Attribute < BaseMethod
+      # @return [::Symbol] :reader or :writer
+      attr_reader :access
+
+      # @param access [::Symbol] :reader or :writer
+      def initialize access: :reader, **splat
+        super(**splat)
+        @access = access
+        if access == :writer
+          parameters.push(
+            Pin::Parameter.new(name: 'value', decl: :arg, closure: self)
+          )
+          if return_type.defined?
+            docstring.add_tag YARD::Tags::Tag.new(:param, '', return_type.to_s.split(', '), 'value')
+          end
+        end
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::PROPERTY
+      end
+
+      def symbol_kind
+        Solargraph::LanguageServer::SymbolKinds::PROPERTY
+      end
+
+      def path
+        @path ||= namespace + (scope == :instance ? '#' : '.') + name
+      end
+
+      def probe api_map
+        types = []
+        varname = "@#{name.gsub(/=$/, '')}"
+        pins = api_map.get_instance_variable_pins(binder.namespace, binder.scope).select { |iv| iv.name == varname }
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          type = pin.probe(api_map) if type.undefined?
+          types.push type if type.defined?
+        end
+        return ComplexType::UNDEFINED if types.empty?
+        ComplexType.try_parse(*types.map(&:tag).uniq)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/base.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    # The base class for map pins.
+    #
+    class Base
+      include Common
+      include Conversions
+      include Documenting
+
+      # @return [YARD::CodeObjects::Base]
+      attr_reader :code_object
+
+      # @return [Solargraph::Location]
+      attr_reader :location
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :path
+
+      # @param location [Solargraph::Location]
+      # @param kind [Integer]
+      # @param closure [String]
+      # @param name [String]
+      # @param comments [String]
+      def initialize location: nil, closure: nil, name: '', comments: ''
+        @location = location
+        @closure = closure
+        @name = name
+        @comments = comments
+      end
+
+      # @return [String]
+      def comments
+        @comments ||= ''
+      end
+
+      # @return [String]
+      def filename
+        return nil if location.nil?
+        location.filename
+      end
+
+      # @return [Integer]
+      def completion_item_kind
+        LanguageServer::CompletionItemKinds::KEYWORD
+      end
+
+      # @return [Integer, nil]
+      def symbol_kind
+        nil
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      # @return [Boolean]
+      def variable?
+        false
+      end
+
+      # Pin equality is determined using the #nearly? method and also
+      # requiring both pins to have the same location.
+      #
+      def == other
+        return false unless nearly? other
+        comments == other.comments and location == other.location
+      end
+
+      # True if the specified pin is a near match to this one. A near match
+      # indicates that the pins contain mostly the same data. Any differences
+      # between them should not have an impact on the API surface.
+      #
+      # @param other [Solargraph::Pin::Base, Object]
+      # @return [Boolean]
+      def nearly? other
+        self.class == other.class &&
+          name == other.name &&
+          (closure == other.closure || (closure && closure.nearly?(other.closure))) &&
+          (comments == other.comments ||
+            (((maybe_directives? == false && other.maybe_directives? == false) || compare_directives(directives, other.directives)) &&
+            compare_docstring_tags(docstring, other.docstring))
+          )
+      end
+
+      # The pin's return type.
+      #
+      # @return [ComplexType]
+      def return_type
+        @return_type ||= ComplexType::UNDEFINED
+      end
+
+      # @return [YARD::Docstring]
+      def docstring
+        parse_comments unless defined?(@docstring)
+        @docstring ||= Solargraph::Source.parse_docstring('').to_docstring
+      end
+
+      # @return [Array<YARD::Tags::Directive>]
+      def directives
+        parse_comments unless defined?(@directives)
+        @directives
+      end
+
+      # @return [Array<YARD::Tags::MacroDirective>]
+      def macros
+        @macros ||= collect_macros
+      end
+
+      # Perform a quick check to see if this pin possibly includes YARD
+      # directives. This method does not require parsing the comments.
+      #
+      # After the comments have been parsed, this method will return false if
+      # no directives were found, regardless of whether it previously appeared
+      # possible.
+      #
+      # @return [Boolean]
+      def maybe_directives?
+        return !@directives.empty? if defined?(@directives)
+        @maybe_directives ||= comments.include?('@!')
+      end
+
+      # @return [Boolean]
+      def deprecated?
+        @deprecated ||= docstring.has_tag?('deprecated')
+      end
+
+      # Get a fully qualified type from the pin's return type.
+      #
+      # The relative type is determined from YARD documentation (@return,
+      # @param, @type, etc.) and its namespaces are fully qualified using the
+      # provided ApiMap.
+      #
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def typify api_map
+        return_type.qualify(api_map, namespace)
+      end
+
+      # Infer the pin's return type via static code analysis.
+      #
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def probe api_map
+        typify api_map
+      end
+
+      # @deprecated Use #typify and/or #probe instead
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def infer api_map
+        Solargraph::Logging.logger.warn "WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead."
+        type = typify(api_map)
+        return type unless type.undefined?
+        probe api_map
+      end
+
+      # Try to merge data from another pin. Merges are only possible if the
+      # pins are near matches (see the #nearly? method). The changes should
+      # not have any side effects on the API surface.
+      #
+      # @param pin [Pin::Base] The pin to merge into this one
+      # @return [Boolean] True if the pins were merged
+      def try_merge! pin
+        return false unless nearly?(pin)
+        @location = pin.location
+        @closure = pin.closure
+        return true if comments == pin.comments
+        @comments = pin.comments
+        @docstring = pin.docstring
+        @return_type = pin.return_type
+        @documentation = nil
+        @deprecated = nil
+        reset_conversions
+        true
+      end
+
+      def proxied?
+        @proxied ||= false
+      end
+
+      def probed?
+        @probed ||= false
+      end
+
+      # @param api_map [ApiMap]
+      # @return [self]
+      def realize api_map
+        return self if return_type.defined?
+        type = typify(api_map)
+        return proxy(type) if type.defined?
+        type = probe(api_map)
+        return self if type.undefined?
+        result = proxy(type)
+        result.probed = true
+        result
+      end
+
+      # Return a proxy for this pin with the specified return type. Other than
+      # the return type and the #proxied? setting, the proxy should be a clone
+      # of the original.
+      #
+      # @param return_type [ComplexType]
+      # @return [self]
+      def proxy return_type
+        result = dup
+        result.return_type = return_type
+        result.proxied = true
+        result
+      end
+
+      def identity
+        @identity ||= "#{closure.context.namespace}|#{name}"
+      end
+
+      def inspect
+        "#<#{self.class} at #{self.location.inspect}>"
+      end
+
+      protected
+
+      # @return [Boolean]
+      attr_writer :probed
+
+      # @return [Boolean]
+      attr_writer :proxied
+
+      # @return [ComplexType]
+      attr_writer :return_type
+
+      private
+
+      # @return [void]
+      def parse_comments
+        # HACK: Avoid a NoMethodError on nil with empty overload tags
+        if comments.nil? || comments.empty? || comments.strip.end_with?('@overload')
+          @docstring = nil
+          @directives = []
+        else
+          # HACK: Pass a dummy code object to the parser for plugins that
+          # expect it not to be nil
+          parse = Solargraph::Source.parse_docstring(comments)
+          @docstring = parse.to_docstring
+          @directives = parse.directives
+        end
+      end
+
+      # True if two docstrings have the same tags, regardless of any other
+      # differences.
+      #
+      # @param d1 [YARD::Docstring]
+      # @param d2 [YARD::Docstring]
+      # @return [Boolean]
+      def compare_docstring_tags d1, d2
+        return false if d1.tags.length != d2.tags.length
+        d1.tags.each_index do |i|
+          return false unless compare_tags(d1.tags[i], d2.tags[i])
+        end
+        true
+      end
+
+      # @param dir1 [Array<YARD::Tags::Directive>]
+      # @param dir2 [Array<YARD::Tags::Directive>]
+      # @return [Boolean]
+      def compare_directives dir1, dir2
+        return false if dir1.length != dir2.length
+        dir1.each_index do |i|
+          return false unless compare_tags(dir1[i].tag, dir2[i].tag)
+        end
+        true
+      end
+
+      # @param tag1 [YARD::Tags::Tag]
+      # @param tag2 [YARD::Tags::Tag]
+      # @return [Boolean]
+      def compare_tags tag1, tag2
+        tag1.class == tag2.class &&
+          tag1.tag_name == tag2.tag_name &&
+          tag1.text == tag2.text &&
+          tag1.name == tag2.name &&
+          tag1.types == tag2.types
+      end
+
+      # @return [Array<YARD::Tags::Handlers::Directive>]
+      def collect_macros
+        return [] unless maybe_directives?
+        parse = Solargraph::Source.parse_docstring(comments)
+        parse.directives.select{ |d| d.tag.tag_name == 'macro' }
+      end
+    end
+  end
+end