Add AndNode

lib/syntax_tree/dsl.rb

@@ -36,6 +36,16 @@ def AliasNode(left, right)
       AliasNode.new(left: left, right: right, location: Location.default)
     end
 
+    # Create a new AndNode node.
+    def AndNode(left, operator, right)
+      AndNode.new(
+        left: left,
+        operator: operator,
+        right: right,
+        location: Location.default
+      )
+    end
+
     # Create a new ARef node.
     def ARef(collection, index)
       ARef.new(collection: collection, index: index, location: Location.default)

lib/syntax_tree/field_visitor.rb

@@ -73,6 +73,15 @@ def visit_alias(node)
         end
       end
 
+      def visit_and(node)
+        node(node, "and") do
+          field("left", node.left)
+          text("operator", node.operator)
+          field("right", node.right)
+          comments(node)
+        end
+      end
+
       def visit_arg_block(node)
         node(node, "arg_block") do
           field("value", node.value) if node.value

lib/syntax_tree/mutation_visitor.rb

@@ -65,6 +65,11 @@ def visit_alias(node)
         node.copy(left: visit(node.left), right: visit(node.right))
       end
 
+      # Visit a AndNode node.
+      def visit_and(node)
+        node.copy(left: visit(node.left), right: visit(node.right))
+      end
+
       # Visit a ARef node.
       def visit_aref(node)
         node.copy(index: visit(node.index))

lib/syntax_tree/node.rb

@@ -551,6 +551,96 @@ def var_alias?
     end
   end
 
+  class AndNode < Node
+    # Since AndNode's operator is a symbol, it's better to use the `name` method
+    # than to allocate a new string every time. This is a tiny performance
+    # optimization, but enough that it shows up in the profiler. Adding this in
+    # for older Ruby versions.
+    unless :+.respond_to?(:name)
+      using Module.new {
+              refine Symbol do
+                def name
+                  to_s.freeze
+                end
+              end
+            }
+    end
+
+    # [Node] the left side of the && operator
+    attr_reader :left
+
+    # [Symbol] the operator
+    attr_reader :operator
+
+    # [Node] the right side of the && operator
+    attr_reader :right
+
+    # [Array[ Comment | EmbDoc ]] the comments attached to this node
+    attr_reader :comments
+
+    def initialize(left:, operator:, right:, location:)
+      @left = left
+      @operator = operator
+      @right = right
+      @location = location
+      @comments = []
+    end
+
+    def accept(visitor)
+      visitor.visit_and(self)
+    end
+
+    def child_nodes
+      [left, right]
+    end
+
+    def copy(left: nil, operator: nil, right: nil, location: nil)
+      node =
+        AndNode.new(
+          left: left || self.left,
+          operator: operator || self.operator,
+          right: right || self.right,
+          location: location || self.location
+        )
+      node.comments.concat(comments.map(&:copy))
+      node
+    end
+
+    alias deconstruct child_nodes
+
+    def deconstruct_keys(_keys)
+      {
+        left: left,
+        operator: operator,
+        right: right,
+        location: location,
+        comments: comments
+      }
+    end
+
+    def format(q)
+      left = self.left
+
+      q.group do
+        q.group { q.format(left) }
+        q.text(" ")
+
+        q.group do
+          q.text(operator.name)
+          q.indent do
+            q.breakable_space
+            q.format(right)
+          end
+        end
+      end
+    end
+
+    def ===(other)
+      other.is_a?(AndNode) && left === other.left &&
+        operator === other.operator && right === other.right
+    end
+  end
+
   # ARef represents when you're pulling a value out of a collection at a
   # specific index. Put another way, it's any time you're calling the method
   # #[].
@@ -6267,7 +6357,7 @@ def call(q, node)
         # want to force it to not be a ternary, like if the predicate is an
         # assignment because it's hard to read.
         case node.predicate
-        when Assign, Binary, Command, CommandCall, MAssign, OpAssign
+        when Assign, AndNode, Binary, Command, CommandCall, MAssign, OpAssign
           return false
         when Not
           return false unless node.predicate.parentheses?

lib/syntax_tree/parser.rb

@@ -893,12 +893,22 @@ def on_binary(left, operator, right)
         operator = tokens.delete(operator).value
       end
 
-      Binary.new(
-        left: left,
-        operator: operator,
-        right: right,
-        location: left.location.to(right.location)
-      )
+      case operator
+      when :"&&", :and
+        AndNode.new(
+          left: left,
+          operator: operator,
+          right: right,
+          location: left.location.to(right.location)
+        )
+      else
+        Binary.new(
+          left: left,
+          operator: operator,
+          right: right,
+          location: left.location.to(right.location)
+        )
+      end
     end
 
     # :call-seq:

lib/syntax_tree/pretty_print_visitor.rb

@@ -9,6 +9,17 @@ def initialize(q)
       @q = q
     end
 
+    # This is here because we need to make sure the operator is cast to a string
+    # before we print it out.
+    def visit_and(node)
+      node(node, "and") do
+        field("left", node.left)
+        text("operator", node.operator.to_s)
+        field("right", node.right)
+        comments(node)
+      end
+    end
+
     # This is here because we need to make sure the operator is cast to a string
     # before we print it out.
     def visit_binary(node)

lib/syntax_tree/translation/parser.rb

@@ -468,6 +468,18 @@ def visit_begin(node)
           end
         end
 
+        # Visit a AndNode node.
+        def visit_and(node)
+          s(
+            :and,
+            [visit(node.left), visit(node.right)],
+            smap_operator(
+              srange_find_between(node.left, node.right, node.operator.to_s),
+              srange_node(node)
+            )
+          )
+        end
+
         # Visit a Binary node.
         def visit_binary(node)
           case node.operator
@@ -482,9 +494,9 @@ def visit_binary(node)
             else
               visit(canonical_binary(node))
             end
-          when :"=>", :"&&", :and, :"||", :or
+          when :"=>", :"||", :or
             s(
-              { "=>": :match_as, "&&": :and, "||": :or }.fetch(
+              { "=>": :match_as, "||": :or }.fetch(
                 node.operator,
                 node.operator
               ),

lib/syntax_tree/visitor.rb

@@ -14,6 +14,9 @@ class Visitor < BasicVisitor
     # Visit an AliasNode node.
     alias visit_alias visit_child_nodes
 
+    # Visit an AndNode node.
+    alias visit_and visit_child_nodes
+
     # Visit an ArgBlock node.
     alias visit_arg_block visit_child_nodes
 

lib/syntax_tree/yarv/compiler.rb

@@ -543,18 +543,20 @@ def visit_bare_assoc_hash(node)
       def visit_begin(node)
       end
 
-      def visit_binary(node)
-        case node.operator
-        when :"&&"
-          done_label = iseq.label
+      def visit_and(node)
+        done_label = iseq.label
 
-          visit(node.left)
-          iseq.dup
-          iseq.branchunless(done_label)
+        visit(node.left)
+        iseq.dup
+        iseq.branchunless(done_label)
 
-          iseq.pop
-          visit(node.right)
-          iseq.push(done_label)
+        iseq.pop
+        visit(node.right)
+        iseq.push(done_label)
+      end
+
+      def visit_binary(node)
+        case node.operator
         when :"||"
           visit(node.left)
           iseq.dup