Add global variable support to parser and IR

- Add GlobalVar struct and DeclT::GlobalVar variant to IR
- Parse VarDecl in C++ frontend with _pure attribute support
- Add Option<Rc<Expr>> type to Zngur FFI for optional initializers
- Register global vars in Env for type checking and name resolution
- Emit _pure globals as let-definitions; non-pure globals report error
- Treat global var references as rvalues (no dereference)
- Add test/global_var.c with pure bool globals and assertions

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

Author: gebner

cpp/iface.zng

@@ -18,6 +18,7 @@ type bool {
 use ::num_bigint::BigInt as BigInt;
 use ::std::rc::Rc as Rc;
 use ::core::result::Result as Result;
+use ::core::option::Option as Option;
 use ::std::vec::Vec as Vec;
 use crate::ir::Ident as Ident;
 use crate::ir::SourceInfo as SourceInfo;
@@ -62,6 +63,12 @@ mod crate::ir {
         fn push(&mut self, Rc<Expr>);
     }
 
+    type Option<Rc<Expr>> {
+        #layout(size=8, align=8);
+        constructor None;
+        constructor Some(Rc<Expr>);
+    }
+
     type Rc<Stmt> {
         #layout(size=8, align=8);
         fn deref(&self) -> &Stmt;
@@ -158,6 +165,7 @@ mod crate::clang {
         fn add_fn_defn(&mut self, DeclBuilder, Vec<Rc<Stmt>>);
         fn add_typedef(&mut self, Rc<SourceInfo>, Rc<Ident>, Rc<Type>);
         fn add_struct(&mut self, DeclBuilder);
+        fn add_global_var(&mut self, Rc<SourceInfo>, Rc<Ident>, Rc<Type>, Option<Rc<Expr>>, bool);
         fn add_include(&mut self, Rc<SourceInfo>, u32, &SnippetMap);
 
         fn mk_ghost_stmt(&mut self, Rc<SourceInfo>, u32, &SnippetMap) -> Rc<Stmt>;

cpp/impl.cpp

@@ -16,6 +16,7 @@ using rust::std::rc::Rc;
 using rust::std::vec::Vec;
 using namespace rust::crate::clang;
 namespace ir = rust::crate::ir;
+using OptExpr = rust::core::option::Option<Rc<ir::Expr>>;
 
 llvm::StringRef toStringRef(Ref<rust::Str> str) {
   return llvm::StringRef((char const *)str.as_ptr(), str.len());
@@ -829,6 +830,22 @@ class C2PulseConsumer : public ASTConsumer {
         // TODO: forward struct decls
       }
       return {};
+    } else if (auto *VD = dyn_cast<VarDecl>(D)) {
+      auto loc = getRange(VD->getSourceRange());
+      auto id = ctx.mk_ident(toStr(VD->getName()), loc.clone());
+      auto ty = trQualType(VD->getType(), VD->getSourceRange());
+      OptExpr init = VD->hasInit() ? OptExpr::Some(trRValue(VD->getInit()))
+                                   : OptExpr::None();
+      bool is_pure = false;
+      for (auto attr : VD->getAttrs()) {
+        if (auto ann = dyn_cast<AnnotateAttr>(attr);
+            ann && ann->getAnnotation() == "c2pulse-pure" &&
+            ann->args_size() == 0) {
+          is_pure = true;
+        }
+      }
+      return ctx.add_global_var(std::move(loc), std::move(id), std::move(ty),
+                                std::move(init), is_pure);
     }
 
     reportUnsupported(D->getSourceRange(), getRange(D->getSourceRange()),

src/clang.rs

@@ -119,6 +119,25 @@ impl<'a> Ctx<'a> {
         })
     }
 
+    fn add_global_var(
+        &mut self,
+        loc: Rc<SourceInfo>,
+        name: Rc<Ident>,
+        ty: Rc<Type>,
+        init: Option<Rc<Expr>>,
+        is_pure: bool,
+    ) {
+        self.translation_unit.decls.push(Ast {
+            loc,
+            val: DeclT::GlobalVar(GlobalVar {
+                name,
+                ty,
+                init,
+                is_pure,
+            }),
+        })
+    }
+
     fn add_include(&mut self, loc: Rc<SourceInfo>, idx: u32, snippets: &SnippetMap) {
         match snippets.snippets.get(&idx) {
             Some(code) => self.translation_unit.decls.push(Ast {

src/env.rs

@@ -7,6 +7,7 @@ struct Globals {
     fns: HashMap<Rc<str>, FnDecl>,
     typedefs: HashMap<Rc<str>, TypeDefn>,
     structs: HashMap<Rc<str>, StructDefn>,
+    vars: HashMap<Rc<str>, GlobalVar>,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
@@ -137,13 +138,20 @@ impl Env {
             .insert(decl.name.val.clone(), decl);
     }
 
+    pub fn push_global_var(&mut self, gv: GlobalVar) {
+        Rc::make_mut(&mut self.globals)
+            .vars
+            .insert(gv.name.val.clone(), gv);
+    }
+
     pub fn push_decl(&mut self, decl: &Decl) {
         match &decl.val {
             DeclT::FnDefn(fn_defn) => self.push_fn_decl(fn_defn.decl.clone()),
             DeclT::FnDecl(fn_decl) => self.push_fn_decl(fn_decl.clone()),
             DeclT::Typedef(defn) => self.push_typedef(defn.clone()),
             DeclT::StructDefn(struct_defn) => self.push_struct(struct_defn.clone()),
             DeclT::IncludeDecl(_) => {}
+            DeclT::GlobalVar(gv) => self.push_global_var(gv.clone()),
         }
     }
 
@@ -187,8 +195,14 @@ impl Env {
         self.locals.get(&ident.val)
     }
 
+    pub fn lookup_global_var(&self, ident: &Ident) -> Option<&GlobalVar> {
+        self.globals.vars.get(&ident.val)
+    }
+
     pub fn lookup_var_type(&self, ident: &Ident) -> Option<&Rc<Type>> {
-        self.lookup_var(ident).map(|decl| &decl.ty)
+        self.lookup_var(ident)
+            .map(|decl| &decl.ty)
+            .or_else(|| self.lookup_global_var(ident).map(|gv| &gv.ty))
     }
 
     pub fn push_stmt(&mut self, stmt: &Stmt) {

src/ir/mod.rs

@@ -380,6 +380,14 @@ pub struct IncludeDecl {
     pub code: InlineCode,
 }
 
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct GlobalVar {
+    pub name: Rc<Ident>,
+    pub ty: Rc<Type>,
+    pub init: Option<Rc<Expr>>,
+    pub is_pure: bool,
+}
+
 pub type Decl = Ast<DeclT>;
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub enum DeclT {
@@ -388,6 +396,7 @@ pub enum DeclT {
     Typedef(TypeDefn),
     StructDefn(StructDefn),
     IncludeDecl(IncludeDecl),
+    GlobalVar(GlobalVar),
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]

src/ir/pretty.rs

@@ -465,6 +465,28 @@ impl PrettyIR for IncludeDecl {
     }
 }
 
+impl PrettyIR for GlobalVar {
+    fn to_doc(&self) -> RcDoc<'_, ()> {
+        let prefix = if self.is_pure {
+            RcDoc::text("_pure ")
+        } else {
+            RcDoc::nil()
+        };
+        let init = match &self.init {
+            Some(e) => RcDoc::text(" = ").append(e.to_doc()),
+            None => RcDoc::nil(),
+        };
+        prefix
+            .append(self.ty.to_doc())
+            .append(RcDoc::line())
+            .append(self.name.to_doc())
+            .append(init)
+            .append(";")
+            .group()
+            .nest(2)
+    }
+}
+
 impl PrettyIR for DeclT {
     fn to_doc(&self) -> RcDoc<'_, ()> {
         match self {
@@ -473,6 +495,7 @@ impl PrettyIR for DeclT {
             DeclT::Typedef(type_defn) => type_defn.to_doc(),
             DeclT::StructDefn(struct_defn) => struct_defn.to_doc(),
             DeclT::IncludeDecl(include_decl) => include_decl.to_doc(),
+            DeclT::GlobalVar(global_var) => global_var.to_doc(),
         }
     }
 }

src/pass/check.rs

@@ -368,7 +368,17 @@ impl<'a> Checker<'a> {
 
     fn check_var(&mut self, env: &Env, n: &Ident, needs_lvalue: bool) {
         match env.lookup_var(n) {
-            None => self.report(format!("unknown local variable {}", n.val), &n.loc),
+            None => match env.lookup_global_var(n) {
+                Some(_) => {
+                    if needs_lvalue {
+                        self.report(
+                            format!("need lvalue, but global {} is rvalue", n.val),
+                            &n.loc,
+                        );
+                    }
+                }
+                None => self.report(format!("unknown local variable {}", n.val), &n.loc),
+            },
             Some(ldecl) => {
                 if ldecl.kind == LocalDeclKind::RValue && needs_lvalue {
                     self.report(format!("need lvalue, but {} is rvalue", n.val), &n.loc);
@@ -529,6 +539,17 @@ impl<'a> Checker<'a> {
                 }
             }
             DeclT::IncludeDecl(_) => {}
+            DeclT::GlobalVar(GlobalVar {
+                name: _,
+                ty,
+                init,
+                is_pure: _,
+            }) => {
+                self.check_type(env, ty);
+                if let Some(init) = init {
+                    self.check_rvalue(env, init);
+                }
+            }
         }
     }
 

src/pass/elab.rs

@@ -466,6 +466,17 @@ impl<'a> Elaborator<'a> {
                 }
             }
             DeclT::IncludeDecl(_) => {}
+            DeclT::GlobalVar(GlobalVar {
+                name: _,
+                ty,
+                init,
+                is_pure: _,
+            }) => {
+                self.elab_type(env, Rc::make_mut(ty));
+                if let Some(init) = init {
+                    self.elab_rvalue(env, Rc::make_mut(init));
+                }
+            }
         }
     }
 }

src/pass/emit.rs

@@ -480,6 +480,8 @@ impl<'a> Emitter<'a> {
                 }) = env.lookup_var(x)
                 {
                     ExprKind::RValue(annotated(v, self.emit_var(x)))
+                } else if env.lookup_global_var(x).is_some() {
+                    ExprKind::RValue(annotated(v, self.emit_var(x)))
                 } else {
                     ExprKind::LValue(annotated(v, self.emit_var(x)))
                 }
@@ -2001,6 +2003,36 @@ impl<'a> Emitter<'a> {
         )
     }
 
+    fn emit_global_var(&mut self, env: &Env, gv: &GlobalVar) -> Doc {
+        if !gv.is_pure {
+            self.report(
+                "non-pure global variables are not yet supported".to_string(),
+                &gv.name.loc,
+            );
+            return Doc::nil();
+        }
+        let name = self.nm.emit(Name::Var(gv.name.val.clone()));
+        let ty = self.emit_type(env, &gv.ty);
+        match &gv.init {
+            Some(init) => {
+                let init_doc = self.emit_rvalue(env, init);
+                Doc::text("let ")
+                    .append(name)
+                    .append(" : ")
+                    .append(ty)
+                    .append(" = ")
+                    .append(init_doc)
+            }
+            None => {
+                self.report(
+                    "pure global variable must have an initializer".to_string(),
+                    &gv.name.loc,
+                );
+                Doc::nil()
+            }
+        }
+    }
+
     fn emit_decl(&mut self, env: &Env, decl: &Decl) -> Doc {
         annotated(decl, {
             match &decl.val {
@@ -2033,6 +2065,7 @@ impl<'a> Emitter<'a> {
                 DeclT::Typedef(typedef) => self.emit_typedef(env, typedef),
                 DeclT::StructDefn(struct_defn) => self.emit_structdefn(env, struct_defn),
                 DeclT::IncludeDecl(include_decl) => emit_inline_code(&include_decl.code),
+                DeclT::GlobalVar(gv) => self.emit_global_var(env, gv),
             }
         })
     }

src/pass/prune.rs

@@ -59,6 +59,7 @@ enum DeclName {
     Fn(Rc<str>),
     Struct(Rc<str>),
     Typedef(Rc<str>),
+    GlobalVar(Rc<str>),
     Include(Rc<SourceInfo>),
 }
 
@@ -238,6 +239,7 @@ fn decl_name(decl: &Decl) -> DeclName {
         DeclT::Typedef(type_defn) => DeclName::Typedef(type_defn.name.val.clone()),
         DeclT::StructDefn(struct_defn) => DeclName::Struct(struct_defn.name.val.clone()),
         DeclT::IncludeDecl(_) => DeclName::Include(decl.loc.clone()),
+        DeclT::GlobalVar(gv) => DeclName::GlobalVar(gv.name.val.clone()),
     }
 }
 
@@ -285,6 +287,18 @@ fn scan_translation_unit(deps: &mut Deps<DeclName>, tu: &TranslationUnit) {
                 }
             }
             DeclT::IncludeDecl(_) => {}
+            DeclT::GlobalVar(GlobalVar {
+                name: _,
+                ty,
+                init,
+                is_pure: _,
+            }) => {
+                let ds = deps.deps_for(n);
+                scan_type(ds, ty);
+                if let Some(init) = init {
+                    scan_expr(ds, init);
+                }
+            }
         }
     }
 }