solargraph 0.38.6 → 0.39.0

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

@@ -0,0 +1,60 @@
+# 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 :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_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 :OP_ASGN_OR, Rubyvm::NodeProcessors::OrasgnNode
+      register :LIT,        Rubyvm::NodeProcessors::LitNode
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class AliasNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::MethodAlias.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].children[0].to_s,
+              original: node.children[1].children[0].to_s,
+              scope: region.scope || :instance
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class ArgsNode < Parser::NodeProcessor::Base
+          def process
+            if region.closure.is_a?(Pin::BaseMethod) || region.closure.is_a?(Pin::Block)
+              node.children[0].times do |i|
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: region.lvars[i].to_s,
+                  presence: region.closure.location.range,
+                  decl: :arg
+                )
+                region.closure.parameters.push locals.last
+              end
+              # @todo Optional args, keyword args, etc.
+              if node.children[6]
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: node.children[6].to_s,
+                  presence: region.closure.location.range,
+                  decl: :restarg
+                )
+                region.closure.parameters.push locals.last
+              end
+              if node.children[8] && node.children[8].children.first
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: node.children[8].children.first.to_s,
+                  presence: region.closure.location.range,
+                  decl: :kwrestarg
+                )
+                region.closure.parameters.push locals.last
+              end
+              if node.children.last
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: node.children.last.to_s,
+                  presence: region.closure.location.range,
+                  decl: :blockarg
+                )
+                region.closure.parameters.push locals.last
+              end
+            end
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class BeginNode < Parser::NodeProcessor::Base
+          def process
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class BlockNode < Parser::NodeProcessor::Base
+          def process
+            pins.push Solargraph::Pin::Block.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              receiver: node.children[0],
+              comments: comments_for(node),
+              scope: region.scope || region.closure.context.scope
+            )
+            process_children region.update(closure: pins.last)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class CasgnNode < Parser::NodeProcessor::Base
+          def process
+            pins.push Solargraph::Pin::Constant.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1]
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class CvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::ClassVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1]
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class DefNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            methpin = Solargraph::Pin::Method.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              scope: region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance),
+              visibility: region.visibility,
+              node: node
+            )
+            if methpin.name == 'initialize' and methpin.scope == :instance
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: 'new',
+                comments: methpin.comments,
+                scope: :class,
+                parameters: methpin.parameters
+              )
+              # @todo Smelly instance variable access.
+              pins.last.instance_variable_set(:@return_type, ComplexType::SELF)
+              pins.push methpin
+              # @todo Smelly instance variable access.
+              methpin.instance_variable_set(:@visibility, :private)
+              methpin.instance_variable_set(:@return_type, ComplexType::VOID)
+            elsif region.visibility == :module_function
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: methpin.name,
+                comments: methpin.comments,
+                scope: :class,
+                visibility: :public,
+                parameters: methpin.parameters,
+                node: methpin.node
+              )
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: methpin.name,
+                comments: methpin.comments,
+                scope: :instance,
+                visibility: :private,
+                parameters: methpin.parameters,
+                node: methpin.node
+              )
+            else
+              pins.push methpin
+            end
+            process_children region.update(closure: methpin, scope: methpin.scope)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class DefsNode < DefNode
+          include NodeMethods
+
+          def process
+            s_visi = region.visibility
+            s_visi = :public if region.scope != :class
+            loc = get_node_location(node)
+            if node.children[0].is_a?(RubyVM::AbstractSyntaxTree::Node) && node.children[0].type == :SELF
+              closure = region.closure
+            else
+              closure = Solargraph::Pin::Namespace.new(
+                name: unpack_name(node.children[0])
+              )
+            end
+            if s_visi == :module_function
+              pins.push Solargraph::Pin::Method.new(
+                location: loc,
+                closure: closure,
+                name: node.children[1].to_s,
+                comments: comments_for(node),
+                scope: :class,
+                visibility: :public,
+                node: node
+              )
+              pins.push Solargraph::Pin::Method.new(
+                location: loc,
+                closure: closure,
+                name: node.children[1].to_s,
+                comments: comments_for(node),
+                scope: :instance,
+                visibility: :private,
+                node: node
+              )
+            else
+              pins.push Solargraph::Pin::Method.new(
+                location: loc,
+                closure: closure,
+                name: node.children[1].to_s,
+                comments: comments_for(node),
+                scope: :class,
+                visibility: s_visi,
+                node: node
+              )
+            end
+            process_children region.update(closure: pins.last, scope: :class)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class GvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::GlobalVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1]
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class IvasgnNode < Parser::NodeProcessor::Base
+          include Rubyvm::NodeMethods
+
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::InstanceVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1]
+            )
+            if region.visibility == :module_function
+              rng = Range.from_node(node)
+              named_path = named_path_pin(rng.start)
+              if named_path.is_a?(Pin::BaseMethod)
+                pins.push Solargraph::Pin::InstanceVariable.new(
+                  location: loc,
+                  closure: Pin::Namespace.new(type: :module, closure: region.closure.closure, name: region.closure.name),
+                  name: node.children[0].to_s,
+                  comments: comments_for(node),
+                  assignment: node.children[1]
+                )
+              end
+            end
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class KwArgNode < Parser::NodeProcessor::Base
+          def process
+            locals.push Solargraph::Pin::Parameter.new(
+              location: region.closure.location,
+              closure: region.closure,
+              comments: comments_for(node),
+              name: node.children[0].children[0].to_s,
+              # assignment: require_keyword?(node) ? nil : node.children[0].children[1],
+              asgn_code: require_keyword?(node) ? nil: region.code_for(node.children[0].children[1]),
+              presence: region.closure.location.range,
+              decl: require_keyword?(node) ? :kwarg : :kwoptarg
+            )
+            region.closure.parameters.push locals.last
+            node.children[1] && NodeProcessor.process(node.children[1], region, pins, locals)
+          end
+
+          private
+
+          def require_keyword? node
+            # Ruby 2.7 changed required keywords to use a magic symbol instead
+            # of nil in the assignment node
+            node.children[0].children[1].nil? || node.children[0].children[1] == :NODE_SPECIAL_REQUIRED_KEYWORD
+          end
+        end
+      end
+    end
+  end
+end