[CIR] Implement cast expression classes as l-values

This commit fixes l-value emission for CXXConstCastExpr,
CXXReinterpretCastExpr, CXXFunctionalCastExpr, CXXAddrspaceCastExpr,
and ObjCBridgedCastExpr by routing them through the existing
emitCastLValue() function, matching the behavior of CodeGen.

Previously, these cast expression classes would trigger an error and
assertion when used in l-value contexts (e.g., `const_cast<int&>(x) = 1`).
This was an artificial limitation - CodeGen routes all cast expression
classes through EmitCastLValue(), which then handles each cast *kind*
appropriately.

Key insight from CodeGen (CGExpr.cpp:5679-5685):
"Casts are never lvalues unless that cast is to a reference type."

The cast expression *class* (CXXConstCastExpr vs CXXReinterpretCastExpr)
doesn't determine if it's a valid l-value. Instead, the cast *kind*
(CK_NoOp, CK_LValueBitCast, etc.) and result type determine validity.
emitCastLValue() already handles this correctly based on getCastKind().

Implementation Details:
- Removed emitError() and assert() for const_cast and related expr classes
- Unified all cast expression classes in emitLValue() switch statement
- All now route through emitCastLValue() like CodeGen (CGExpr.cpp:1823-1832)
- Safety is maintained by emitCastLValue()'s cast kind handling

This follows the ClangIR principle of copying implementations from
CodeGen, which has been proven correct over 20 years.

Testing:
- Single comprehensive test covering const_cast and reinterpret_cast
- Tests verify CIR emission, LLVM lowering, and match with original CodeGen
- All three outputs verified to ensure correctness

Test Plan:
$ ninja -C build/Release clang
$ build/Release/bin/llvm-lit clang/test/CIR/CodeGen/cast-lvalue.cpp

ghstack-source-id: f4cfd63
Pull-Request: #2011

Author: lanza

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2710,18 +2710,15 @@ LValue CIRGenFunction::emitLValue(const Expr *E) {
     return emitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
   case Expr::PredefinedExprClass:
     return emitPredefinedLValue(cast<PredefinedExpr>(E));
+  case Expr::ImplicitCastExprClass:
+  case Expr::CStyleCastExprClass:
   case Expr::CXXFunctionalCastExprClass:
+  case Expr::CXXStaticCastExprClass:
+  case Expr::CXXDynamicCastExprClass:
   case Expr::CXXReinterpretCastExprClass:
   case Expr::CXXConstCastExprClass:
   case Expr::CXXAddrspaceCastExprClass:
   case Expr::ObjCBridgedCastExprClass:
-    emitError(getLoc(E->getExprLoc()), "l-value not implemented for '")
-        << E->getStmtClassName() << "'";
-    assert(0 && "Use emitCastLValue below, remove me when adding testcase");
-  case Expr::CStyleCastExprClass:
-  case Expr::CXXStaticCastExprClass:
-  case Expr::CXXDynamicCastExprClass:
-  case Expr::ImplicitCastExprClass:
     return emitCastLValue(cast<CastExpr>(E));
   case Expr::OpaqueValueExprClass:
     return emitOpaqueValueLValue(cast<OpaqueValueExpr>(E));

clang/test/CIR/CodeGen/cast-lvalue.cpp

@@ -0,0 +1,47 @@
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.orig.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t.orig.ll %s
+//
+// Test for cast expressions as l-values (const_cast, reinterpret_cast, etc.)
+
+void const_cast_lvalue() {
+  const int x = 0;
+  const_cast<int&>(x) = 1;
+}
+
+// CIR-LABEL: cir.func dso_local @_Z17const_cast_lvaluev
+// CIR:   %[[X:.*]] = cir.alloca !s32i, {{.*}}, ["x", init, const]
+// CIR:   %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR:   cir.store {{.*}} %[[ZERO]], %[[X]] : !s32i, !cir.ptr<!s32i>
+// CIR:   %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
+// CIR:   cir.store {{.*}} %[[ONE]], %[[X]] : !s32i, !cir.ptr<!s32i>
+// CIR:   cir.return
+
+// LLVM-LABEL: define {{.*}}void @_Z17const_cast_lvaluev
+// LLVM:   %[[X:.*]] = alloca i32
+// LLVM:   store i32 0, ptr %[[X]]
+// LLVM:   store i32 1, ptr %[[X]]
+// LLVM:   ret void
+
+void reinterpret_cast_lvalue() {
+  long x = 0;
+  reinterpret_cast<int&>(x) = 1;
+}
+
+// CIR-LABEL: cir.func dso_local @_Z23reinterpret_cast_lvaluev
+// CIR:   %[[X:.*]] = cir.alloca !s64i, {{.*}}, ["x", init]
+// CIR:   %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR:   cir.store {{.*}} %{{.*}}, %[[X]] : !s64i, !cir.ptr<!s64i>
+// CIR:   %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
+// CIR:   %[[CAST:.*]] = cir.cast bitcast %[[X]] : !cir.ptr<!s64i> -> !cir.ptr<!s32i>
+// CIR:   cir.store {{.*}} %[[ONE]], %[[CAST]] : !s32i, !cir.ptr<!s32i>
+// CIR:   cir.return
+
+// LLVM-LABEL: define {{.*}}void @_Z23reinterpret_cast_lvaluev
+// LLVM:   %[[X:.*]] = alloca i64
+// LLVM:   store i64 0, ptr %[[X]]
+// LLVM:   store i32 1, ptr %[[X]]
+// LLVM:   ret void

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

@@ -1,5 +1,4 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
-// XFAIL: *
 //
 // CXXConstCastExpr l-value emission not implemented
 // Location: CIRGenExpr.cpp:2799