Add and configure new Rubocop cops

Author: andrykonchin

.rubocop.yml

@@ -1,3 +1,9 @@
+require:
+  - ./tool/rubocop-truffleruby/cop/replace_with_primitive_nil.rb
+  - ./tool/rubocop-truffleruby/cop/replace_with_primitive_object_class.rb
+  - ./tool/rubocop-truffleruby/cop/replace_with_primitive_object_equal.rb
+  - ./tool/rubocop-truffleruby/cop/replace_with_primitive_object_kind_of.rb
+
 AllCops:
   TargetRubyVersion: 3.1
   DisabledByDefault: true
@@ -389,4 +395,28 @@ Layout/SpaceInsideBlockBraces:
 # Supports --auto-correct
 Layout/SpaceAroundEqualsInParameterDefault:
   Description: Checks that the equals signs in parameter default assignments have or don't have surrounding space depending on configuration.
-  Enabled: true
+  Enabled: true
+
+# Supports --auto-correct
+TruffleRuby/ReplaceWithPrimitiveNil:
+  Enabled: true
+  Include: # inspect *only* this directory
+    - src/main/ruby/**/*.rb
+
+# Supports --auto-correct
+TruffleRuby/ReplaceWithPrimitiveObjectClass:
+  Enabled: true
+  Include: # inspect *only* this directory
+    - src/main/ruby/**/*.rb
+
+# Supports --auto-correct
+TruffleRuby/ReplaceWithPrimitiveObjectEqual:
+  Enabled: true
+  Include: # inspect *only* this directory
+    - src/main/ruby/**/*.rb
+
+# Supports --auto-correct
+TruffleRuby/ReplaceWithPrimitiveObjectKindOf:
+  Enabled: true
+  Include: # inspect *only* this directory
+    - src/main/ruby/**/*.rb

tool/rubocop-truffleruby/cop/replace_with_primitive_nil.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module TruffleRuby
+      # Prefer Primitive method `nil?` to check whether object is `nil`
+      #
+      # @example
+      #
+      #   # bad
+      #   object.nil?
+      #
+      #   # bad
+      #   object == nil
+      #
+      #   # bad
+      #   object != nil
+      #
+      #   # bad
+      #   object.equal?(nil)
+      #
+      #   # bad
+      #   nil.equal?(object)
+      #
+      #   # bad
+      #   Primitive.object_equal(nil, object)
+      #
+      #   # bad
+      #   Primitive.object_equal(object, nil)
+      #
+      #   # good
+      #   Primitive.nil?(object)
+      #
+      class ReplaceWithPrimitiveNil < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Primitive.nil?` instead of `Object#nil?` or `object == nil`'
+        RESTRICT_ON_SEND = %i[nil? == != equal? object_equal].freeze
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          {
+            (send $_ :nil?)
+            (send $_ :== nil)
+            (send $_ :!= nil)
+            (send nil :equal? $_)
+            (send $_ :equal? nil)
+            (send (const {nil? cbase} :Primitive) :object_equal $_ nil)
+            (send (const {nil? cbase} :Primitive) :object_equal nil $_)
+          }
+        PATTERN
+
+        def on_send(node)
+          receiver = bad_method?(node)
+          return unless receiver
+
+          add_offense(node) do |corrector|
+            source_string = "Primitive.nil?(#{receiver.source})"
+            source_string = "!#{source_string}" if node.method_name == :!=
+            corrector.replace(node.loc.expression, source_string)
+          end
+        end
+      end
+    end
+  end
+end

tool/rubocop-truffleruby/cop/replace_with_primitive_object_class.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module TruffleRuby
+      # Prefer Primitive method `object_class` to get a logical class of an object.
+      #
+      # @example
+      #
+      #   # bad
+      #   object.class
+      #
+      #   # good
+      #   Primitive.object_class(object)
+      #
+      class ReplaceWithPrimitiveObjectClass < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Primitive.object_class` instead of `Object#class`'
+        RESTRICT_ON_SEND = %i[class].freeze
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          (send $_ :class)
+        PATTERN
+
+        def on_send(node)
+          receiver = bad_method?(node)
+          return unless receiver
+
+          add_offense(node) do |corrector|
+            source_string = "Primitive.object_class(#{receiver.source})"
+            corrector.replace(node.loc.expression, source_string)
+          end
+        end
+      end
+    end
+  end
+end

tool/rubocop-truffleruby/cop/replace_with_primitive_object_equal.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module TruffleRuby
+      # Prefer Primitive method `object_equal` to check whether two objects are
+      # the same object.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo.equal?(bar)
+      #
+      #   # good
+      #   Primitive.object_equal(foo, bar)
+      #
+      class ReplaceWithPrimitiveObjectEqual < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Primitive.object_equal` instead of `#equal?`'
+        RESTRICT_ON_SEND = %i[equal?].freeze
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          (send $_ :equal? $_)
+        PATTERN
+
+        def on_send(node)
+          captures = bad_method?(node)
+          return unless captures
+
+          add_offense(node) do |corrector|
+            receiver, argument = captures.map { |n| n&.source }
+            receiver ||= 'self'
+
+            source_string = "Primitive.object_equal(#{receiver}, #{argument})"
+            corrector.replace(node.loc.expression, source_string)
+          end
+        end
+      end
+    end
+  end
+end

tool/rubocop-truffleruby/cop/replace_with_primitive_object_kind_of.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module TruffleRuby
+      # Prefer Primitive method `object_kind_of?` to check an object class for
+      # performance reasons.
+      #
+      # @safety
+      #   This cop is unsafe because #=== call's receiver might be not a module.
+      #
+      # @example
+      #
+      #   # bad
+      #   a.is_a?(String)
+      #
+      #   # bad
+      #   a.kind_of?(String)
+      #
+      #   # bad
+      #   String === a
+      #
+      #   # good
+      #   Primitive.object_kind_of?(a, String)
+      #
+      class ReplaceWithPrimitiveObjectKindOf < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Primitive.object_kind_of?` instead of `#kind_of?` or `#is_a?`'
+        RESTRICT_ON_SEND = %i[is_a? kind_of? ===].freeze
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          {
+            (send $_ { :is_a? :kind_of? } $_)
+            (send $const :=== $_)
+          }
+        PATTERN
+
+        def on_send(node)
+          captures = bad_method?(node)
+          return unless captures
+
+          add_offense(node) do |corrector|
+            source_string = build_expression_to_replace_by(node, captures)
+            corrector.replace(node.loc.expression, source_string)
+          end
+        end
+
+        private
+
+        def build_expression_to_replace_by(node, captures)
+          if node.method_name == :===
+            object = captures[1].source
+            constant = captures[0].source
+          else
+            object = captures[0]&.source || 'self'
+            constant = captures[1].source
+          end
+
+          "Primitive.object_kind_of?(#{object}, #{constant})"
+        end
+      end
+    end
+  end
+end