Translate sizeof / _Alignof to size_t literals

Adds a UnaryExprOrTypeTraitExpr arm to trRValue in cpp/impl.cpp that
asks clang to constant-fold sizeof/_Alignof/_PreferredAlignOf via
EvaluateAsInt and emits the result as a size_t integer literal. VLA
sizeof falls through to the existing unsupported-rvalue error.

Also fills in the previously-TODO (SizeT, Int) cast arm in emit.rs as
the dual of the existing (Int, SizeT) arm, so that (uintN_t)sizeof(T)
emits as UIntN.uint_to_t (SizeT.v Nsz). This is needed in practice
because once sizeof emits a real size_t literal, narrowing casts of it
appear immediately.

The test file exercises sizeof on builtin types, expressions, struct
types, array types, an arithmetic combination with another size_t
literal, the new SizeT -> uint32_t cast, and _Alignof.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: KimayaBedarkar

cpp/impl.cpp

@@ -797,6 +797,24 @@ class PALConsumer : public ASTConsumer {
       }
       // Other DeclRefExpr in rvalue context: treat as lvalue read
       return mk_rvalue_lvalue(std::move(loc), trLValue(e));
+    } else if (auto *u = dyn_cast<UnaryExprOrTypeTraitExpr>(e)) {
+      // sizeof / _Alignof: clang has already constant-folded these for any
+      // non-VLA type or expression. Emit as a size_t literal. The value
+      // depends on the target triple PAL invokes clang with; for a 64-bit
+      // target this matches the runtime layout assumed by msquic.
+      if (u->getKind() == UETT_SizeOf || u->getKind() == UETT_AlignOf ||
+          u->getKind() == UETT_PreferredAlignOf) {
+        Expr::EvalResult er;
+        if (u->EvaluateAsInt(er, *astCtx)) {
+          SmallString<32> valStr;
+          er.Val.getInt().toString(valStr);
+          return mk_int_lit(loc.clone(),
+                            mk_bigint(toStr(StringRef(valStr))),
+                            mk_sizet(std::move(loc)));
+        }
+        // VLA sizeof or other non-constant case: fall through to the
+        // generic unsupported-rvalue error below.
+      }
     }
 
     reportUnsupported(e->getSourceRange(), loc,

src/pass/emit.rs

@@ -1544,7 +1544,17 @@ impl<'a> Emitter<'a> {
                         // (TypeT::Int { signed, width }, TypeT::SizeT) => todo!(),
                         // (TypeT::Int { signed, width }, TypeT::SLProp) => todo!(),
                         // (TypeT::SizeT, TypeT::Bool) => todo!(),
-                        // (TypeT::SizeT, TypeT::Int { signed, width }) => todo!(),
+                        (TypeT::SizeT, TypeT::Int { signed, width }) => {
+                            if let Some(m) = get_int_mod(signed, width) {
+                                unaryfn(
+                                    Doc::text(format!("{}.uint_to_t (SizeT.v", m)),
+                                    val_doc.append(Doc::text(")")),
+                                )
+                            } else {
+                                self.report(default_msg.clone(), &v.loc);
+                                Doc::text("(admit())")
+                            }
+                        }
                         // (TypeT::SizeT, TypeT::SLProp) => todo!(),
                         // (TypeT::Pointer { to, kind }, TypeT::Bool) => todo!(),
                         (TypeT::Pointer(_, kind), TypeT::Bool) => {

test/sizeof.c

@@ -0,0 +1,51 @@
+#include "pal.h"
+#include <stdint.h>
+#include <stddef.h>
+
+// sizeof of a builtin type in a size_t-position
+size_t size_of_int(void)
+{
+    return sizeof(int);
+}
+
+// sizeof of an expression (clang folds based on the expression's type)
+size_t size_of_expr(int x)
+{
+    return sizeof(x);
+}
+
+// sizeof participating in arithmetic against another size_t literal
+size_t bytes_for_10_ints(void)
+{
+    return (size_t) 10 * sizeof(int);
+}
+
+// sizeof of a struct type
+typedef struct {
+    int x;
+    int y;
+} two_ints;
+
+size_t size_of_two_ints(void)
+{
+    return sizeof(two_ints);
+}
+
+// sizeof of an array type
+size_t size_of_int_array(void)
+{
+    return sizeof(int[8]);
+}
+
+// Cast sizeof to a narrower integer type (exercises the new SizeT -> Int cast).
+uint32_t size_of_int_u32(void)
+{
+    return (uint32_t) sizeof(int);
+}
+
+// _Alignof of a builtin type
+size_t align_of_int(void)
+{
+    return _Alignof(int);
+}
+