solargraph 0.32.5 → 0.33.0

data/lib/solargraph/source_map/node_processor/casgn_node.rb

@@ -4,8 +4,13 @@ module Solargraph
       class CasgnNode < Base
         def process
           here = get_node_start_position(node)
-          block = block_pin(here)
-          pins.push Solargraph::Pin::Constant.new(get_node_location(node), region.namespace, node.children[1].to_s, comments_for(node), node.children[2], infer_literal_node_type(node.children[2]), block.context, :public)
+          pins.push Solargraph::Pin::Constant.new(
+            location: get_node_location(node),
+            closure: region.closure,
+            name: node.children[1].to_s,
+            comments: comments_for(node),
+            assignment: node.children[2]
+          )
           process_children
         end
       end

data/lib/solargraph/source_map/node_processor/cvasgn_node.rb

@@ -3,9 +3,14 @@ module Solargraph
     module NodeProcessor
       class CvasgnNode < Base
         def process
-          here = get_node_start_position(node)
-          context = named_path_pin(here)
-          pins.push Solargraph::Pin::ClassVariable.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), context.context)
+          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

data/lib/solargraph/source_map/node_processor/def_node.rb

@@ -3,50 +3,57 @@ module Solargraph
     module NodeProcessor
       class DefNode < Base
         def process
-          methpin = Solargraph::Pin::Method.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), region.scope, region.visibility, method_args, node)
+          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,
+            args: method_args,
+            node: node
+          )
           if methpin.name == 'initialize' and methpin.scope == :instance
-            pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, 'new', methpin.comments, :class, :public, methpin.parameters, nil)
+            pins.push Solargraph::Pin::Method.new(
+              location: methpin.location,
+              closure: methpin.closure,
+              name: 'new',
+              comments: methpin.comments,
+              scope: :class,
+              args: methpin.parameters
+            )
             # @todo Smelly instance variable access.
-            pins.last.instance_variable_set(:@return_complex_type, ComplexType.try_parse(methpin.namespace))
-            pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, methpin.scope, :private, methpin.parameters, methpin.node)
+            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(methpin.location, methpin.namespace, methpin.name, methpin.comments, :class, :public, methpin.parameters, methpin.node)
-            pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, :instance, :private, methpin.parameters, methpin.node)
+            pins.push Solargraph::Pin::Method.new(
+              location: methpin.location,
+              closure: methpin.closure,
+              name: methpin.name,
+              comments: methpin.comments,
+              scope: :class,
+              visibility: :public,
+              args: 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,
+              args: methpin.parameters,
+              node: methpin.node
+            )
           else
             pins.push methpin
           end
-          process_children
-        end
-
-        private
-
-        def method_args
-          return [] if node.nil?
-          list = nil
-          args = []
-          node.children.each { |c|
-            if c.kind_of?(AST::Node) and c.type == :args
-              list = c
-              break
-            end
-          }
-          return args if list.nil?
-          list.children.each { |c|
-            if c.type == :arg
-              args.push c.children[0].to_s
-            elsif c.type == :restarg
-              args.push "*#{c.children[0]}"
-            elsif c.type == :optarg
-              args.push "#{c.children[0]} = #{region.code_for(c.children[1])}"
-            elsif c.type == :kwarg
-              args.push "#{c.children[0]}:"
-            elsif c.type == :kwoptarg
-              args.push "#{c.children[0]}: #{region.code_for(c.children[1])}"
-            elsif c.type == :blockarg
-              args.push "&#{c.children[0]}"
-            end
-          }
-          args
+          process_children region.update(closure: methpin, scope: methpin.scope)
         end
       end
     end

data/lib/solargraph/source_map/node_processor/defs_node.rb

@@ -5,15 +5,25 @@ module Solargraph
         def process
           s_visi = region.visibility
           s_visi = :public if s_visi == :module_function || region.scope != :class
+          loc = get_node_location(node)
           if node.children[0].is_a?(AST::Node) && node.children[0].type == :self
-            dfqn = region.namespace
+            closure = region.closure
           else
-            dfqn = unpack_name(node.children[0])
-          end
-          unless dfqn.nil?
-            pins.push Solargraph::Pin::Method.new(get_node_location(node), dfqn, "#{node.children[1]}", comments_for(node), :class, s_visi, method_args, node)
-            process_children region.update(namespace: dfqn)
+            closure = Solargraph::Pin::Namespace.new(
+              name: unpack_name(node.children[0])
+            )
           end
+          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,
+            args: method_args,
+            node: node
+          )
+          process_children region.update(closure: pins.last, scope: :class)
         end
       end
     end

data/lib/solargraph/source_map/node_processor/gvasgn_node.rb

@@ -3,7 +3,14 @@ module Solargraph
     module NodeProcessor
       class GvasgnNode < Base
         def process
-          pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), pins.first.context)
+          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

data/lib/solargraph/source_map/node_processor/ivasgn_node.rb

@@ -3,12 +3,26 @@ module Solargraph
     module NodeProcessor
       class IvasgnNode < Base
         def process
-          here = get_node_start_position(node)
-          named_path = named_path_pin(here)
-          pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(node), region.namespace,node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), named_path.context)
-          if region.visibility == :module_function and named_path.kind == Pin::METHOD
-            other = ComplexType.try_parse("Module<#{named_path.context.namespace}>")
-            pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(node), region.namespace,node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), other)
+          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
+            here = get_node_start_position(node)
+            named_path = named_path_pin(here)
+            if named_path.kind == Pin::METHOD
+              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

data/lib/solargraph/source_map/node_processor/lvasgn_node.rb

@@ -4,10 +4,16 @@ module Solargraph
       class LvasgnNode < Base
         def process
           here = get_node_start_position(node)
-          context = named_path_pin(here)
-          block = block_pin(here)
-          presence = Range.new(here, block.location.range.ending)
-          pins.push Solargraph::Pin::LocalVariable.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), context.context, block, presence)
+          presence = Range.new(here, region.closure.location.range.ending)
+          loc = get_node_location(node)
+          locals.push Solargraph::Pin::LocalVariable.new(
+            location: loc,
+            closure: region.closure,
+            name: node.children[0].to_s,
+            assignment: node.children[1],
+            comments: comments_for(node),
+            presence: presence
+          )
           process_children
         end
       end

data/lib/solargraph/source_map/node_processor/namespace_node.rb

@@ -3,22 +3,28 @@ module Solargraph
     module NodeProcessor
       class NamespaceNode < Base
         def process
-          visibility = :public
-          if node.children[0].kind_of?(AST::Node) and node.children[0].children[0].kind_of?(AST::Node) and node.children[0].children[0].type == :cbase
-            tree = pack_name(node.children[0])
-            tree.shift if tree.first.empty?
-          else
-            tree = region.namespace.empty? ? [] : [region.namespace]
-            tree.concat pack_name(node.children[0])
-          end
-          fqn = tree.join('::')
           sc = nil
           if node.type == :class and !node.children[1].nil?
             sc = unpack_name(node.children[1])
           end
-          pins.push Solargraph::Pin::Namespace.new(get_node_location(node), tree[0..-2].join('::') || '', pack_name(node.children[0]).last.to_s, comments_for(node), node.type, visibility)
-          pins.push Pin::Reference::Superclass.new(pins.last.location, pins.last.path, sc) unless sc.nil?
-          process_children region.update(namespace: fqn, scope: :instance, visibility: :public)
+          loc = get_node_location(node)
+          nspin = Solargraph::Pin::Namespace.new(
+            type: node.type,
+            location: loc,
+            closure: region.closure,
+            name: unpack_name(node.children[0]),
+            comments: comments_for(node),
+            visibility: :public
+          )
+          pins.push nspin
+          unless sc.nil?
+            pins.push Pin::Reference::Superclass.new(
+              location: loc,
+              closure: pins.last,
+              name: sc
+            )
+          end
+          process_children region.update(closure: nspin, visibility: :public)
         end
       end
     end

data/lib/solargraph/source_map/node_processor/orasgn_node.rb

@@ -4,7 +4,7 @@ module Solargraph
       class OrasgnNode < Base
         def process
           new_node = node.updated(node.children[0].type, node.children[0].children + [node.children[1]])
-          NodeProcessor.process(new_node, region, pins)
+          NodeProcessor.process(new_node, region, pins, locals)
         end
       end
     end

data/lib/solargraph/source_map/node_processor/resbody_node.rb

@@ -0,0 +1,30 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class ResbodyNode < Base
+        def process
+          if node.children[1]
+            here = get_node_start_position(node.children[1])
+            presence = Range.new(here, region.closure.location.range.ending)
+            loc = get_node_location(node.children[1])
+            types = if node.children[0].nil?
+                      ['Exception']
+                    else
+                      node.children[0].children.map do |child|
+                        unpack_name(child)
+                      end
+                    end
+            locals.push Solargraph::Pin::LocalVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[1].children[0].to_s,
+              comments: "@type [#{types.join(',')}]",
+              presence: presence
+            )
+          end
+          NodeProcessor.process(node.children[2], region, pins, locals)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/sclass_node.rb

@@ -3,7 +3,13 @@ module Solargraph
     module NodeProcessor
       class SclassNode < Base
         def process
-          process_children region.update(visibility: :public, scope: :class)
+          # @todo Temporarily skipping remote metaclasses
+          return unless node.children[0].is_a?(AST::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

data/lib/solargraph/source_map/node_processor/send_node.rb

@@ -9,7 +9,7 @@ module Solargraph
                 node.children[2..-1].each do |child|
                   next unless child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
                   name = child.children[0].to_s
-                  matches = pins.select{ |pin| [Pin::METHOD, Pin::ATTRIBUTE].include?(pin.kind) && pin.name == name && pin.namespace == region.namespace && pin.context.scope == region.scope }
+                  matches = pins.select{ |pin| [Pin::METHOD, Pin::ATTRIBUTE].include?(pin.kind) && 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[1])
@@ -27,7 +27,7 @@ module Solargraph
               process_include
             elsif node.children[1] == :extend
               process_extend
-            elsif node.children[1] == :require 
+            elsif node.children[1] == :require
               process_require
             elsif node.children[1] == :private_constant
               process_private_constant
@@ -43,113 +43,163 @@ module Solargraph
 
         private
 
+        # @return [void]
         def process_attribute
           node.children[2..-1].each do |a|
+            loc = get_node_location(node)
+            clos = region.closure
+            cmnt = comments_for(node)
             if node.children[1] == :attr_reader || node.children[1] == :attr_accessor
-              pins.push Solargraph::Pin::Attribute.new(get_node_location(node), region.namespace, "#{a.children[0]}", comments_for(node), :reader, region.scope, region.visibility)
+              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[1] == :attr_writer || node.children[1] == :attr_accessor
-              pins.push Solargraph::Pin::Attribute.new(get_node_location(node), region.namespace, "#{a.children[0]}=", comments_for(node), :writer, region.scope, region.visibility)
+              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
           if node.children[2].kind_of?(AST::Node) && node.children[2].type == :const
+            cp = region.closure
             node.children[2..-1].each do |i|
-              nspin = pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.path == region.namespace}.last
-              unless nspin.nil?
-                pins.push Pin::Reference::Include.new(get_node_location(node), nspin.path, unpack_name(i))
-              end
+              pins.push Pin::Reference::Include.new(
+                location: get_node_location(i),
+                closure: cp,
+                name: unpack_name(i)
+              )
             end
           end
         end
 
+        # @return [void]
         def process_extend
           node.children[2..-1].each do |i|
-            nspin = pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.path == region.namespace}.last
-            unless nspin.nil?
-              ref = nil
-              if i.type == :self
-                ref = Pin::Reference::Extend.new(get_node_location(node), nspin.path, nspin.path)
-              elsif i.type == :const
-                ref = Pin::Reference::Extend.new(get_node_location(node), nspin.path, unpack_name(i))
-              end
-              pins.push ref unless ref.nil?
+            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
           if node.children[2].kind_of?(AST::Node) && node.children[2].type == :str
             pins.push Pin::Reference::Require.new(get_node_location(node), node.children[2].children[0].to_s)
           end
         end
 
+        # @return [void]
         def process_module_function
           if node.children[2].nil?
             # @todo Smelly instance variable access
             region.instance_variable_set(:@visibility, :module_function)
           elsif node.children[2].type == :sym || node.children[2].type == :str
-            # @todo What to do about references?
             node.children[2..-1].each do |x|
               cn = x.children[0].to_s
-              ref = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.namespace == region.namespace && p.name == cn}.first
+              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(ref.location, ref.namespace, ref.name, ref.comments, :class, :public, ref.parameters, ref.node)
-                cm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, :instance, :private, ref.parameters, ref.node)
+                mm = Solargraph::Pin::Method.new(
+                  location: ref.location,
+                  closure: ref.closure,
+                  name: ref.name,
+                  comments: ref.comments,
+                  scope: :class,
+                  visibility: :public,
+                  args: 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,
+                  args: ref.parameters,
+                  node: ref.node)
                 pins.push mm, cm
-                pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context == ref.context}.each do |ivar|
+                pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE && pin.closure.path == ref.path}.each do |ivar|
                   pins.delete ivar
-                  pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), mm)
-                  pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), cm)
+                  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
           elsif node.children[2].type == :def
-            NodeProcessor.process node.children[2], region.update(visibility: :module_function), pins
+            NodeProcessor.process node.children[2], region.update(visibility: :module_function), pins, locals
           end
         end
 
+        # @return [void]
         def process_private_constant
           if node.children[2] && (node.children[2].type == :sym || node.children[2].type == :str)
-            # @todo What to do about references?
             cn = node.children[2].children[0].to_s
-            ref = pins.select{|p| [Solargraph::Pin::Namespace, Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.namespace && p.name == cn}.first
-            unless ref.nil?
-              pins.delete ref
-              # Might be either a namespace or constant
-              if ref.kind == Pin::CONSTANT
-                pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.signature, ref.return_type, ref.context, :private)
-              else
-                # pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.type, :private, (ref.superclass_reference.nil? ? nil : ref.superclass_reference.name))
-                pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.type, :private)
-              end
-            end
+            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
 
+        # @return [void]
         def process_alias_method
-          pin = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.name == node.children[3].children[0].to_s && p.namespace == region.namespace && p.scope == region.scope}.first
-          if pin.nil?
-            pins.push Solargraph::Pin::MethodAlias.new(get_node_location(node), region.namespace, node.children[2].children[0].to_s, region.scope, node.children[3].children[0].to_s)
-          else
-            if pin.is_a?(Solargraph::Pin::Method)
-              pins.push Solargraph::Pin::Method.new(get_node_location(node), pin.namespace, node.children[2].children[0].to_s, comments_for(node) || pin.comments, pin.scope, pin.visibility, pin.parameters, pin.node)
-            elsif pin.is_a?(Solargraph::Pin::Attribute)
-              pins.push Solargraph::Pin::Attribute.new(get_node_location(node), pin.namespace, node.children[2].children[0].to_s, comments_for(node) || pin.comments, pin.access, pin.scope, pin.visibility)
-            end
-          end
+          loc = get_node_location(node)
+          pins.push Solargraph::Pin::MethodAlias.new(
+            location: get_node_location(node),
+            closure: region.closure,
+            name: node.children[2].children[0].to_s,
+            original: node.children[3].children[0].to_s,
+            scope: region.scope || :instance
+          )
         end
 
+        # @return [Boolean]
         def process_private_class_method
           if node.children[2].type == :sym || node.children[2].type == :str
-            ref = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.namespace == region.namespace && p.name == node.children[2].children[0].to_s}.first
-            unless ref.nil?
-              # HACK: Smelly instance variable access
-              ref.instance_variable_set(:@visibility, :private)
-            end
+            ref = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == node.children[2].children[0].to_s}.first
+            # HACK: Smelly instance variable access
+            ref.instance_variable_set(:@visibility, :private) unless ref.nil?
             false
           else
             process_children region.update(scope: :class, visibility: :private)