solargraph 0.54.4 → 0.56.2

data/lib/solargraph/library.rb

@@ -2,6 +2,7 @@
 
 require 'pathname'
 require 'observer'
+require 'open3'
 
 module Solargraph
   # A Library handles coordination between a Workspace and an ApiMap.
@@ -327,9 +328,10 @@ module Solargraph
 
     # @param query [String]
     # @return [Enumerable<YARD::CodeObjects::Base>]
+    # @return [Array(ApiMap, Enumerable<Pin::Base>)]
     def document query
       sync_catalog
-      mutex.synchronize { api_map.document query }
+      mutex.synchronize { [api_map, api_map.get_path_pins(query)] }
     end
 
     # @param query [String]
@@ -430,7 +432,8 @@ module Solargraph
       Bench.new(
         source_maps: source_map_hash.values,
         workspace: workspace,
-        external_requires: external_requires
+        external_requires: external_requires,
+        live_map: @current ? source_map_hash[@current.filename] : nil
       )
     end
 
@@ -586,28 +589,52 @@ module Solargraph
     # @return [void]
     def cache_next_gemspec
       return if @cache_progress
-      spec = api_map.uncached_gemspecs.find { |spec| !cache_errors.include?(spec) }
+
+      spec = cacheable_specs.first
       return end_cache_progress unless spec
 
       pending = api_map.uncached_gemspecs.length - cache_errors.length - 1
-      logger.info "Caching #{spec.name} #{spec.version}"
-      Thread.new do
-        cache_pid = Process.spawn(workspace.command_path, 'cache', spec.name, spec.version.to_s)
-        report_cache_progress spec.name, pending
-        Process.wait(cache_pid)
-        logger.info "Cached #{spec.name} #{spec.version}"
-      rescue Errno::EINVAL => _e
-        logger.info "Cached #{spec.name} #{spec.version} with EINVAL"
-      rescue StandardError => e
-        cache_errors.add spec
-        Solargraph.logger.warn "Error caching gemspec #{spec.name} #{spec.version}: [#{e.class}] #{e.message}"
-      ensure
-        end_cache_progress
+
+      if Yardoc.processing?(spec)
+        logger.info "Enqueuing cache of #{spec.name} #{spec.version} (already being processed)"
+        queued_gemspec_cache.push(spec)
+        return if pending - queued_gemspec_cache.length < 1
+
         catalog
         sync_catalog
+      else
+        logger.info "Caching #{spec.name} #{spec.version}"
+        Thread.new do
+          report_cache_progress spec.name, pending
+          _o, e, s = Open3.capture3(workspace.command_path, 'cache', spec.name, spec.version.to_s)
+          if s.success?
+            logger.info "Cached #{spec.name} #{spec.version}"
+          else
+            cache_errors.add spec
+            logger.warn "Error caching gemspec #{spec.name} #{spec.version}"
+            logger.warn e
+          end
+          end_cache_progress
+          catalog
+          sync_catalog
+        end
       end
     end
 
+    def cacheable_specs
+      cacheable = api_map.uncached_yard_gemspecs +
+                  api_map.uncached_rbs_collection_gemspecs -
+                  queued_gemspec_cache -
+                  cache_errors.to_a
+      return cacheable unless cacheable.empty?
+
+      queued_gemspec_cache
+    end
+
+    def queued_gemspec_cache
+      @queued_gemspec_cache ||= []
+    end
+
     # @param gem_name [String]
     # @param pending [Integer]
     # @return [void]
@@ -653,7 +680,8 @@ module Solargraph
         api_map.catalog bench
         source_map_hash.values.each { |map| find_external_requires(map) }
         logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
-        logger.info "#{api_map.uncached_gemspecs.length} uncached gemspecs"
+        logger.info "#{api_map.uncached_yard_gemspecs.length} uncached YARD gemspecs"
+        logger.info "#{api_map.uncached_rbs_collection_gemspecs.length} uncached RBS collection gemspecs"
         cache_next_gemspec
         @sync_count = 0
       end

data/lib/solargraph/location.rb

@@ -25,11 +25,32 @@ module Solargraph
       [filename, range]
     end
 
+    def <=>(other)
+      return nil unless other.is_a?(Location)
+      if filename == other.filename
+        range <=> other.range
+      else
+        filename <=> other.filename
+      end
+    end
+
+    def rbs?
+      filename.end_with?('.rbs')
+    end
+
     # @param location [self]
     def contain? location
       range.contain?(location.range.start) && range.contain?(location.range.ending) && filename == location.filename
     end
 
+    def inspect
+      "<#{self.class.name}: filename=#{filename}, range=#{range.inspect}>"
+    end
+
+    def to_s
+      inspect
+    end
+
     # @return [Hash]
     def to_hash
       {

data/lib/solargraph/logging.rb

@@ -13,6 +13,7 @@ module Solargraph
     }
 
     @@logger = Logger.new(STDERR, level: DEFAULT_LOG_LEVEL)
+    # @sg-ignore Fix cvar issue
     @@logger.formatter = proc do |severity, datetime, progname, msg|
       "[#{severity}] #{msg}\n"
     end

data/lib/solargraph/parser/comment_ripper.rb

@@ -13,6 +13,8 @@ module Solargraph
       end
 
       def on_comment *args
+        # @sg-ignore
+        # @type [Array(Symbol, String, Array([Integer, nil], [Integer, nil]))]
         result = super
         if @buffer_lines[result[2][0]][0..result[2][1]].strip =~ /^#/
           chomped = result[1].chomp
@@ -24,24 +26,28 @@ module Solargraph
         result
       end
 
+      # @param result [Array(Symbol, String, Array([Integer, nil], [Integer, nil]))]
+      # @return [void]
+      def create_snippet(result)
+        chomped = result[1].chomp
+        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0] || 0, result[2][1] || 0, result[2][0] || 0, (result[2][1] || 0) + chomped.length), chomped)
+      end
+
       def on_embdoc_beg *args
         result = super
-        chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        create_snippet(result)
         result
       end
 
       def on_embdoc *args
         result = super
-        chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        create_snippet(result)
         result
       end
 
       def on_embdoc_end *args
         result = super
-        chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        create_snippet(result)
         result
       end
 

data/lib/solargraph/parser/flow_sensitive_typing.rb

@@ -0,0 +1,227 @@
+module Solargraph
+  module Parser
+    class FlowSensitiveTyping
+      include Solargraph::Parser::NodeMethods
+
+      # @param locals [Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+      def initialize(locals, enclosing_breakable_pin = nil)
+        @locals = locals
+        @enclosing_breakable_pin = enclosing_breakable_pin
+      end
+
+      # @param and_node [Parser::AST::Node]
+      def process_and(and_node, true_ranges = [])
+        lhs = and_node.children[0]
+        rhs = and_node.children[1]
+
+        before_rhs_loc = rhs.location.expression.adjust(begin_pos: -1)
+        before_rhs_pos = Position.new(before_rhs_loc.line, before_rhs_loc.column)
+
+        rhs_presence = Range.new(before_rhs_pos,
+                                 get_node_end_position(rhs))
+        process_isa(lhs, true_ranges + [rhs_presence])
+      end
+
+      # @param if_node [Parser::AST::Node]
+      def process_if(if_node)
+        #
+        # See if we can refine a type based on the result of 'if foo.nil?'
+        #
+        # [3] pry(main)> require 'parser/current'; Parser::CurrentRuby.parse("if foo.is_a? Baz; then foo; else bar; end")
+        # => s(:if,
+        #   s(:send,
+        #     s(:send, nil, :foo), :is_a?,
+        #     s(:const, nil, :Baz)),
+        #   s(:send, nil, :foo),
+        #   s(:send, nil, :bar))
+        # [4] pry(main)>
+        conditional_node = if_node.children[0]
+        then_clause = if_node.children[1]
+        else_clause = if_node.children[2]
+
+        true_ranges = []
+        if always_breaks?(else_clause)
+          unless enclosing_breakable_pin.nil?
+            rest_of_breakable_body = Range.new(get_node_end_position(if_node),
+                                               get_node_end_position(enclosing_breakable_pin.node))
+            true_ranges << rest_of_breakable_body
+          end
+        end
+
+        unless then_clause.nil?
+          #
+          # Add specialized locals for the then clause range
+          #
+          before_then_clause_loc = then_clause.location.expression.adjust(begin_pos: -1)
+          before_then_clause_pos = Position.new(before_then_clause_loc.line, before_then_clause_loc.column)
+          true_ranges << Range.new(before_then_clause_pos,
+                                   get_node_end_position(then_clause))
+        end
+
+        process_conditional(conditional_node, true_ranges)
+      end
+
+      class << self
+        include Logging
+      end
+
+      # Find a variable pin by name and where it is used.
+      #
+      # Resolves our most specific view of this variable's type by
+      # preferring pins created by flow-sensitive typing when we have
+      # them based on the Closure and Location.
+      #
+      # @param pins [Array<Pin::LocalVariable>]
+      # @param closure [Pin::Closure]
+      # @param location [Location]
+      def self.visible_pins(pins, name, closure, location)
+        logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location})" }
+        pins_with_name = pins.select { |p| p.name == name }
+        if pins_with_name.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => [] - no pins with name" }
+          return []
+        end
+        pins_with_specific_visibility = pins.select { |p| p.name == name && p.presence && p.visible_at?(closure, location) }
+        if pins_with_specific_visibility.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{pins_with_name} - no pins with specific visibility" }
+          return pins_with_name
+        end
+        visible_pins_specific_to_this_closure = pins_with_specific_visibility.select { |p| p.closure == closure }
+        if visible_pins_specific_to_this_closure.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{pins_with_specific_visibility} - no visible pins specific to this closure (#{closure})}" }
+          return pins_with_specific_visibility
+        end
+        flow_defined_pins = pins_with_specific_visibility.select { |p| p.presence_certain? }
+        if flow_defined_pins.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{visible_pins_specific_to_this_closure} - no flow-defined pins" }
+          return visible_pins_specific_to_this_closure
+        end
+
+        logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{flow_defined_pins}" }
+
+        flow_defined_pins
+      end
+
+      include Logging
+
+      private
+
+      # @param pin [Pin::LocalVariable]
+      # @param if_node [Parser::AST::Node]
+      def add_downcast_local(pin, downcast_type_name, presence)
+        # @todo Create pin#update method
+        new_pin = Solargraph::Pin::LocalVariable.new(
+          location: pin.location,
+          closure: pin.closure,
+          name: pin.name,
+          assignment: pin.assignment,
+          comments: pin.comments,
+          presence: presence,
+          return_type: ComplexType.try_parse(downcast_type_name),
+          presence_certain: true,
+          source: :flow_sensitive_typing
+        )
+        locals.push(new_pin)
+      end
+
+      # @param facts_by_pin [Hash{Pin::LocalVariable => Array<Hash{Symbol => String}>}]
+      # @param presences [Array<Range>]
+      # @return [void]
+      def process_facts(facts_by_pin, presences)
+        #
+        # Add specialized locals for the rest of the block
+        #
+        facts_by_pin.each_pair do |pin, facts|
+          facts.each do |fact|
+            downcast_type_name = fact.fetch(:type)
+            presences.each do |presence|
+              add_downcast_local(pin, downcast_type_name, presence)
+            end
+          end
+        end
+      end
+
+      # @param conditional_node [Parser::AST::Node]
+      def process_conditional(conditional_node, true_ranges)
+        if conditional_node.type == :send
+          process_isa(conditional_node, true_ranges)
+        elsif conditional_node.type == :and
+          process_and(conditional_node, true_ranges)
+        end
+      end
+
+      # @param isa_node [Parser::AST::Node]
+      # @return [Array(String, String)]
+      def parse_isa(isa_node)
+        return unless isa_node&.type == :send && isa_node.children[1] == :is_a?
+        # Check if conditional node follows this pattern:
+        #   s(:send,
+        #     s(:send, nil, :foo), :is_a?,
+        #     s(:const, nil, :Baz)),
+        isa_receiver = isa_node.children[0]
+        isa_type_name = type_name(isa_node.children[2])
+        return unless isa_type_name
+
+        # check if isa_receiver looks like this:
+        #  s(:send, nil, :foo)
+        # and set variable_name to :foo
+        if isa_receiver&.type == :send && isa_receiver.children[0].nil? && isa_receiver.children[1].is_a?(Symbol)
+          variable_name = isa_receiver.children[1].to_s
+        end
+        # or like this:
+        # (lvar :repr)
+        variable_name = isa_receiver.children[0].to_s if isa_receiver&.type == :lvar
+        return unless variable_name
+
+        [isa_type_name, variable_name]
+      end
+
+      def find_local(variable_name, position)
+        pins = locals.select { |pin| pin.name == variable_name && pin.presence.include?(position) }
+        return unless pins.length == 1
+        pins.first
+      end
+
+      def process_isa(isa_node, true_presences)
+        isa_type_name, variable_name = parse_isa(isa_node)
+        return if variable_name.nil? || variable_name.empty?
+        isa_position = Range.from_node(isa_node).start
+
+        pin = find_local(variable_name, isa_position)
+        return unless pin
+
+        if_true = {}
+        if_true[pin] ||= []
+        if_true[pin] << { type: isa_type_name }
+        process_facts(if_true, true_presences)
+      end
+
+      # @param node [Parser::AST::Node]
+      def type_name(node)
+        # e.g.,
+        #  s(:const, nil, :Baz)
+        return unless node.type == :const
+        module_node = node.children[0]
+        class_node = node.children[1]
+
+        return class_node.to_s if module_node.nil?
+
+        module_type_name = type_name(module_node)
+        return unless module_type_name
+
+        "#{module_type_name}::#{class_node}"
+      end
+
+      # @todo "return type could not be inferred" should not trigger here
+      # @sg-ignore
+      # @param clause_node [Parser::AST::Node]
+      def always_breaks?(clause_node)
+        clause_node&.type == :break
+      end
+
+      attr_reader :locals
+
+      attr_reader :enclosing_breakable_pin
+    end
+  end
+end

data/lib/solargraph/parser/node_methods.rb

@@ -78,6 +78,20 @@ module Solargraph
       def convert_hash node
         raise NotImplementedError
       end
+
+      # @abstract
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_start_position(node)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_end_position(node)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/solargraph/parser/node_processor/base.rb

@@ -30,9 +30,12 @@ module Solargraph
 
         # Subclasses should override this method to generate new pins.
         #
-        # @return [void]
+        # @return [Boolean] continue processing the next processor of the same node type.
+        # @return [void] In case there is only one processor registered for the node type, it can be void.
         def process
           process_children
+
+          true
         end
 
         private
@@ -64,7 +67,9 @@ module Solargraph
         # @param position [Solargraph::Position]
         # @return [Pin::Closure, nil]
         def named_path_pin position
-          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.path && !pin.path.empty? && pin.location.range.contain?(position)}.last
+          pins.select do |pin|
+            pin.is_a?(Pin::Closure) && pin.path && !pin.path.empty? && pin.location.range.contain?(position)
+          end.last
         end
 
         # @todo Candidate for deprecation
@@ -72,14 +77,14 @@ module Solargraph
         # @return [Pin::Closure, nil]
         def block_pin position
           # @todo determine if this can return a Pin::Block
-          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
         end
 
         # @todo Candidate for deprecation
         # @param position [Solargraph::Position]
         # @return [Pin::Closure, nil]
         def closure_pin position
-          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
         end
       end
     end

data/lib/solargraph/parser/node_processor.rb

@@ -9,16 +9,22 @@ module Solargraph
       autoload :Base, 'solargraph/parser/node_processor/base'
 
       class << self
-        # @type [Hash<Symbol, Class<NodeProcessor::Base>>]
+        # @type [Hash<Symbol, Array<Class<NodeProcessor::Base>>>]
         @@processors ||= {}
 
-        # Register a processor for a node type.
+        # Register a processor for a node type. You can register multiple processors for the same type.
+        # If a node processor returns true, it will skip the next processor of the same node type.
         #
         # @param type [Symbol]
         # @param cls [Class<NodeProcessor::Base>]
         # @return [Class<NodeProcessor::Base>]
         def register type, cls
-          @@processors[type] = cls
+          @@processors[type] ||= []
+          @@processors[type] << cls
+        end
+
+        def deregister type, cls
+          @@processors[type].delete(cls)
         end
       end
 
@@ -31,14 +37,21 @@ module Solargraph
         if pins.empty?
           pins.push Pin::Namespace.new(
             location: region.source.location,
-            name: ''
+            name: '',
+            source: :parser,
           )
         end
         return [pins, locals] unless Parser.is_ast_node?(node)
-        klass = @@processors[node.type] || NodeProcessor::Base
-        processor = klass.new(node, region, pins, locals)
-        processor.process
-        [processor.pins, processor.locals]
+        node_processor_classes = @@processors[node.type] || [NodeProcessor::Base]
+
+        node_processor_classes.each do |klass|
+          processor = klass.new(node, region, pins, locals)
+          process_next = processor.process
+
+          break unless process_next
+        end
+
+        [pins, locals]
       end
     end
   end

data/lib/solargraph/parser/parser_gem/class_methods.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
-require 'parser/current'
-require 'parser/source/buffer'
+require 'prism'
+
+# Awaiting ability to use a version containing https://github.com/whitequark/parser/pull/1076
+#
+# @!parse
+#   class ::Parser::Base < ::Parser::Builder
+#     # @return [Integer]
+#     def version; end
+#   end
+#   class ::Parser::CurrentRuby < ::Parser::Base; end
 
 module Solargraph
   module Parser
@@ -11,13 +19,9 @@ module Solargraph
         # @param filename [String, nil]
         # @return [Array(Parser::AST::Node, Hash{Integer => String})]
         def parse_with_comments code, filename = nil
-          buffer = ::Parser::Source::Buffer.new(filename, 0)
-          buffer.source = code
-          node = parser.parse(buffer)
+          node = parse(code, filename)
           comments = CommentRipper.new(code, filename, 0).parse
           [node, comments]
-        rescue ::Parser::SyntaxError => e
-          raise Parser::SyntaxError, e.message
         end
 
         # @param code [String]
@@ -28,18 +32,16 @@ module Solargraph
           buffer = ::Parser::Source::Buffer.new(filename, line)
           buffer.source = code
           parser.parse(buffer)
-        rescue ::Parser::SyntaxError => e
+        rescue ::Parser::SyntaxError, ::Parser::UnknownEncodingInMagicComment => e
           raise Parser::SyntaxError, e.message
         end
 
         # @return [::Parser::Base]
         def parser
-          # @todo Consider setting an instance variable. We might not need to
-          #   recreate the parser every time we use it.
-          parser = ::Parser::CurrentRuby.new(FlawedBuilder.new)
-          parser.diagnostics.all_errors_are_fatal = true
-          parser.diagnostics.ignore_warnings      = true
-          parser
+          @parser ||= Prism::Translation::Parser.new(FlawedBuilder.new).tap do |parser|
+            parser.diagnostics.all_errors_are_fatal = true
+            parser.diagnostics.ignore_warnings      = true
+          end
         end
 
         # @param source [Source]

data/lib/solargraph/parser/parser_gem/node_chainer.rb

@@ -57,22 +57,22 @@ module Solargraph
           elsif n.type == :send
             if n.children[0].is_a?(::Parser::AST::Node)
               result.concat generate_links(n.children[0])
-              result.push Chain::Call.new(n.children[1].to_s, node_args(n), passed_block(n))
+              result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             elsif n.children[0].nil?
               args = []
               n.children[2..-1].each do |c|
                 args.push NodeChainer.chain(c, @filename, n)
               end
-              result.push Chain::Call.new(n.children[1].to_s, node_args(n), passed_block(n))
+              result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             else
               raise "No idea what to do with #{n}"
             end
           elsif n.type == :csend
             if n.children[0].is_a?(::Parser::AST::Node)
               result.concat generate_links(n.children[0])
-              result.push Chain::QCall.new(n.children[1].to_s, node_args(n))
+              result.push Chain::QCall.new(n.children[1].to_s, Location.from_node(n), node_args(n))
             elsif n.children[0].nil?
-              result.push Chain::QCall.new(n.children[1].to_s, node_args(n))
+              result.push Chain::QCall.new(n.children[1].to_s, Location.from_node(n), node_args(n))
             else
               raise "No idea what to do with #{n}"
             end
@@ -82,15 +82,15 @@ module Solargraph
             result.push Chain::ZSuper.new('super')
           elsif n.type == :super
             args = n.children.map { |c| NodeChainer.chain(c, @filename, n) }
-            result.push Chain::Call.new('super', args)
+            result.push Chain::Call.new('super', Location.from_node(n), args)
           elsif n.type == :yield
             args = n.children.map { |c| NodeChainer.chain(c, @filename, n) }
-            result.push Chain::Call.new('yield', args)
+            result.push Chain::Call.new('yield', Location.from_node(n), args)
           elsif n.type == :const
             const = unpack_name(n)
             result.push Chain::Constant.new(const)
           elsif [:lvar, :lvasgn].include?(n.type)
-            result.push Chain::Call.new(n.children[0].to_s)
+            result.push Chain::Call.new(n.children[0].to_s, Location.from_node(n))
           elsif [:ivar, :ivasgn].include?(n.type)
             result.push Chain::InstanceVariable.new(n.children[0].to_s)
           elsif [:cvar, :cvasgn].include?(n.type)
@@ -124,13 +124,13 @@ module Solargraph
               end
             end
           elsif n.type == :hash
-            result.push Chain::Hash.new('::Hash', hash_is_splatted?(n))
+            result.push Chain::Hash.new('::Hash', n, hash_is_splatted?(n))
           elsif n.type == :array
             chained_children = n.children.map { |c| NodeChainer.chain(c) }
-            result.push Source::Chain::Array.new(chained_children)
+            result.push Source::Chain::Array.new(chained_children, n)
           else
             lit = infer_literal_node_type(n)
-            result.push (lit ? Chain::Literal.new(lit) : Chain::Link.new)
+            result.push (lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
           end
           result
         end

data/lib/solargraph/parser/parser_gem/node_methods.rb

@@ -12,7 +12,7 @@ require 'ast'
 #     class Node
 #       # New children
 #
-#       # @return [Array<self>]
+#       # @return [Array<self, Integer, String, Symbol, nil>]
 #       attr_reader :children
 #     end
 #   end
@@ -40,7 +40,7 @@ module Solargraph
               if n.is_a?(AST::Node)
                 if n.type == :cbase
                   parts = [''] + pack_name(n)
-                else
+                elsif n.type == :const
                   parts += pack_name(n)
                 end
               else
@@ -59,6 +59,8 @@ module Solargraph
             return '::String'
           elsif node.type == :array
             return '::Array'
+          elsif node.type == :nil
+            return '::NilClass'
           elsif node.type == :hash
             return '::Hash'
           elsif node.type == :int