Allow lazily getting type for macro variables.

Author: reitermarkus

src/codegen/mod.rs

@@ -630,7 +630,18 @@ impl CodeGenerator for Var {
             attrs.push(attributes::doc(comment));
         }
 
-        let ty = self.ty().to_rust_ty_or_opaque(ctx, &());
+        let var_ty = if let Some(var_ty) = self.ty(ctx) {
+            var_ty
+        } else {
+            // FIXME: Parse/output macro variables as the last step when all types are known.
+            warn!(
+                "Failed to determine type for macro variable {}.",
+                canonical_name
+            );
+            return;
+        };
+
+        let ty = var_ty.to_rust_ty_or_opaque(ctx, &());
 
         if let Some(val) = self.val() {
             match *val {
@@ -641,8 +652,7 @@ impl CodeGenerator for Var {
                     });
                 }
                 VarType::Int(val) => {
-                    let int_kind = self
-                        .ty()
+                    let int_kind = var_ty
                         .into_resolver()
                         .through_type_aliases()
                         .through_type_refs()

src/ir/item.rs

@@ -297,7 +297,9 @@ impl Trace for Item {
                 tracer.visit(fun.signature().into());
             }
             ItemKind::Var(ref var) => {
-                tracer.visit_kind(var.ty().into(), EdgeKind::VarType);
+                if let Some(ty) = var.ty(ctx) {
+                    tracer.visit_kind(ty.into(), EdgeKind::VarType);
+                }
             }
             ItemKind::Module(_) => {
                 // Module -> children edges are "weak", and we do not want to

src/ir/var.rs

@@ -40,27 +40,39 @@ pub struct Var {
     /// The mangled name of the variable.
     mangled_name: Option<String>,
     /// The type of the variable.
-    ty: TypeId,
+    ty: VarTypeId,
     /// The value of the variable, that needs to be suitable for `ty`.
     val: Option<VarType>,
     /// Whether this variable is const.
     is_const: bool,
 }
 
+#[derive(Debug)]
+pub enum VarTypeId {
+    Concrete(TypeId),
+    Lazy(String),
+}
+
+impl From<TypeId> for VarTypeId {
+    fn from(type_id: TypeId) -> Self {
+        Self::Concrete(type_id)
+    }
+}
+
 impl Var {
     /// Construct a new `Var`.
     pub fn new(
         name: String,
         mangled_name: Option<String>,
-        ty: TypeId,
+        ty: impl Into<VarTypeId>,
         val: Option<VarType>,
         is_const: bool,
-    ) -> Var {
+    ) -> Self {
         assert!(!name.is_empty());
-        Var {
+        Self {
             name,
             mangled_name,
-            ty,
+            ty: ty.into(),
             val,
             is_const,
         }
@@ -336,30 +348,18 @@ impl ClangSubItemParser for Var {
                                 ["int64_t"] => IntKind::I64,
                                 ["uint64_t"] => IntKind::U64,
                                 [custom_type] => {
-                                    eprintln!(
-                                        "looking for type {:?}",
-                                        custom_type
-                                    );
-
-                                    // FIXME: Doesn't work since types are parsed after macros.
-                                    let type_id = ctx
-                                        .wrapper_id_by_name(custom_type)
-                                        .or_else(|| {
-                                            ctx.wrapper_id_by_name(&format!(
-                                                "const {}",
-                                                custom_type
-                                            ))
-                                        });
-
-                                    if let Some(type_id) = type_id {
-                                        todo!(
-                                            "type id for {:?} = {:?}",
-                                            custom_type,
-                                            type_id
-                                        );
-                                    }
-
-                                    return Err(ParseError::Continue);
+                                    return Ok(ParseResult::New(
+                                        Var::new(
+                                            name,
+                                            None,
+                                            VarTypeId::Lazy(
+                                                custom_type.to_string(),
+                                            ),
+                                            Some(val),
+                                            true,
+                                        ),
+                                        Some(cursor),
+                                    ));
                                 }
                                 _ => return Err(ParseError::Continue),
                             };