Only short circuit against the left-most operand

And cleanup the test

Author: mshockwave

llvm/docs/TableGen/ProgRef.rst

@@ -1646,7 +1646,7 @@ and non-0 as true.
 ``!and(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise AND on *a*, *b*, etc., and produces the
     result. A logical AND can be performed if all the arguments are either
-    0 or 1. This operator is short-circuit to 0 when one of the operands
+    0 or 1. This operator is short-circuit to 0 when the left-most operand
     is 0.
 
 ``!cast<``\ *type*\ ``>(``\ *a*\ ``)``
@@ -1873,8 +1873,8 @@ and non-0 as true.
 ``!or(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise OR on *a*, *b*, etc., and produces the
     result. A logical OR can be performed if all the arguments are either
-    0 or 1. This operator is short-circuit to -1 (all ones) if one of the
-    operands is -1.
+    0 or 1. This operator is short-circuit to -1 (all ones) the left-most
+    operand is -1.
 
 ``!range([``\ *start*\ ``,]`` *end*\ ``[,``\ *step*\ ``])``
     This operator produces half-open range sequence ``[start : end : step)`` as

llvm/lib/TableGen/Record.cpp

@@ -1558,12 +1558,6 @@ const Init *BinOpInit::resolveReferences(Resolver &R) const {
           (Opc == OR && LHSi->getValue() == -1))
         return LHSi;
     }
-    if (const auto *RHSi = dyn_cast_or_null<IntInit>(
-            rhs->convertInitializerTo(IntRecTy::get(getRecordKeeper())))) {
-      if ((Opc == AND && !RHSi->getValue()) ||
-          (Opc == OR && RHSi->getValue() == -1))
-        return RHSi;
-    }
   }
 
   if (LHS != lhs || RHS != rhs)

llvm/test/TableGen/true-false.td

@@ -72,15 +72,11 @@ def rec7 {
 // CHECK: def rec8
 // CHECK:   list<int> newSeq = [];
 // CHECK:   list<int> newSeq2 = [];
-// CHECK:   list<int> newSeq3 = [];
-// CHECK:   list<int> newSeq4 = [];
 
 class Foo <list<int> seq = []> {
-  bit containsStr = !ne(!find(NAME, "BAR"), -1);
-  list<int> newSeq  = !if(!and(!not(!empty(seq)), containsStr), !tail(seq), seq);
-  list<int> newSeq2 = !if(!and(containsStr, !not(!empty(seq))), !tail(seq), seq);
-  list<int> newSeq3 = !if(!or(containsStr, -1), seq, !tail(seq));
-  list<int> newSeq4 = !if(!or(-1, containsStr), seq, !tail(seq));
+  bit unresolved = !ne(!find(NAME, "BAR"), -1);
+  list<int> newSeq  = !if(!and(false, unresolved), !tail(seq), seq);
+  list<int> newSeq2 = !if(!or(-1, unresolved), seq, !tail(seq));
 }
 
 def rec8 : Foo<>;