[CIR][CodeGen] Emit dtor properly for objects in TernaryOp (llvm#1614)

Currently, the following code snippet fails with a crash: 
```
#include <stdio.h>

struct X {
  int a;
  X(int a) : a(a) {}
  ~X() {}
};

bool foo(const X &) { return false; }
bool bar() { return foo(1) || foo(2); }
```
it fails with 
```
error: 'cir.yield' op must be the last operation in the parent block
```
The crash can be traced to the [construction of the
TernaryOp](https://github.com/llvm/clangir/blob/5df50096be1a783c26b48ea437523347df8a3110/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp#L2728).
A
[yield](https://github.com/llvm/clangir/blob/5df50096be1a783c26b48ea437523347df8a3110/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp#L2776)
is created and when the LexicalScope is destroyed the destructors for
the object follow.

So, the CIR looks something like:
```
%11 = "cir.ternary"(%10) ({
    %13 = "cir.const"() <{value = #cir.bool<true> : !cir.bool}> : () -> !cir.bool
    "cir.yield"(%13) : (!cir.bool) -> ()
}, {
    %12 = "cir.const"() <{value = #cir.bool<false> : !cir.bool}> : () -> !cir.bool
    "cir.yield"(%12) : (!cir.bool) -> ()
}) : (!cir.bool) -> !cir.bool
"cir.yield"(%11) : (!cir.bool) -> ()
"cir.call"(%7) <{callee = @_ZN1XD2Ev, calling_conv = 1 : i32, extra_attrs = #cir<extra({nothrow = #cir.nothrow})>, side_effect = 1 : i32}> ({
}) 
```
which is wrong, since the yield should come last. 

The fix here is forcing a cleanup and then the yield follows. A similar
rule also applies
[here](https://github.com/llvm/clangir/blob/5df50096be1a783c26b48ea437523347df8a3110/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp#L2657)
for the "&&" case, e.g., foo(1) && foo(2) instead in the code snippet.

One more modification I made is adding a check for when the current
lexScope is ternary, when creating dispatch blocks for cleanups. I
believe in this case, we do not want to create a dispatch block, please
correct me if I am wrong.

Finally, I add two tests to verify that everything works as intended.

Author: bruteforceboy

clang/lib/CIR/CodeGen/CIRGenException.cpp

@@ -806,6 +806,8 @@ CIRGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si,
                "one per call: expected empty region at this point");
         dispatchBlock = builder.createBlock(&callWithExceptionCtx.getCleanup());
         builder.createYield(callWithExceptionCtx.getLoc());
+      } else if (currLexScope && currLexScope->isTernary()) {
+        break;
       } else {
         // Usually coming from general cir.scope cleanups that aren't
         // tried to a specific throwing call.

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -2677,6 +2677,7 @@ mlir::Value ScalarExprEmitter::VisitBinLAnd(const clang::BinaryOperator *E) {
               auto res = b.create<cir::ConstantOp>(Loc, Builder.getFalseAttr());
               b.create<cir::YieldOp>(Loc, res.getRes());
             });
+        LexScope.ForceCleanup();
         B.create<cir::YieldOp>(Loc, res.getResult());
       },
       /*falseBuilder*/
@@ -2772,6 +2773,7 @@ mlir::Value ScalarExprEmitter::VisitBinLOr(const clang::BinaryOperator *E) {
               auto res = b.create<cir::ConstantOp>(Loc, Builder.getFalseAttr());
               b.create<cir::YieldOp>(Loc, res.getRes());
             });
+        LexScope.ForceCleanup();
         B.create<cir::YieldOp>(Loc, res.getResult());
       });
 

clang/test/CIR/CodeGen/dtors.cpp

@@ -50,6 +50,61 @@ class B : public A
 // CHECK:   cir.return
 // CHECK: }
 
+struct X {
+  int a;
+  X(int a) : a(a) {}
+  ~X() {}
+};
+
+bool foo(const X &) { return false; }
+bool bar() { return foo(1) || foo(2); }
+
+// CHECK: cir.func @_Z3barv()
+// CHECK:   %[[V0:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"] {alignment = 1 : i64}
+// CHECK:   cir.scope {
+// CHECK:     %[[V2:.*]] = cir.alloca !rec_X, !cir.ptr<!rec_X>, ["ref.tmp0"] {alignment = 4 : i64}
+// CHECK:     %[[V3:.*]] = cir.const #cir.int<1> : !s32i
+// CHECK:     cir.call @_ZN1XC2Ei(%[[V2]], %[[V3]]) : (!cir.ptr<!rec_X>, !s32i) -> ()
+// CHECK:     %[[V4:.*]] = cir.call @_Z3fooRK1X(%[[V2]]) : (!cir.ptr<!rec_X>) -> !cir.bool
+// CHECK:     %[[V5:.*]] = cir.ternary(%[[V4]], true {
+// CHECK:       %[[V6:.*]] = cir.const #true
+// CHECK:       cir.yield %[[V6]] : !cir.bool
+// CHECK:     }, false {
+// CHECK:       %[[V6:.*]] = cir.alloca !rec_X, !cir.ptr<!rec_X>, ["ref.tmp1"] {alignment = 4 : i64}
+// CHECK:       %[[V7:.*]] = cir.const #cir.int<2> : !s32i
+// CHECK:       cir.call @_ZN1XC2Ei(%[[V6]], %[[V7]]) : (!cir.ptr<!rec_X>, !s32i) -> ()
+// CHECK:       %[[V8:.*]] = cir.call @_Z3fooRK1X(%[[V6]]) : (!cir.ptr<!rec_X>) -> !cir.bool
+// CHECK:       %[[V9:.*]] = cir.ternary(%[[V8]], true {
+// CHECK:         %[[V10:.*]] = cir.const #true
+// CHECK:         cir.yield %[[V10]] : !cir.bool
+// CHECK:       }, false {
+// CHECK:         %[[V10:.*]] = cir.const #false
+// CHECK:         cir.yield %[[V10]] : !cir.bool
+// CHECK:       }) : (!cir.bool) -> !cir.bool
+// CHECK:       cir.call @_ZN1XD2Ev(%[[V6]]) : (!cir.ptr<!rec_X>) -> ()
+// CHECK:       cir.yield %[[V9]] : !cir.bool
+// CHECK:     }) : (!cir.bool) -> !cir.bool
+// CHECK:     cir.store %[[V5]], %[[V0]] : !cir.bool, !cir.ptr<!cir.bool>
+// CHECK:     cir.call @_ZN1XD2Ev(%[[V2]]) : (!cir.ptr<!rec_X>) -> ()
+// CHECK:   }
+// CHECK:   %[[V1:.*]] = cir.load %[[V0]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:   cir.return %[[V1]] : !cir.bool
+// CHECK: }
+
+bool bar2() { return foo(1) && foo(2); }
+
+// CHECK:  cir.func @_Z4bar2v()
+// CHECK:     cir.alloca !rec_X, !cir.ptr<!rec_X>
+// CHECK:       {{.*}} = cir.ternary({{.*}}, true {
+// CHECK:         cir.alloca !rec_X, !cir.ptr<!rec_X>
+// CHECK:         cir.call @_ZN1XD2Ev
+// CHECK:         cir.yield
+// CHECK:       }, false {
+// CHECK:         {{.*}} = cir.const #false
+// CHECK:         cir.yield
+// CHECK:       }) : (!cir.bool) -> !cir.bool
+// CHECK:     cir.call @_ZN1XD2Ev
+
 // @B::~B() #1 definition call into base @A::~A()
 // CHECK:  cir.func linkonce_odr @_ZN1BD2Ev{{.*}}{
 // CHECK:    cir.call @_ZN1AD2Ev(