solargraph 0.56.2 → 0.58.0

data/lib/solargraph/library.rb

@@ -259,11 +259,11 @@ module Solargraph
           referenced&.path == pin.path
         end
         if pin.path == 'Class#new'
-          caller = cursor.chain.base.infer(api_map, clip.send(:block), clip.locals).first
+          caller = cursor.chain.base.infer(api_map, clip.send(:closure), clip.locals).first
           if caller.defined?
             found.select! do |loc|
               clip = api_map.clip_at(loc.filename, loc.range.start)
-              other = clip.send(:cursor).chain.base.infer(api_map, clip.send(:block), clip.locals).first
+              other = clip.send(:cursor).chain.base.infer(api_map, clip.send(:closure), clip.locals).first
               caller == other
             end
           else
@@ -402,8 +402,8 @@ module Solargraph
       repargs = {}
       workspace.config.reporters.each do |line|
         if line == 'all!'
-          Diagnostics.reporters.each do |reporter|
-            repargs[reporter] ||= []
+          Diagnostics.reporters.each do |reporter_name|
+            repargs[Diagnostics.reporter(reporter_name)] ||= []
           end
         else
           args = line.split(':').map(&:strip)
@@ -437,17 +437,6 @@ module Solargraph
       )
     end
 
-    # Get an array of foldable ranges for the specified file.
-    #
-    # @deprecated The library should not need to handle folding ranges. The
-    #   source itself has all the information it needs.
-    #
-    # @param filename [String]
-    # @return [Array<Range>]
-    def folding_ranges filename
-      read(filename).folding_ranges
-    end
-
     # Create a library from a directory.
     #
     # @param directory [String] The path to be used for the workspace
@@ -511,7 +500,7 @@ module Solargraph
 
     private
 
-    # @return [Hash{String => Set<String>}]
+    # @return [Hash{String => Array<String>}]
     def source_map_external_require_hash
       @source_map_external_require_hash ||= {}
     end
@@ -519,6 +508,7 @@ module Solargraph
     # @param source_map [SourceMap]
     # @return [void]
     def find_external_requires source_map
+      # @type [Set<String>]
       new_set = source_map.requires.map(&:name).to_set
       # return if new_set == source_map_external_require_hash[source_map.filename]
       _filenames = nil
@@ -532,7 +522,7 @@ module Solargraph
       @external_requires = nil
     end
 
-    # @return [Mutex]
+    # @return [Thread::Mutex]
     def mutex
       @mutex ||= Mutex.new
     end
@@ -621,6 +611,7 @@ module Solargraph
       end
     end
 
+    # @return [Array<Gem::Specification>]
     def cacheable_specs
       cacheable = api_map.uncached_yard_gemspecs +
                   api_map.uncached_rbs_collection_gemspecs -
@@ -631,6 +622,7 @@ module Solargraph
       queued_gemspec_cache
     end
 
+    # @return [Array<Gem::Specification>]
     def queued_gemspec_cache
       @queued_gemspec_cache ||= []
     end
@@ -672,13 +664,14 @@ module Solargraph
       @total = nil
     end
 
+    # @return [void]
     def sync_catalog
       return if @sync_count == 0
 
       mutex.synchronize do
         logger.info "Cataloging #{workspace.directory.empty? ? 'generic workspace' : workspace.directory}"
-        api_map.catalog bench
         source_map_hash.values.each { |map| find_external_requires(map) }
+        api_map.catalog bench
         logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
         logger.info "#{api_map.uncached_yard_gemspecs.length} uncached YARD gemspecs"
         logger.info "#{api_map.uncached_rbs_collection_gemspecs.length} uncached RBS collection gemspecs"

data/lib/solargraph/location.rb

@@ -25,6 +25,7 @@ module Solargraph
       [filename, range]
     end
 
+    # @param other [self]
     def <=>(other)
       return nil unless other.is_a?(Location)
       if filename == other.filename
@@ -60,6 +61,7 @@ module Solargraph
     end
 
     # @param node [Parser::AST::Node, nil]
+    # @return [Location, nil]
     def self.from_node(node)
       return nil if node.nil? || node.loc.nil?
       range = Range.from_node(node)
@@ -69,6 +71,7 @@ module Solargraph
     # @param other [BasicObject]
     def == other
       return false unless other.is_a?(Location)
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       filename == other.filename and range == other.range
     end
 

data/lib/solargraph/logging.rb

@@ -11,8 +11,17 @@ module Solargraph
       'info' => Logger::INFO,
       'debug' => Logger::DEBUG
     }
-
-    @@logger = Logger.new(STDERR, level: DEFAULT_LOG_LEVEL)
+    configured_level = ENV.fetch('SOLARGRAPH_LOG', nil)
+    level = if LOG_LEVELS.keys.include?(configured_level)
+              LOG_LEVELS.fetch(configured_level)
+            else
+              if configured_level
+                warn "Invalid value for SOLARGRAPH_LOG: #{configured_level.inspect} - " \
+                     "valid values are #{LOG_LEVELS.keys}"
+              end
+              DEFAULT_LOG_LEVEL
+            end
+    @@logger = Logger.new(STDERR, level: level)
     # @sg-ignore Fix cvar issue
     @@logger.formatter = proc do |severity, datetime, progname, msg|
       "[#{severity}] #{msg}\n"

data/lib/solargraph/page.rb

@@ -29,6 +29,7 @@ module Solargraph
       # @param text [String]
       # @return [String]
       def htmlify text
+        # @type [String]
         YARD::Templates::Helpers::Markup::RDocMarkup.new(text).to_html
       end
 
@@ -70,8 +71,10 @@ module Solargraph
     # @param template [String]
     # @param layout [Boolean]
     # @param locals [Hash]
+    # @sg-ignore
     # @return [String]
     def render template, layout: true, locals: {}
+      # @type [String]
       @render_method.call(template, layout: layout, locals: locals)
     end
 

data/lib/solargraph/parser/comment_ripper.rb

@@ -3,6 +3,13 @@ require 'ripper'
 module Solargraph
   module Parser
     class CommentRipper < Ripper::SexpBuilderPP
+      # @!override Ripper::SexpBuilder#on_embdoc_beg
+      #   @return [Array(Symbol, String, Array)]
+      # @!override Ripper::SexpBuilder#on_embdoc
+      #   @return [Array(Symbol, String, Array)]
+      # @!override Ripper::SexpBuilder#on_embdoc_end
+      #   @return [Array(Symbol, String, Array)]
+
       # @param src [String]
       # @param filename [String]
       # @param lineno [Integer]
@@ -51,7 +58,7 @@ module Solargraph
         result
       end
 
-      # @return [Hash{Integer => String}]
+      # @return [Hash{Integer => Solargraph::Parser::Snippet}]
       def parse
         @comments = {}
         super

data/lib/solargraph/parser/flow_sensitive_typing.rb

@@ -4,14 +4,20 @@ module Solargraph
       include Solargraph::Parser::NodeMethods
 
       # @param locals [Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+      # @param enclosing_breakable_pin [Solargraph::Pin::Breakable, nil]
       def initialize(locals, enclosing_breakable_pin = nil)
         @locals = locals
         @enclosing_breakable_pin = enclosing_breakable_pin
       end
 
       # @param and_node [Parser::AST::Node]
+      # @param true_ranges [Array<Range>]
+      #
+      # @return [void]
       def process_and(and_node, true_ranges = [])
+        # @type [Parser::AST::Node]
         lhs = and_node.children[0]
+        # @type [Parser::AST::Node]
         rhs = and_node.children[1]
 
         before_rhs_loc = rhs.location.expression.adjust(begin_pos: -1)
@@ -23,6 +29,8 @@ module Solargraph
       end
 
       # @param if_node [Parser::AST::Node]
+      #
+      # @return [void]
       def process_if(if_node)
         #
         # See if we can refine a type based on the result of 'if foo.nil?'
@@ -36,7 +44,9 @@ module Solargraph
         #   s(:send, nil, :bar))
         # [4] pry(main)>
         conditional_node = if_node.children[0]
+        # @type [Parser::AST::Node]
         then_clause = if_node.children[1]
+        # @type [Parser::AST::Node]
         else_clause = if_node.children[2]
 
         true_ranges = []
@@ -72,8 +82,11 @@ module Solargraph
       # them based on the Closure and Location.
       #
       # @param pins [Array<Pin::LocalVariable>]
+      # @param name [String]
       # @param closure [Pin::Closure]
       # @param location [Location]
+      #
+      # @return [Array<Pin::LocalVariable>]
       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 }
@@ -107,7 +120,10 @@ module Solargraph
       private
 
       # @param pin [Pin::LocalVariable]
-      # @param if_node [Parser::AST::Node]
+      # @param downcast_type_name [String]
+      # @param presence [Range]
+      #
+      # @return [void]
       def add_downcast_local(pin, downcast_type_name, presence)
         # @todo Create pin#update method
         new_pin = Solargraph::Pin::LocalVariable.new(
@@ -126,6 +142,7 @@ module Solargraph
 
       # @param facts_by_pin [Hash{Pin::LocalVariable => Array<Hash{Symbol => String}>}]
       # @param presences [Array<Range>]
+      #
       # @return [void]
       def process_facts(facts_by_pin, presences)
         #
@@ -142,6 +159,9 @@ module Solargraph
       end
 
       # @param conditional_node [Parser::AST::Node]
+      # @param true_ranges [Array<Range>]
+      #
+      # @return [void]
       def process_conditional(conditional_node, true_ranges)
         if conditional_node.type == :send
           process_isa(conditional_node, true_ranges)
@@ -151,7 +171,7 @@ module Solargraph
       end
 
       # @param isa_node [Parser::AST::Node]
-      # @return [Array(String, String)]
+      # @return [Array(String, String), nil]
       def parse_isa(isa_node)
         return unless isa_node&.type == :send && isa_node.children[1] == :is_a?
         # Check if conditional node follows this pattern:
@@ -176,12 +196,20 @@ module Solargraph
         [isa_type_name, variable_name]
       end
 
+      # @param variable_name [String]
+      # @param position [Position]
+      #
+      # @return [Solargraph::Pin::LocalVariable, nil]
       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
 
+      # @param isa_node [Parser::AST::Node]
+      # @param true_presences [Array<Range>]
+      #
+      # @return [void]
       def process_isa(isa_node, true_presences)
         isa_type_name, variable_name = parse_isa(isa_node)
         return if variable_name.nil? || variable_name.empty?
@@ -197,10 +225,12 @@ module Solargraph
       end
 
       # @param node [Parser::AST::Node]
+      #
+      # @return [String, nil]
       def type_name(node)
         # e.g.,
         #  s(:const, nil, :Baz)
-        return unless node.type == :const
+        return unless node&.type == :const
         module_node = node.children[0]
         class_node = node.children[1]
 
@@ -212,8 +242,6 @@ module Solargraph
         "#{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

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

@@ -13,7 +13,7 @@ module Solargraph
         # @return [Array<Pin::Base>]
         attr_reader :pins
 
-        # @return [Array<Pin::BaseVariable>]
+        # @return [Array<Pin::LocalVariable>]
         attr_reader :locals
 
         # @param node [Parser::AST::Node]

data/lib/solargraph/parser/node_processor.rb

@@ -9,7 +9,7 @@ module Solargraph
       autoload :Base, 'solargraph/parser/node_processor/base'
 
       class << self
-        # @type [Hash<Symbol, Array<Class<NodeProcessor::Base>>>]
+        # @type [Hash{Symbol => Array<Class<NodeProcessor::Base>>}]
         @@processors ||= {}
 
         # Register a processor for a node type. You can register multiple processors for the same type.
@@ -17,12 +17,16 @@ module Solargraph
         #
         # @param type [Symbol]
         # @param cls [Class<NodeProcessor::Base>]
-        # @return [Class<NodeProcessor::Base>]
+        # @return [Array<Class<NodeProcessor::Base>>]
         def register type, cls
           @@processors[type] ||= []
           @@processors[type] << cls
         end
 
+        # @param type [Symbol]
+        # @param cls [Class<NodeProcessor::Base>]
+        #
+        # @return [void]
         def deregister type, cls
           @@processors[type].delete(cls)
         end

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

@@ -2,22 +2,13 @@
 
 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
     module ParserGem
       module ClassMethods
         # @param code [String]
         # @param filename [String, nil]
-        # @return [Array(Parser::AST::Node, Hash{Integer => String})]
+        # @return [Array(Parser::AST::Node, Hash{Integer => Solargraph::Parser::Snippet})]
         def parse_with_comments code, filename = nil
           node = parse(code, filename)
           comments = CommentRipper.new(code, filename, 0).parse
@@ -84,6 +75,7 @@ module Solargraph
         # @param top [AST::Node]
         # @return [Array<AST::Node>]
         def inner_node_references name, top
+          # @type [Array<AST::Node>]
           result = []
           if top.is_a?(AST::Node) && top.to_s.include?(":#{name}")
             result.push top if top.children.any? { |c| c.to_s == name }
@@ -137,9 +129,7 @@ module Solargraph
         def string_ranges node
           return [] unless is_ast_node?(node)
           result = []
-          if node.type == :str
-            result.push Range.from_node(node)
-          end
+          result.push Range.from_node(node) if node.type == :str
           node.children.each do |child|
             result.concat string_ranges(child)
           end

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

@@ -9,6 +9,7 @@ module Solargraph
       class FlawedBuilder < ::Parser::Builders::Default
         # @param token [::Parser::AST::Node]
         # @return [String]
+        # @sg-ignore
         def string_value(token)
           value(token)
         end

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

@@ -7,6 +7,7 @@ module Solargraph
       #
       class NodeChainer
         include NodeMethods
+
         Chain = Source::Chain
 
         # @param node [Parser::AST::Node]
@@ -98,7 +99,8 @@ module Solargraph
           elsif [:gvar, :gvasgn].include?(n.type)
             result.push Chain::GlobalVariable.new(n.children[0].to_s)
           elsif n.type == :or_asgn
-            result.concat generate_links n.children[1]
+            new_node = n.updated(n.children[0].type, n.children[0].children + [n.children[1]])
+            result.concat generate_links new_node
           elsif [:class, :module, :def, :defs].include?(n.type)
             # @todo Undefined or what?
             result.push Chain::UNDEFINED_CALL

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

@@ -3,20 +3,6 @@
 require 'parser'
 require 'ast'
 
-# Teach AST::Node#children about its generic type
-#
-# @todo contribute back to https://github.com/ruby/gem_rbs_collection/blob/main/gems/ast/2.4/ast.rbs
-#
-# @!parse
-#   module ::AST
-#     class Node
-#       # New children
-#
-#       # @return [Array<self, Integer, String, Symbol, nil>]
-#       attr_reader :children
-#     end
-#   end
-
 # https://github.com/whitequark/parser
 module Solargraph
   module Parser
@@ -120,7 +106,7 @@ module Solargraph
         end
 
         # @param node [Parser::AST::Node]
-        # @return [Hash{Parser::AST::Node => Chain}]
+        # @return [Hash{Symbol => Chain}]
         def convert_hash node
           return {} unless Parser.is_ast_node?(node)
           return convert_hash(node.children[0]) if node.type == :kwsplat
@@ -133,6 +119,7 @@ module Solargraph
           result
         end
 
+        # @sg-ignore Wrong argument type for AST::Node.new: type expected AST::_ToSym, received :nil
         NIL_NODE = ::Parser::AST::Node.new(:nil)
 
         # @param node [Parser::AST::Node]
@@ -179,6 +166,7 @@ module Solargraph
             node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
           elsif node.type == :send
             result.push node
+            result.concat call_nodes_from(node.children.first)
             node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
           elsif [:super, :zsuper].include?(node.type)
             result.push node
@@ -232,6 +220,7 @@ module Solargraph
           else
             source.tree_at(position.line, position.column - 1)
           end
+          # @type [AST::Node, nil]
           prev = nil
           tree.each do |node|
             if node.type == :send
@@ -242,7 +231,7 @@ module Solargraph
                 if source.synchronized?
                   return node if source.code[0..offset-1] =~ /\(\s*\z/ && source.code[offset..-1] =~ /^\s*\)/
                 else
-                  return node if source.code[0..offset-1] =~ /\([^\(]*\z/
+                  return node if source.code[0..offset-1] =~ /\([^(]*\z/
                 end
               end
             end

data/lib/solargraph/parser/parser_gem/node_processors/and_node.rb

@@ -11,6 +11,7 @@ module Solargraph
             process_children
 
             position = get_node_start_position(node)
+            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
             enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
             FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_and(node)
           end

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

@@ -19,7 +19,7 @@ module Solargraph
             else
               region.closure
             end
-            pins.push Solargraph::Pin::Block.new(
+            block_pin = Solargraph::Pin::Block.new(
               location: location,
               closure: parent,
               node: node,
@@ -28,7 +28,8 @@ module Solargraph
               scope: region.scope || region.closure.context.scope,
               source: :parser
             )
-            process_children region.update(closure: pins.last)
+            pins.push block_pin
+            process_children region.update(closure: block_pin)
           end
 
           private

data/lib/solargraph/parser/parser_gem/node_processors/if_node.rb

@@ -11,6 +11,8 @@ module Solargraph
             process_children
 
             position = get_node_start_position(node)
+            # @sg-ignore
+            # @type [Solargraph::Pin::Breakable, nil]
             enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
             FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_if(node)
           end

data/lib/solargraph/parser/parser_gem/node_processors/masgn_node.rb

@@ -22,8 +22,11 @@ module Solargraph
             #     s(:int, 2),
             #     s(:int, 3)))
             masgn = node
+            # @type [Parser::AST::Node]
             mlhs = masgn.children.fetch(0)
+            # @type [Array<Parser::AST::Node>]
             lhs_arr = mlhs.children
+            # @type [Parser::AST::Node]
             mass_rhs = node.children.fetch(1)
 
             # Get pins created for the mlhs node

data/lib/solargraph/parser/parser_gem/node_processors/opasgn_node.rb

@@ -9,14 +9,70 @@ module Solargraph
         class OpasgnNode < Parser::NodeProcessor::Base
           # @return [void]
           def process
-            # Parser::CurrentRuby.parse("a += 2")
-            # => s(:op_asgn,
-            #      s(:lvasgn, :a), :+,
-            #      s(:int, 2))
-            asgn = node.children[0]
-            variable_name = asgn.children[0]
+            target = node.children[0]
             operator = node.children[1]
             argument = node.children[2]
+            if target.type == :send
+              # @sg-ignore Need a downcast here
+              process_send_target(target, operator, argument)
+            elsif target.type.to_s.end_with?('vasgn')
+              # @sg-ignore Need a downcast here
+              process_vasgn_target(target, operator, argument)
+            else
+              Solargraph.assert_or_log(:opasgn_unknown_target,
+                                       "Unexpected op_asgn target type: #{target.type}")
+            end
+          end
+
+          # @param call [Parser::AST::Node] the target of the assignment
+          # @param operator [Symbol] the operator, e.g. :+
+          # @param argument [Parser::AST::Node] the argument of the operation
+          #
+          # @return [void]
+          def process_send_target call, operator, argument
+            # if target is a call:
+            # [10] pry(main)> Parser::CurrentRuby.parse("Foo.bar += baz")
+            # => s(:op_asgn,
+            #      s(:send, # call
+            #        s(:const, nil, :Foo), # calee
+            #        :bar), # call_method
+            #      :+, # operator
+            #      s(:send, nil, :baz)) # argument
+            # [11] pry(main)>
+            callee = call.children[0]
+            call_method = call.children[1]
+            asgn_method = :"#{call_method}="
+
+            # [8] pry(main)> Parser::CurrentRuby.parse("Foo.bar = Foo.bar + baz")
+            # => s(:send,
+            #       s(:const, nil, :Foo), # callee
+            #       :bar=, # asgn_method
+            #        s(:send,
+            #          s(:send,
+            #             s(:const, nil, :Foo), # callee
+            #             :bar), # call_method
+            #          :+, # operator
+            #          s(:send, nil, :baz))) # argument
+            new_send = node.updated(:send,
+                                    [callee,
+                                     asgn_method,
+                                     node.updated(:send, [call, operator, argument])])
+            NodeProcessor.process(new_send, region, pins, locals)
+          end
+
+          # @param asgn [Parser::AST::Node] the target of the assignment
+          # @param operator [Symbol] the operator, e.g. :+
+          # @param argument [Parser::AST::Node] the argument of the operation
+          #
+          # @return [void]
+          def process_vasgn_target asgn, operator, argument
+            # => s(:op_asgn,
+            #      s(:lvasgn, :a), # asgn
+            #      :+, # operator
+            #      s(:int, 2)) # argument
+
+            # @type [Parser::AST::Node]
+            variable_name = asgn.children[0]
             # for lvasgn, gvasgn, cvasgn, convert to lvar, gvar, cvar
             # [6] pry(main)> Parser::CurrentRuby.parse("a = a + 1")
             # => s(:lvasgn, :a,
@@ -25,9 +81,9 @@ module Solargraph
             #     s(:int, 1)))
             # [7] pry(main)>
             variable_reference_type = asgn.type.to_s.sub(/vasgn$/, 'var').to_sym
-            variable_reference = node.updated(variable_reference_type, asgn.children)
+            target_reference = node.updated(variable_reference_type, asgn.children)
             send_children = [
-              variable_reference,
+              target_reference,
               operator,
               argument
             ]

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

@@ -7,9 +7,18 @@ module Solargraph
         class SclassNode < Parser::NodeProcessor::Base
           def process
             sclass = node.children[0]
-            if sclass.is_a?(AST::Node) && sclass.type == :self
+            # @todo Changing Parser::AST::Node to AST::Node below will
+            #   cause type errors at strong level because the combined
+            #   pin for AST::Node#children has return type
+            #   "Array<AST::Node>, Array".  YARD annotations in AST
+            #   provided the Array, RBS for Array<AST::Node>.  We
+            #   should probably have a rule to combine "A, A<T>""
+            #   types to "A<T>" if the "A" comes from YARD, with the
+            #   rationale that folks tend to be less formal with types in
+            #   YARD.
+            if sclass.is_a?(::Parser::AST::Node) && sclass.type == :self
               closure = region.closure
-            elsif sclass.is_a?(AST::Node) && sclass.type == :casgn
+            elsif sclass.is_a?(::Parser::AST::Node) && sclass.type == :casgn
               names = [region.closure.namespace, region.closure.name]
               if sclass.children[0].nil? && names.last != sclass.children[1].to_s
                 names << sclass.children[1].to_s
@@ -18,7 +27,7 @@ module Solargraph
               end
               name = names.reject(&:empty?).join('::')
               closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location, source: :parser)
-            elsif sclass.is_a?(AST::Node) && sclass.type == :const
+            elsif sclass.is_a?(::Parser::AST::Node) && sclass.type == :const
               names = [region.closure.namespace, region.closure.name]
               also = NodeMethods.unpack_name(sclass)
               if also != region.closure.name