rubocop 0.83.0 → 0.84.0

data/lib/rubocop/target_finder.rb

@@ -54,9 +54,7 @@ module RuboCop
     # @return [Array] Array of filenames
     def target_files_in_dir(base_dir = Dir.pwd)
       # Support Windows: Backslashes from command-line -> forward slashes
-      if File::ALT_SEPARATOR
-        base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
-      end
+      base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
       all_files = find_files(base_dir, File::FNM_DOTMATCH)
       hidden_files = Set.new(all_files - find_files(base_dir, 0))
       base_dir_config = @config_store.for(base_dir)
@@ -172,9 +170,7 @@ module RuboCop
     def process_explicit_path(path, mode)
       files = path.include?('*') ? Dir[path] : [path]
 
-      if mode == :only_recognized_file_types || force_exclusion?
-        files.select! { |file| included_file?(file) }
-      end
+      files.select! { |file| included_file?(file) } if mode == :only_recognized_file_types || force_exclusion?
 
       return files unless force_exclusion?
 

data/lib/rubocop/version.rb

@@ -3,14 +3,16 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.83.0'
+    STRING = '0.84.0'
 
-    MSG = '%<version>s (using Parser %<parser_version>s, running on ' \
-          '%<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'
+    MSG = '%<version>s (using Parser %<parser_version>s, '\
+          'rubocop-ast %<rubocop_ast_version>s, ' \
+          'running on %<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'
 
     def self.version(debug = false)
       if debug
         format(MSG, version: STRING, parser_version: Parser::VERSION,
+                    rubocop_ast_version: RuboCop::AST::Version::STRING,
                     ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
                     ruby_platform: RUBY_PLATFORM)
       else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 0.83.0
+  version: 0.84.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-11 00:00:00.000000000 Z
+date: 2020-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -74,6 +74,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -148,57 +162,7 @@ files:
 - config/default.yml
 - exe/rubocop
 - lib/rubocop.rb
-- lib/rubocop/ast/builder.rb
-- lib/rubocop/ast/node.rb
-- lib/rubocop/ast/node/alias_node.rb
-- lib/rubocop/ast/node/and_node.rb
-- lib/rubocop/ast/node/args_node.rb
-- lib/rubocop/ast/node/array_node.rb
-- lib/rubocop/ast/node/block_node.rb
-- lib/rubocop/ast/node/break_node.rb
-- lib/rubocop/ast/node/case_match_node.rb
-- lib/rubocop/ast/node/case_node.rb
-- lib/rubocop/ast/node/class_node.rb
-- lib/rubocop/ast/node/def_node.rb
-- lib/rubocop/ast/node/defined_node.rb
-- lib/rubocop/ast/node/ensure_node.rb
-- lib/rubocop/ast/node/float_node.rb
-- lib/rubocop/ast/node/for_node.rb
-- lib/rubocop/ast/node/forward_args_node.rb
-- lib/rubocop/ast/node/hash_node.rb
-- lib/rubocop/ast/node/if_node.rb
-- lib/rubocop/ast/node/int_node.rb
-- lib/rubocop/ast/node/keyword_splat_node.rb
-- lib/rubocop/ast/node/mixin/basic_literal_node.rb
-- lib/rubocop/ast/node/mixin/binary_operator_node.rb
-- lib/rubocop/ast/node/mixin/collection_node.rb
-- lib/rubocop/ast/node/mixin/conditional_node.rb
-- lib/rubocop/ast/node/mixin/hash_element_node.rb
-- lib/rubocop/ast/node/mixin/method_dispatch_node.rb
-- lib/rubocop/ast/node/mixin/method_identifier_predicates.rb
-- lib/rubocop/ast/node/mixin/modifier_node.rb
-- lib/rubocop/ast/node/mixin/numeric_node.rb
-- lib/rubocop/ast/node/mixin/parameterized_node.rb
-- lib/rubocop/ast/node/mixin/predicate_operator_node.rb
-- lib/rubocop/ast/node/module_node.rb
-- lib/rubocop/ast/node/or_node.rb
-- lib/rubocop/ast/node/pair_node.rb
-- lib/rubocop/ast/node/range_node.rb
-- lib/rubocop/ast/node/regexp_node.rb
-- lib/rubocop/ast/node/resbody_node.rb
-- lib/rubocop/ast/node/retry_node.rb
-- lib/rubocop/ast/node/return_node.rb
-- lib/rubocop/ast/node/self_class_node.rb
-- lib/rubocop/ast/node/send_node.rb
-- lib/rubocop/ast/node/str_node.rb
-- lib/rubocop/ast/node/super_node.rb
-- lib/rubocop/ast/node/symbol_node.rb
-- lib/rubocop/ast/node/until_node.rb
-- lib/rubocop/ast/node/when_node.rb
-- lib/rubocop/ast/node/while_node.rb
-- lib/rubocop/ast/node/yield_node.rb
-- lib/rubocop/ast/sexp.rb
-- lib/rubocop/ast/traversal.rb
+- lib/rubocop/ast_aliases.rb
 - lib/rubocop/cached_data.rb
 - lib/rubocop/cli.rb
 - lib/rubocop/cli/command.rb
@@ -356,6 +320,7 @@ files:
 - lib/rubocop/cop/lint/circular_argument_reference.rb
 - lib/rubocop/cop/lint/debugger.rb
 - lib/rubocop/cop/lint/deprecated_class_methods.rb
+- lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb
 - lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb
 - lib/rubocop/cop/lint/duplicate_case_condition.rb
 - lib/rubocop/cop/lint/duplicate_hash_key.rb
@@ -721,6 +686,7 @@ files:
 - lib/rubocop/cop/variable_force/variable_table.rb
 - lib/rubocop/core_ext/string.rb
 - lib/rubocop/error.rb
+- lib/rubocop/ext/processed_source.rb
 - lib/rubocop/file_finder.rb
 - lib/rubocop/formatter/auto_gen_config_formatter.rb
 - lib/rubocop/formatter/base_formatter.rb
@@ -744,11 +710,9 @@ files:
 - lib/rubocop/formatter/worst_offenders_formatter.rb
 - lib/rubocop/magic_comment.rb
 - lib/rubocop/name_similarity.rb
-- lib/rubocop/node_pattern.rb
 - lib/rubocop/options.rb
 - lib/rubocop/path_util.rb
 - lib/rubocop/platform.rb
-- lib/rubocop/processed_source.rb
 - lib/rubocop/rake_task.rb
 - lib/rubocop/remote_config.rb
 - lib/rubocop/result_cache.rb
@@ -761,7 +725,6 @@ files:
 - lib/rubocop/string_interpreter.rb
 - lib/rubocop/target_finder.rb
 - lib/rubocop/target_ruby.rb
-- lib/rubocop/token.rb
 - lib/rubocop/version.rb
 - lib/rubocop/warning.rb
 - lib/rubocop/yaml_duplication_checker.rb

data/lib/rubocop/ast/builder.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # `RuboCop::AST::Builder` is an AST builder that is utilized to let `Parser`
-    # generate ASTs with {RuboCop::AST::Node}.
-    #
-    # @example
-    #   buffer = Parser::Source::Buffer.new('(string)')
-    #   buffer.source = 'puts :foo'
-    #
-    #   builder = RuboCop::AST::Builder.new
-    #   require 'parser/ruby25'
-    #   parser = Parser::Ruby25.new(builder)
-    #   root_node = parser.parse(buffer)
-    class Builder < Parser::Builders::Default
-      NODE_MAP = {
-        and:          AndNode,
-        alias:        AliasNode,
-        args:         ArgsNode,
-        array:        ArrayNode,
-        block:        BlockNode,
-        numblock:     BlockNode,
-        break:        BreakNode,
-        case_match:   CaseMatchNode,
-        case:         CaseNode,
-        class:        ClassNode,
-        def:          DefNode,
-        defined?:     DefinedNode,
-        defs:         DefNode,
-        ensure:       EnsureNode,
-        for:          ForNode,
-        forward_args: ForwardArgsNode,
-        float:        FloatNode,
-        hash:         HashNode,
-        if:           IfNode,
-        int:          IntNode,
-        irange:       RangeNode,
-        erange:       RangeNode,
-        kwsplat:      KeywordSplatNode,
-        module:       ModuleNode,
-        or:           OrNode,
-        pair:         PairNode,
-        regexp:       RegexpNode,
-        resbody:      ResbodyNode,
-        retry:        RetryNode,
-        return:       ReturnNode,
-        csend:        SendNode,
-        send:         SendNode,
-        str:          StrNode,
-        dstr:         StrNode,
-        xstr:         StrNode,
-        sclass:       SelfClassNode,
-        super:        SuperNode,
-        zsuper:       SuperNode,
-        sym:          SymbolNode,
-        until:        UntilNode,
-        until_post:   UntilNode,
-        when:         WhenNode,
-        while:        WhileNode,
-        while_post:   WhileNode,
-        yield:        YieldNode
-      }.freeze
-
-      # Generates {Node} from the given information.
-      #
-      # @return [Node] the generated node
-      def n(type, children, source_map)
-        node_klass(type).new(type, children, location: source_map)
-      end
-
-      # TODO: Figure out what to do about literal encoding handling...
-      # More details here https://github.com/whitequark/parser/issues/283
-      def string_value(token)
-        value(token)
-      end
-
-      private
-
-      def node_klass(type)
-        NODE_MAP[type] || Node
-      end
-    end
-  end
-end

data/lib/rubocop/ast/node.rb

@@ -1,637 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # `RuboCop::AST::Node` is a subclass of `Parser::AST::Node`. It provides
-    # access to parent nodes and an object-oriented way to traverse an AST with
-    # the power of `Enumerable`.
-    #
-    # It has predicate methods for every node type, like this:
-    #
-    # @example
-    #   node.send_type?    # Equivalent to: `node.type == :send`
-    #   node.op_asgn_type? # Equivalent to: `node.type == :op_asgn`
-    #
-    #   # Non-word characters (other than a-zA-Z0-9_) in type names are omitted.
-    #   node.defined_type? # Equivalent to: `node.type == :defined?`
-    #
-    #   # Find the first lvar node under the receiver node.
-    #   lvar_node = node.each_descendant.find(&:lvar_type?)
-    #
-    class Node < Parser::AST::Node # rubocop:disable Metrics/ClassLength
-      include RuboCop::AST::Sexp
-      extend NodePattern::Macros
-
-      # <=> isn't included here, because it doesn't return a boolean.
-      COMPARISON_OPERATORS = %i[== === != <= >= > <].freeze
-
-      TRUTHY_LITERALS = %i[str dstr xstr int float sym dsym array
-                           hash regexp true irange erange complex
-                           rational regopt].freeze
-      FALSEY_LITERALS = %i[false nil].freeze
-      LITERALS = (TRUTHY_LITERALS + FALSEY_LITERALS).freeze
-      COMPOSITE_LITERALS = %i[dstr xstr dsym array hash irange
-                              erange regexp].freeze
-      BASIC_LITERALS = (LITERALS - COMPOSITE_LITERALS).freeze
-      MUTABLE_LITERALS = %i[str dstr xstr array hash
-                            regexp irange erange].freeze
-      IMMUTABLE_LITERALS = (LITERALS - MUTABLE_LITERALS).freeze
-
-      EQUALS_ASSIGNMENTS = %i[lvasgn ivasgn cvasgn gvasgn
-                              casgn masgn].freeze
-      SHORTHAND_ASSIGNMENTS = %i[op_asgn or_asgn and_asgn].freeze
-      ASSIGNMENTS = (EQUALS_ASSIGNMENTS + SHORTHAND_ASSIGNMENTS).freeze
-
-      BASIC_CONDITIONALS = %i[if while until].freeze
-      CONDITIONALS = [*BASIC_CONDITIONALS, :case].freeze
-      VARIABLES = %i[ivar gvar cvar lvar].freeze
-      REFERENCES = %i[nth_ref back_ref].freeze
-      KEYWORDS = %i[alias and break case class def defs defined?
-                    kwbegin do else ensure for if module next
-                    not or postexe redo rescue retry return self
-                    super zsuper then undef until when while
-                    yield].freeze
-      OPERATOR_KEYWORDS = %i[and or].freeze
-      SPECIAL_KEYWORDS = %w[__FILE__ __LINE__ __ENCODING__].freeze
-
-      # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
-      def initialize(type, children = [], properties = {})
-        @mutable_attributes = {}
-
-        # ::AST::Node#initialize freezes itself.
-        super
-
-        # #parent= may be invoked multiple times for a node because there are
-        # pending nodes while constructing AST and they are replaced later.
-        # For example, `lvar` and `send` type nodes are initially created as an
-        # `ident` type node and fixed to the appropriate type later.
-        # So, the #parent attribute needs to be mutable.
-        each_child_node do |child_node|
-          child_node.parent = self unless child_node.complete?
-        end
-      end
-
-      Parser::Meta::NODE_TYPES.each do |node_type|
-        method_name = "#{node_type.to_s.gsub(/\W/, '')}_type?"
-        define_method(method_name) do
-          type == node_type
-        end
-      end
-
-      # Returns the parent node, or `nil` if the receiver is a root node.
-      #
-      # @return [Node, nil] the parent node or `nil`
-      def parent
-        @mutable_attributes[:parent]
-      end
-
-      def parent=(node)
-        @mutable_attributes[:parent] = node
-      end
-
-      def complete!
-        @mutable_attributes.freeze
-        each_child_node(&:complete!)
-      end
-
-      def complete?
-        @mutable_attributes.frozen?
-      end
-
-      protected :parent=
-
-      # Override `AST::Node#updated` so that `AST::Processor` does not try to
-      # mutate our ASTs. Since we keep references from children to parents and
-      # not just the other way around, we cannot update an AST and share
-      # identical subtrees. Rather, the entire AST must be copied any time any
-      # part of it is changed.
-      def updated(type = nil, children = nil, properties = {})
-        properties[:location] ||= @location
-        klass = RuboCop::AST::Builder::NODE_MAP[type || @type] || Node
-        klass.new(type || @type, children || @children, properties)
-      end
-
-      # Returns the index of the receiver node in its siblings. (Sibling index
-      # uses zero based numbering.)
-      #
-      # @return [Integer] the index of the receiver node in its siblings
-      def sibling_index
-        parent&.children&.index { |sibling| sibling.equal?(self) }
-      end
-
-      # Common destructuring method. This can be used to normalize
-      # destructuring for different variations of the node.
-      # Some node types override this with their own custom
-      # destructuring method.
-      #
-      # @return [Array<Node>] the different parts of the ndde
-      def node_parts
-        to_a
-      end
-
-      # Calls the given block for each ancestor node from parent to root.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # @overload each_ancestor
-      #   Yield all nodes.
-      # @overload each_ancestor(type)
-      #   Yield only nodes matching the type.
-      #   @param [Symbol] type a node type
-      # @overload each_ancestor(type_a, type_b, ...)
-      #   Yield only nodes matching any of the types.
-      #   @param [Symbol] type_a a node type
-      #   @param [Symbol] type_b a node type
-      # @yieldparam [Node] node each ancestor node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_ancestor(*types, &block)
-        return to_enum(__method__, *types) unless block_given?
-
-        visit_ancestors(types, &block)
-
-        self
-      end
-
-      # Returns an array of ancestor nodes.
-      # This is a shorthand for `node.each_ancestor.to_a`.
-      #
-      # @return [Array<Node>] an array of ancestor nodes
-      def ancestors
-        each_ancestor.to_a
-      end
-
-      # Calls the given block for each child node.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # Note that this is different from `node.children.each { |child| ... }`
-      # which yields all children including non-node elements.
-      #
-      # @overload each_child_node
-      #   Yield all nodes.
-      # @overload each_child_node(type)
-      #   Yield only nodes matching the type.
-      #   @param [Symbol] type a node type
-      # @overload each_child_node(type_a, type_b, ...)
-      #   Yield only nodes matching any of the types.
-      #   @param [Symbol] type_a a node type
-      #   @param [Symbol] type_b a node type
-      # @yieldparam [Node] node each child node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_child_node(*types)
-        return to_enum(__method__, *types) unless block_given?
-
-        children.each do |child|
-          next unless child.is_a?(Node)
-
-          yield child if types.empty? || types.include?(child.type)
-        end
-
-        self
-      end
-
-      # Returns an array of child nodes.
-      # This is a shorthand for `node.each_child_node.to_a`.
-      #
-      # @return [Array<Node>] an array of child nodes
-      def child_nodes
-        each_child_node.to_a
-      end
-
-      # Calls the given block for each descendant node with depth first order.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # @overload each_descendant
-      #   Yield all nodes.
-      # @overload each_descendant(type)
-      #   Yield only nodes matching the type.
-      #   @param [Symbol] type a node type
-      # @overload each_descendant(type_a, type_b, ...)
-      #   Yield only nodes matching any of the types.
-      #   @param [Symbol] type_a a node type
-      #   @param [Symbol] type_b a node type
-      # @yieldparam [Node] node each descendant node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_descendant(*types, &block)
-        return to_enum(__method__, *types) unless block_given?
-
-        visit_descendants(types, &block)
-
-        self
-      end
-
-      # Returns an array of descendant nodes.
-      # This is a shorthand for `node.each_descendant.to_a`.
-      #
-      # @return [Array<Node>] an array of descendant nodes
-      def descendants
-        each_descendant.to_a
-      end
-
-      # Calls the given block for the receiver and each descendant node in
-      # depth-first order.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # This method would be useful when you treat the receiver node as the root
-      # of a tree and want to iterate over all nodes in the tree.
-      #
-      # @overload each_node
-      #   Yield all nodes.
-      # @overload each_node(type)
-      #   Yield only nodes matching the type.
-      #   @param [Symbol] type a node type
-      # @overload each_node(type_a, type_b, ...)
-      #   Yield only nodes matching any of the types.
-      #   @param [Symbol] type_a a node type
-      #   @param [Symbol] type_b a node type
-      # @yieldparam [Node] node each node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_node(*types, &block)
-        return to_enum(__method__, *types) unless block_given?
-
-        yield self if types.empty? || types.include?(type)
-
-        visit_descendants(types, &block)
-
-        self
-      end
-
-      def source
-        loc.expression.source
-      end
-
-      def source_range
-        loc.expression
-      end
-
-      def first_line
-        loc.line
-      end
-
-      def last_line
-        loc.last_line
-      end
-
-      def line_count
-        return 0 unless source_range
-
-        source_range.last_line - source_range.first_line + 1
-      end
-
-      def nonempty_line_count
-        source.lines.grep(/\S/).size
-      end
-
-      def source_length
-        source_range ? source_range.size : 0
-      end
-
-      ## Destructuring
-
-      def_node_matcher :receiver, <<~PATTERN
-        {(send $_ ...) ({block numblock} (send $_ ...) ...)}
-      PATTERN
-
-      def_node_matcher :str_content, '(str $_)'
-
-      def const_name
-        return unless const_type?
-
-        namespace, name = *self
-        if namespace && !namespace.cbase_type?
-          "#{namespace.const_name}::#{name}"
-        else
-          name.to_s
-        end
-      end
-
-      def_node_matcher :defined_module0, <<~PATTERN
-        {(class (const $_ $_) ...)
-         (module (const $_ $_) ...)
-         (casgn $_ $_        (send (const nil? {:Class :Module}) :new ...))
-         (casgn $_ $_ (block (send (const nil? {:Class :Module}) :new ...) ...))}
-      PATTERN
-
-      private :defined_module0
-
-      def defined_module
-        namespace, name = *defined_module0
-        s(:const, namespace, name) if name
-      end
-
-      def defined_module_name
-        (const = defined_module) && const.const_name
-      end
-
-      ## Searching the AST
-
-      def parent_module_name
-        # what class or module is this method/constant/etc definition in?
-        # returns nil if answer cannot be determined
-        ancestors = each_ancestor(:class, :module, :sclass, :casgn, :block)
-        result    = ancestors.map do |ancestor|
-          parent_module_name_part(ancestor) { |full_name| return full_name }
-        end.compact.reverse.join('::')
-        result.empty? ? 'Object' : result
-      end
-
-      ## Predicates
-
-      def multiline?
-        line_count > 1
-      end
-
-      def single_line?
-        line_count == 1
-      end
-
-      def empty_source?
-        source_length.zero?
-      end
-
-      # Some cops treat the shovel operator as a kind of assignment.
-      def_node_matcher :assignment_or_similar?, <<~PATTERN
-        {assignment? (send _recv :<< ...)}
-      PATTERN
-
-      def literal?
-        LITERALS.include?(type)
-      end
-
-      def basic_literal?
-        BASIC_LITERALS.include?(type)
-      end
-
-      def truthy_literal?
-        TRUTHY_LITERALS.include?(type)
-      end
-
-      def falsey_literal?
-        FALSEY_LITERALS.include?(type)
-      end
-
-      def mutable_literal?
-        MUTABLE_LITERALS.include?(type)
-      end
-
-      def immutable_literal?
-        IMMUTABLE_LITERALS.include?(type)
-      end
-
-      %i[literal basic_literal].each do |kind|
-        recursive_kind = :"recursive_#{kind}?"
-        kind_filter = :"#{kind}?"
-        define_method(recursive_kind) do
-          case type
-          when :send
-            [*COMPARISON_OPERATORS, :!, :<=>].include?(method_name) &&
-              receiver.send(recursive_kind) &&
-              arguments.all?(&recursive_kind)
-          when :begin, :pair, *OPERATOR_KEYWORDS, *COMPOSITE_LITERALS
-            children.compact.all?(&recursive_kind)
-          else
-            send(kind_filter)
-          end
-        end
-      end
-
-      def variable?
-        VARIABLES.include?(type)
-      end
-
-      def reference?
-        REFERENCES.include?(type)
-      end
-
-      def equals_asgn?
-        EQUALS_ASSIGNMENTS.include?(type)
-      end
-
-      def shorthand_asgn?
-        SHORTHAND_ASSIGNMENTS.include?(type)
-      end
-
-      def assignment?
-        ASSIGNMENTS.include?(type)
-      end
-
-      def basic_conditional?
-        BASIC_CONDITIONALS.include?(type)
-      end
-
-      def conditional?
-        CONDITIONALS.include?(type)
-      end
-
-      def keyword?
-        return true if special_keyword? || send_type? && prefix_not?
-        return false unless KEYWORDS.include?(type)
-
-        !OPERATOR_KEYWORDS.include?(type) || loc.operator.is?(type.to_s)
-      end
-
-      def special_keyword?
-        SPECIAL_KEYWORDS.include?(source)
-      end
-
-      def operator_keyword?
-        OPERATOR_KEYWORDS.include?(type)
-      end
-
-      def parenthesized_call?
-        loc.respond_to?(:begin) && loc.begin && loc.begin.is?('(')
-      end
-
-      def call_type?
-        send_type? || csend_type?
-      end
-
-      def chained?
-        parent&.call_type? && eql?(parent.receiver)
-      end
-
-      def argument?
-        parent&.send_type? && parent.arguments.include?(self)
-      end
-
-      def boolean_type?
-        true_type? || false_type?
-      end
-
-      def numeric_type?
-        int_type? || float_type?
-      end
-
-      def range_type?
-        irange_type? || erange_type?
-      end
-
-      def guard_clause?
-        node = and_type? || or_type? ? rhs : self
-
-        node.match_guard_clause?
-      end
-
-      def_node_matcher :match_guard_clause?, <<~PATTERN
-        [${(send nil? {:raise :fail} ...) return break next} single_line?]
-      PATTERN
-
-      def_node_matcher :proc?, <<~PATTERN
-        {(block (send nil? :proc) ...)
-         (block (send (const nil? :Proc) :new) ...)
-         (send (const nil? :Proc) :new)}
-      PATTERN
-
-      def_node_matcher :lambda?, '({block numblock} (send nil? :lambda) ...)'
-      def_node_matcher :lambda_or_proc?, '{lambda? proc?}'
-
-      def_node_matcher :class_constructor?, <<~PATTERN
-        {       (send (const nil? {:Class :Module}) :new ...)
-         (block (send (const nil? {:Class :Module}) :new ...) ...)}
-      PATTERN
-
-      # Some expressions are evaluated for their value, some for their side
-      # effects, and some for both
-      # If we know that an expression is useful only for its side effects, that
-      # means we can transform it in ways which preserve the side effects, but
-      # change the return value
-      # So, does the return value of this node matter? If we changed it to
-      # `(...; nil)`, might that affect anything?
-      #
-      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-      def value_used?
-        # Be conservative and return true if we're not sure.
-        return false if parent.nil?
-
-        case parent.type
-        when :array, :defined?, :dstr, :dsym, :eflipflop, :erange, :float,
-             :hash, :iflipflop, :irange, :not, :pair, :regexp, :str, :sym,
-             :when, :xstr
-          parent.value_used?
-        when :begin, :kwbegin
-          begin_value_used?
-        when :for
-          for_value_used?
-        when :case, :if
-          case_if_value_used?
-        when :while, :until, :while_post, :until_post
-          while_until_value_used?
-        else
-          true
-        end
-      end
-      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
-
-      # Some expressions are evaluated for their value, some for their side
-      # effects, and some for both.
-      # If we know that expressions are useful only for their return values,
-      # and have no side effects, that means we can reorder them, change the
-      # number of times they are evaluated, or replace them with other
-      # expressions which are equivalent in value.
-      # So, is evaluation of this node free of side effects?
-      #
-      def pure?
-        # Be conservative and return false if we're not sure
-        case type
-        when :__FILE__, :__LINE__, :const, :cvar, :defined?, :false, :float,
-             :gvar, :int, :ivar, :lvar, :nil, :str, :sym, :true, :regopt
-          true
-        when :and, :array, :begin, :case, :dstr, :dsym, :eflipflop, :ensure,
-             :erange, :for, :hash, :if, :iflipflop, :irange, :kwbegin, :not,
-             :or, :pair, :regexp, :until, :until_post, :when, :while,
-             :while_post
-          child_nodes.all?(&:pure?)
-        else
-          false
-        end
-      end
-
-      protected
-
-      def visit_descendants(types, &block)
-        each_child_node do |child|
-          yield child if types.empty? || types.include?(child.type)
-          child.visit_descendants(types, &block)
-        end
-      end
-
-      private
-
-      def visit_ancestors(types)
-        last_node = self
-
-        while (current_node = last_node.parent)
-          yield current_node if types.empty? ||
-                                types.include?(current_node.type)
-          last_node = current_node
-        end
-      end
-
-      def begin_value_used?
-        # the last child node determines the value of the parent
-        sibling_index == parent.children.size - 1 ? parent.value_used? : false
-      end
-
-      def for_value_used?
-        # `for var in enum; body; end`
-        # (for <var> <enum> <body>)
-        sibling_index == 2 ? parent.value_used? : true
-      end
-
-      def case_if_value_used?
-        # (case <condition> <when...>)
-        # (if <condition> <truebranch> <falsebranch>)
-        sibling_index.zero? ? true : parent.value_used?
-      end
-
-      def while_until_value_used?
-        # (while <condition> <body>) -> always evaluates to `nil`
-        sibling_index.zero?
-      end
-
-      def parent_module_name_part(node)
-        case node.type
-        when :class, :module, :casgn
-          # TODO: if constant name has cbase (leading ::), then we don't need
-          # to keep traversing up through nested classes/modules
-          node.defined_module_name
-        when :sclass
-          yield parent_module_name_for_sclass(node)
-        else # block
-          parent_module_name_for_block(node) { yield nil }
-        end
-      end
-
-      def parent_module_name_for_sclass(sclass_node)
-        # TODO: look for constant definition and see if it is nested
-        # inside a class or module
-        subject = sclass_node.children[0]
-
-        if subject.const_type?
-          "#<Class:#{subject.const_name}>"
-        elsif subject.self_type?
-          "#<Class:#{sclass_node.parent_module_name}>"
-        end
-      end
-
-      def parent_module_name_for_block(ancestor)
-        if ancestor.method?(:class_eval)
-          # `class_eval` with no receiver applies to whatever module or class
-          # we are currently in
-          return unless (receiver = ancestor.receiver)
-
-          yield unless receiver.const_type?
-          receiver.const_name
-        elsif !new_class_or_module_block?(ancestor)
-          yield
-        end
-      end
-
-      def_node_matcher :new_class_or_module_block?, <<~PATTERN
-        ^(casgn _ _ (block (send (const _ {:Class :Module}) :new) ...))
-      PATTERN
-    end
-  end
-end