[CIR] Add crash tests from ClangIR build failure analysis

Added minimal crash test cases documenting known NYI features and bugs:

1. bitfield-bool-int-cast.cpp
   - Location: Casting.h:560
   - Error: cast<mlir::Type> assertion failure with boolean bitfield
   - Tests bool bitfield to int conversion in operator<<

2. const-cast-lvalue.cpp
   - Location: CIRGenExpr.cpp:2799
   - Error: CXXConstCastExpr l-value emission not implemented
   - Tests const_cast on l-value references

3. non-odr-use-constant.cpp
   - Location: CIRGenExpr.cpp:1122
   - Error: NOUR_Constant (non-ODR-use constant) not implemented
   - Tests range-based for loop over StringMap/StringSet

4. range-for-temp-automatic.cpp
   - Location: CIRGenExpr.cpp:2435
   - Error: SD_Automatic storage duration for reference temporaries NYI
   - Tests nested range-based for loops with temporary lifetime extension

Tests collected from ninja -C /tmp/clangbuild -k10000 build failure analysis.

Test plan:
$ llvm-lit -v clang/test/CIR/crashes/*.cpp
All tests XFAIL as expected

Author: lanza

clang/test/CIR/crashes/bitfield-bool-int-cast.cpp

@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// XFAIL: *
+//
+// Bitfield bool to int conversion - type cast assertion failure
+// Location: Casting.h:560
+
+struct a {
+  bool b : 1;
+};
+class c {
+public:
+  void operator<<(int);
+};
+void d(c e, a f) { e << f.b; }

clang/test/CIR/crashes/const-cast-lvalue.cpp

@@ -1,28 +1,25 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
 // XFAIL: *
 //
-// Test for CXXConstCastExpr l-value emission not implemented
-// Assertion at CIRGenExpr.cpp:2764
-//
-// This test triggers the assertion:
-// "Use emitCastLValue below, remove me when adding testcase"
-//
-// Original failure: assertion_emitcastlvalue from LLVM build
-// Reduced from /tmp/DeltaTree-af9b43.cpp
+// CXXConstCastExpr l-value emission not implemented
+// Location: CIRGenExpr.cpp:2799
 
 int a;
 struct b {
   using c = int;
   static c d() { const_cast<int &>(a); }
 };
-struct e {
+template <typename> struct e {
   static bool f() { b::d; }
 };
-struct g {
-  static bool h() { e::f; }
-};
-struct j : g {
-  using i = int;
-  static i k() { h; }
+template <typename... g, typename h> void i(h) { (e<g>::f || ...); }
+class j {
+  int k;
+
+public:
+  void l() { i<int>(k); }
 };
-void l() { j::k; }
+void m() {
+  j n;
+  n.l();
+}

clang/test/CIR/crashes/non-odr-use-constant.cpp

@@ -0,0 +1,31 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// XFAIL: *
+//
+// Non-ODR-use constant expression not implemented
+// Location: CIRGenExpr.cpp:1122
+
+namespace llvm {
+  template<typename ValueTy> class StringMapEntry {};
+  template<typename ValueTy> class StringMapIterBase {
+  public:
+    StringMapEntry<ValueTy>& operator*() const;
+    StringMapIterBase& operator++();
+    friend bool operator!=(const StringMapIterBase& LHS, const StringMapIterBase& RHS);
+  };
+  template<typename ValueTy> class StringMap {
+  public:
+    StringMapIterBase<ValueTy> begin();
+    StringMapIterBase<ValueTy> end();
+  };
+  struct EmptyStringSetTag {};
+  template<class AllocatorTy = int> class StringSet : public StringMap<EmptyStringSetTag> {};
+}
+
+namespace clang {
+  static llvm::StringSet<> BuiltinClasses;
+
+  void EmitBuiltins() {
+    for (const auto &Entry : BuiltinClasses) {
+    }
+  }
+}

clang/test/CIR/crashes/range-for-temp-automatic.cpp

@@ -0,0 +1,50 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// XFAIL: *
+//
+// SD_Automatic storage duration for reference temporaries in range-based for loops
+// Location: CIRGenExpr.cpp:2435
+
+template <typename> struct b;
+template <typename> struct f;
+template <typename c> struct f<c *> {
+  typedef c d;
+};
+template <typename e, typename> class j {
+public:
+  f<e>::d operator*();
+  void operator++();
+};
+template <typename e, typename g> bool operator!=(j<e, g>, j<e, g>);
+template <typename> class k;
+template <typename c> struct b<k<c>> {
+  using h = c *;
+};
+template <typename i> struct F {
+  typedef b<i>::h h;
+  ~F();
+};
+template <typename c, typename i = k<c>> class G : F<i> {
+public:
+  typedef j<typename F<i>::h, int> iterator;
+  iterator begin();
+  iterator end();
+};
+template <typename l> class m {
+public:
+  using n = l;
+  using o = n *;
+  using iterator = o;
+  iterator begin();
+  iterator end();
+};
+class p {
+public:
+  G<p *> u();
+  m<p *> r();
+} q;
+void s() {
+  m a = q.r();
+  for (p *v : a)
+    for (p *t : v->u())
+      ;
+}