Remove redundant nil checks in RBI::Visitor

lib/rbi/index.rb

@@ -77,6 +77,8 @@ module Indexable
 
     interface!
 
+    requires_ancestor { Node }
+
     # Unique IDs that refer to this node.
     #
     # Some nodes can have multiple ids, for example an attribute accessor matches the ID of the

lib/rbi/rewriters/annotate.rb

@@ -22,6 +22,7 @@ def visit(node)
         when Const, Attr, Method, TStructField, TypeMember
           annotate_node(node) if @annotate_properties
         end
+
         visit_all(node.nodes) if node.is_a?(Tree)
       end
 

lib/rbi/rewriters/deannotate.rb

@@ -18,6 +18,7 @@ def visit(node)
         when Scope, Const, Attr, Method, TStructField, TypeMember
           deannotate_node(node)
         end
+
         visit_all(node.nodes) if node.is_a?(Tree)
       end
 

lib/rbi/rewriters/group_nodes.rb

@@ -8,24 +8,21 @@ class GroupNodes < Visitor
 
       sig { override.params(node: T.nilable(Node)).void }
       def visit(node)
-        return unless node
+        return unless node.is_a?(Tree)
 
-        case node
-        when Tree
-          kinds = node.nodes.map { |child| group_kind(child) }
-          kinds.uniq!
-
-          groups = {}
-          kinds.each { |kind| groups[kind] = Group.new(kind) }
+        kinds = node.nodes.map { |child| group_kind(child) }
+        kinds.uniq!
 
-          node.nodes.dup.each do |child|
-            visit(child)
-            child.detach
-            groups[group_kind(child)] << child
-          end
+        groups = {}
+        kinds.each { |kind| groups[kind] = Group.new(kind) }
 
-          groups.each { |_, group| node << group }
+        node.nodes.dup.each do |child|
+          visit(child)
+          child.detach
+          groups[group_kind(child)] << child
         end
+
+        groups.each { |_, group| node << group }
       end
 
       private

lib/rbi/rewriters/merge_trees.rb

@@ -117,8 +117,6 @@ def initialize(output, left_name: "left", right_name: "right", keep: Keep::NONE)
 
         sig { override.params(node: T.nilable(Node)).void }
         def visit(node)
-          return unless node
-
           case node
           when Scope
             prev = previous_definition(node)

lib/rbi/rewriters/nest_non_public_methods.rb

@@ -8,33 +8,30 @@ class NestNonPublicMethods < Visitor
 
       sig { override.params(node: T.nilable(Node)).void }
       def visit(node)
-        return unless node
-
-        case node
-        when Tree
-          public_group = VisibilityGroup.new(Public.new)
-          protected_group = VisibilityGroup.new(Protected.new)
-          private_group = VisibilityGroup.new(Private.new)
-
-          node.nodes.dup.each do |child|
-            visit(child)
-            next unless child.is_a?(Method)
-
-            child.detach
-            case child.visibility
-            when Protected
-              protected_group << child
-            when Private
-              private_group << child
-            else
-              public_group << child
-            end
+        return unless node.is_a?(Tree)
+
+        public_group = VisibilityGroup.new(Public.new)
+        protected_group = VisibilityGroup.new(Protected.new)
+        private_group = VisibilityGroup.new(Private.new)
+
+        node.nodes.dup.each do |child|
+          visit(child)
+          next unless child.is_a?(Method)
+
+          child.detach
+          case child.visibility
+          when Protected
+            protected_group << child
+          when Private
+            private_group << child
+          else
+            public_group << child
           end
-
-          node << public_group unless public_group.empty?
-          node << protected_group unless protected_group.empty?
-          node << private_group unless private_group.empty?
         end
+
+        node << public_group unless public_group.empty?
+        node << protected_group unless protected_group.empty?
+        node << private_group unless private_group.empty?
       end
     end
   end

lib/rbi/rewriters/nest_singleton_methods.rb

@@ -8,23 +8,20 @@ class NestSingletonMethods < Visitor
 
       sig { override.params(node: T.nilable(Node)).void }
       def visit(node)
-        return unless node
+        return unless node.is_a?(Tree)
 
-        case node
-        when Tree
-          singleton_class = SingletonClass.new
+        singleton_class = SingletonClass.new
 
-          node.nodes.dup.each do |child|
-            visit(child)
-            next unless child.is_a?(Method) && child.is_singleton
+        node.nodes.dup.each do |child|
+          visit(child)
+          next unless child.is_a?(Method) && child.is_singleton
 
-            child.detach
-            child.is_singleton = false
-            singleton_class << child
-          end
-
-          node << singleton_class unless singleton_class.empty?
+          child.detach
+          child.is_singleton = false
+          singleton_class << child
         end
+
+        node << singleton_class unless singleton_class.empty?
       end
     end
   end

lib/rbi/rewriters/remove_known_definitions.rb

@@ -81,8 +81,6 @@ def visit_all(nodes)
 
       sig { override.params(node: T.nilable(Node)).void }
       def visit(node)
-        return unless node
-
         case node
         when Scope
           visit_all(node.nodes)

lib/rbi/rewriters/sort_nodes.rb

@@ -13,28 +13,28 @@ def visit(node)
         return unless node.is_a?(Tree)
 
         visit_all(node.nodes)
-        original_order = node.nodes.map.with_index.to_h
+        original_order = node.nodes.each_with_index.to_h
 
         # The child nodes could contain private/protected markers. If so, they should not be moved in the file.
         # Otherwise, some methods could see their privacy change. To avoid that problem, divide the array of child
         # nodes into chunks based on whether any Visibility nodes appear, and sort the chunks independently. This
         # applies the ordering rules from the node_rank method as much as possible, while preserving visibility.
-        sorted_nodes = node.nodes.chunk do |n|
-          n.is_a?(Visibility)
-        end.flat_map do |_, nodes|
-          nodes.sort! do |a, b|
-            # First we try to compare the nodes by their node rank (based on the node type)
-            res = node_rank(a) <=> node_rank(b)
-            next res if res != 0 # we can sort the nodes by their rank, let's stop here
+        sorted_nodes = node.nodes
+          .chunk { |n| n.is_a?(Visibility) }
+          .flat_map do |_, nodes|
+            nodes.sort! do |a, b|
+              # First we try to compare the nodes by their node rank (based on the node type)
+              res = node_rank(a) <=> node_rank(b)
+              next res if res != 0 # we can sort the nodes by their rank, let's stop here
 
-            # Then, if the nodes ranks are the same (res == 0), we try to compare the nodes by their name
-            res = node_name(a) <=> node_name(b)
-            next res if res && res != 0 # we can sort the nodes by their name, let's stop here
+              # Then, if the nodes ranks are the same (res == 0), we try to compare the nodes by their name
+              res = node_name(a) <=> node_name(b)
+              next res if res && res != 0 # we can sort the nodes by their name, let's stop here
 
-            # Finally, if the two nodes have the same rank and the same name or at least one node is anonymous then,
-            T.must(original_order[a]) <=> T.must(original_order[b]) # we keep the original order
+              # Finally, if the two nodes have the same rank and the same name or at least one node is anonymous then,
+              T.must(original_order[a]) <=> T.must(original_order[b]) # we keep the original order
+            end
           end
-        end
 
         node.nodes.replace(sorted_nodes)
       end