cosmicgraph 0.49.0

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

@@ -0,0 +1,279 @@
+# 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])
+              process_visibility
+            elsif node.children[0] == :module_function
+              process_module_function
+            elsif node.children[0] == :require
+              process_require
+            elsif node.children[0] == :autoload
+              process_autoload
+            elsif node.children[0] == :alias_method
+              process_alias_method
+            elsif node.children[0] == :private_class_method
+              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_visibility
+            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)
+                if child.type == :LIT || child.type == :STR
+                  name = child.children[0].to_s
+                  matches = pins.select{ |pin| pin.is_a?(Pin::Method) && 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
+                else
+                  process_children region.update(visibility: node.children[0])
+                end
+              end
+            else
+              # @todo Smelly instance variable access
+              region.instance_variable_set(:@visibility, node.children[0])
+            end
+          end
+
+          # @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::Method.new(
+                  location: loc,
+                  closure: clos,
+                  name: a.children[0].to_s,
+                  comments: cmnt,
+                  scope: region.scope || :instance,
+                  visibility: region.visibility,
+                  attribute: true
+                )
+              end
+              if node.children[0] == :attr_writer || node.children[0] == :attr_accessor
+                pins.push Solargraph::Pin::Method.new(
+                  location: loc,
+                  closure: clos,
+                  name: "#{a.children[0]}=",
+                  comments: cmnt,
+                  scope: region.scope || :instance,
+                  visibility: region.visibility,
+                  attribute: true
+                )
+                pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+                if pins.last.return_type.defined?
+                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+                end
+              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)
+              type = region.scope == :class ? Pin::Reference::Extend : Pin::Reference::Include
+              pins.push type.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_autoload
+            return unless Parser.is_ast_node?(node.children[1]) && Parser.is_ast_node?(node.children[1].children[1])
+            arg = node.children[1].children[1]
+            if arg.type == :STR
+              pins.push Pin::Reference::Require.new(get_node_location(arg), arg.children[0])
+            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| p.is_a?(Pin::Method) && 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
+            arr = node.children[1]
+            return unless Parser.is_ast_node?(arr) && [:ARRAY, :LIST].include?(arr.type)
+
+            arr.children.compact.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 [void]
+          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)
+            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| p.is_a?(Pin::Method) && 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?
+                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/rubyvm/node_processors.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'solargraph/parser/node_processor'
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        autoload :ScopeNode,     'solargraph/parser/rubyvm/node_processors/scope_node'
+        autoload :BeginNode,     'solargraph/parser/rubyvm/node_processors/begin_node'
+        autoload :DefNode,       'solargraph/parser/rubyvm/node_processors/def_node'
+        autoload :DefsNode,      'solargraph/parser/rubyvm/node_processors/defs_node'
+        autoload :SendNode,      'solargraph/parser/rubyvm/node_processors/send_node'
+        autoload :NamespaceNode, 'solargraph/parser/rubyvm/node_processors/namespace_node'
+        autoload :SclassNode,    'solargraph/parser/rubyvm/node_processors/sclass_node'
+        autoload :ModuleNode,    'solargraph/parser/rubyvm/node_processors/module_node'
+        autoload :IvasgnNode,    'solargraph/parser/rubyvm/node_processors/ivasgn_node'
+        autoload :CvasgnNode,    'solargraph/parser/rubyvm/node_processors/cvasgn_node'
+        autoload :LvasgnNode,    'solargraph/parser/rubyvm/node_processors/lvasgn_node'
+        autoload :GvasgnNode,    'solargraph/parser/rubyvm/node_processors/gvasgn_node'
+        autoload :CasgnNode,     'solargraph/parser/rubyvm/node_processors/casgn_node'
+        autoload :AliasNode,     'solargraph/parser/rubyvm/node_processors/alias_node'
+        autoload :ArgsNode,      'solargraph/parser/rubyvm/node_processors/args_node'
+        autoload :OptArgNode,    'solargraph/parser/rubyvm/node_processors/opt_arg_node'
+        autoload :KwArgNode,     'solargraph/parser/rubyvm/node_processors/kw_arg_node'
+        autoload :BlockNode,     'solargraph/parser/rubyvm/node_processors/block_node'
+        autoload :OrasgnNode,    'solargraph/parser/rubyvm/node_processors/orasgn_node'
+        autoload :SymNode,       'solargraph/parser/rubyvm/node_processors/sym_node'
+        autoload :LitNode,       'solargraph/parser/rubyvm/node_processors/lit_node'
+        autoload :ResbodyNode,   'solargraph/parser/rubyvm/node_processors/resbody_node'
+      end
+    end
+
+    module NodeProcessor
+      register :SCOPE,      Rubyvm::NodeProcessors::ScopeNode
+      register :RESBODY,    Rubyvm::NodeProcessors::ResbodyNode
+      register :DEFN,       Rubyvm::NodeProcessors::DefNode
+      register :DEFS,       Rubyvm::NodeProcessors::DefsNode
+      register :CALL,       Rubyvm::NodeProcessors::SendNode
+      register :FCALL,      Rubyvm::NodeProcessors::SendNode
+      register :VCALL,      Rubyvm::NodeProcessors::SendNode
+      register :CLASS,      Rubyvm::NodeProcessors::NamespaceNode
+      register :MODULE,     Rubyvm::NodeProcessors::NamespaceNode
+      register :SCLASS,     Rubyvm::NodeProcessors::SclassNode
+      register :IASGN,      Rubyvm::NodeProcessors::IvasgnNode
+      register :CVASGN,     Rubyvm::NodeProcessors::CvasgnNode
+      register :LASGN,      Rubyvm::NodeProcessors::LvasgnNode
+      register :DASGN,      Rubyvm::NodeProcessors::LvasgnNode
+      register :DASGN_CURR, Rubyvm::NodeProcessors::LvasgnNode
+      register :GASGN,      Rubyvm::NodeProcessors::GvasgnNode
+      register :CDECL,      Rubyvm::NodeProcessors::CasgnNode
+      register :ALIAS,      Rubyvm::NodeProcessors::AliasNode
+      register :ARGS,       Rubyvm::NodeProcessors::ArgsNode
+      register :OPT_ARG,    Rubyvm::NodeProcessors::OptArgNode
+      register :KW_ARG,     Rubyvm::NodeProcessors::KwArgNode
+      register :ITER,       Rubyvm::NodeProcessors::BlockNode
+      register :LAMBDA,     Rubyvm::NodeProcessors::BlockNode
+      register :FOR,        Rubyvm::NodeProcessors::BlockNode
+      register :OP_ASGN_OR, Rubyvm::NodeProcessors::OrasgnNode
+      register :LIT,        Rubyvm::NodeProcessors::LitNode
+    end
+  end
+end

data/lib/solargraph/parser/rubyvm/node_wrapper.rb

@@ -0,0 +1,47 @@
+require 'delegate'
+
+module RubyVM::AbstractSyntaxTree
+  # Wrapper for RubyVM::AbstractSyntaxTree::Node. for return character based column
+  class NodeWrapper < SimpleDelegator
+    attr_reader :code
+    # @param node [RubyVM::AbstractSyntaxTree::Node] wrapped node to return character based column
+    # @param code [Array<String>] source code lines for generated this node
+    def initialize(node, code)
+      @code = code
+      super(node)
+    end
+
+    def self.from(node, code)
+      return node unless node.is_a?(RubyVM::AbstractSyntaxTree::Node) and !node.kind_of?(SimpleDelegator)
+
+      new(node, code)
+    end
+
+    def is_a?(type)
+      __getobj__.is_a?(type) || super.is_a?(type)
+    end
+
+    def class
+      __getobj__.class
+    end
+
+
+    def first_column
+      @first_column ||= begin
+        line = @code[__getobj__.first_lineno - 1] || ""
+        line.byteslice(0, __getobj__.first_column).length
+      end
+    end
+
+    def last_column
+      @last_column ||= begin
+        line = @code[__getobj__.last_lineno - 1] || ""
+        line.byteslice(0, __getobj__.last_column).length
+      end
+    end
+
+    def children
+      @children ||= __getobj__.children.map do |node| NodeWrapper.from(node, @code) end
+    end
+  end
+end

data/lib/solargraph/parser/rubyvm.rb

@@ -0,0 +1,40 @@
+module Solargraph
+  module Parser
+    module Rubyvm
+      autoload :ClassMethods, 'solargraph/parser/rubyvm/class_methods'
+      autoload :NodeChainer,  'solargraph/parser/rubyvm/node_chainer'
+      autoload :NodeMethods,  'solargraph/parser/rubyvm/node_methods'
+    end
+  end
+end
+
+require 'solargraph/parser/rubyvm/node_processors'
+
+class RubyVM::AbstractSyntaxTree::Node
+  def to_sexp
+    sexp self
+  end
+
+  def == other
+    return false unless other.is_a?(self.class)
+    here = Solargraph::Range.from_node(self)
+    there = Solargraph::Range.from_node(other)
+    here == there && to_sexp == other.to_sexp
+  end
+
+  private
+
+  def sexp node, depth = 0
+    result = ''
+    if node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      result += "#{'  ' * depth}(:#{node.type}"
+      node.children.each do |child|
+        result += "\n" + sexp(child, depth + 1)
+      end
+      result += ")"
+    else
+      result += "#{'  ' * depth}#{node.inspect}"
+    end
+    result
+  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/parser.rb

@@ -0,0 +1,26 @@
+module Solargraph
+  module Parser
+    autoload :CommentRipper, 'solargraph/parser/comment_ripper'
+    autoload :Legacy, 'solargraph/parser/legacy'
+    autoload :Rubyvm, 'solargraph/parser/rubyvm'
+    autoload :Region, 'solargraph/parser/region'
+    autoload :NodeProcessor, 'solargraph/parser/node_processor'
+    autoload :Snippet, 'solargraph/parser/snippet'
+
+    class SyntaxError < StandardError
+    end
+
+    # True if the parser can use RubyVM.
+    #
+    def self.rubyvm?
+      !!defined?(RubyVM::AbstractSyntaxTree)
+      # false
+    end
+
+    selected = rubyvm? ? Rubyvm : Legacy
+    # include selected
+    extend selected::ClassMethods
+
+    NodeMethods = (rubyvm? ? Rubyvm::NodeMethods : Legacy::NodeMethods)
+  end
+end