Support casts in macros.

Author: reitermarkus

src/ir/context.rs

@@ -354,6 +354,8 @@ pub struct BindgenContext {
     /// This needs to be an std::HashMap because the cexpr API requires it.
     parsed_macros: StdHashMap<Vec<u8>, cexpr::expr::EvalResult>,
 
+    wrapper_ids: StdHashMap<String, TypeId>,
+
     /// A set of all the included filenames.
     deps: BTreeSet<String>,
 
@@ -555,6 +557,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
             semantic_parents: Default::default(),
             currently_parsed_types: vec![],
             parsed_macros: Default::default(),
+            wrapper_ids: Default::default(),
             replacements: Default::default(),
             collected_typerefs: false,
             in_codegen: false,
@@ -1919,7 +1922,10 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         let layout = ty.fallible_layout(self).ok();
         let location = ty.declaration().location();
         let type_kind = TypeKind::ResolvedTypeRef(wrapped_id);
-        let ty = Type::new(Some(spelling), layout, type_kind, is_const);
+
+        eprintln!("Building wrapper type {:?} ({:?})", spelling, wrapped_id);
+
+        let ty = Type::new(Some(spelling.clone()), layout, type_kind, is_const);
         let item = Item::new(
             with_id,
             None,
@@ -1929,7 +1935,15 @@ If you encounter an error missing from this list, please file an issue or a PR!"
             Some(location),
         );
         self.add_builtin_item(item);
-        with_id.as_type_id_unchecked()
+        let type_id = with_id.as_type_id_unchecked();
+
+        self.wrapper_ids.insert(spelling.clone(), type_id);
+
+        type_id
+    }
+
+    pub fn wrapper_id_by_name(&self, name: &str) -> Option<&TypeId> {
+        self.wrapper_ids.get(name)
     }
 
     /// Returns the next item id to be used for an item.
@@ -1988,6 +2002,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         let is_const = ty.is_const();
         let layout = ty.fallible_layout(self).ok();
         let location = ty.declaration().location();
+
+        eprintln!("Building type {:?}", spelling);
+
         let ty = Type::new(Some(spelling), layout, type_kind, is_const);
         let id = self.next_item_id();
         let item = Item::new(

src/ir/var.rs

@@ -77,8 +77,23 @@ impl Var {
     }
 
     /// Get this variable's type.
-    pub fn ty(&self) -> TypeId {
-        self.ty
+    #[track_caller]
+    pub fn ty(&self, ctx: &BindgenContext) -> Option<TypeId> {
+        match self.ty {
+            VarTypeId::Concrete(type_id) => Some(type_id),
+            VarTypeId::Lazy(ref type_name) => {
+                let type_id = ctx.wrapper_id_by_name(type_name).or_else(|| {
+                    ctx.wrapper_id_by_name(&format!("const {}", type_name))
+                });
+
+                eprintln!(
+                    "Looking for type_name '{}': {:?}",
+                    type_name, type_id
+                );
+
+                type_id.cloned()
+            }
+        }
     }
 
     /// Get this variable's name.
@@ -117,6 +132,25 @@ impl DotAttributes for Var {
     }
 }
 
+fn default_limit_constant_type(name: &str, value: i64) -> Option<IntKind> {
+    Some(match name {
+        "SCHAR_MIN" | "SCHAR_MAX" => IntKind::SChar,
+        "CHAR_MIN" | "CHAR_MAX" => IntKind::Char {
+            is_signed: value < 0,
+        },
+        "UCHAR_MIN" | "UCHAR_MAX" => IntKind::UChar,
+        "SHRT_MIN" | "SHRT_MAX" => IntKind::Short,
+        "USHRT_MIN" | "USHRT_MAX" => IntKind::UShort,
+        "INT_MIN" | "INT_MAX" => IntKind::Int,
+        "UINT_MIN" | "UINT_MAX" => IntKind::UInt,
+        "LONG_MIN" | "LONG_MAX" => IntKind::Long,
+        "ULONG_MIN" | "ULONG_MAX" => IntKind::ULong,
+        "LLONG_MIN" | "LLONG_MAX" => IntKind::LongLong,
+        "ULLONG_MIN" | "ULLONG_MAX" => IntKind::ULongLong,
+        _ => return None,
+    })
+}
+
 fn default_macro_constant_type(ctx: &BindgenContext, value: i64) -> IntKind {
     if value < 0 ||
         ctx.options().default_macro_constant_type ==
@@ -258,12 +292,83 @@ impl ClangSubItemParser for Var {
                         let kind = ctx
                             .parse_callbacks()
                             .and_then(|c| c.int_macro(&name, value))
+                            .or_else(|| {
+                                default_limit_constant_type(&name, value)
+                            })
                             .unwrap_or_else(|| {
                                 default_macro_constant_type(ctx, value)
                             });
 
                         (TypeKind::Int(kind), VarType::Int(value))
                     }
+                    EvalResult::Cast(c, v) => {
+                        let ty = c
+                            .iter()
+                            .map(|v| std::str::from_utf8(v).unwrap())
+                            .collect::<Vec<&str>>();
+
+                        if let EvalResult::Int(Wrapping(value)) = *v {
+                            let val = VarType::Int(value);
+
+                            let kind = match &ty[..] {
+                                ["bool"] => IntKind::Bool,
+                                ["char"] => IntKind::Char {
+                                    is_signed: value < 0,
+                                },
+                                ["signed", "char"] => IntKind::SChar,
+                                ["unsigned", "char"] => IntKind::UChar,
+                                ["short"] => IntKind::Short,
+                                ["unsigned", "short"] => IntKind::UShort,
+                                ["int"] => IntKind::Int,
+                                ["unsigned", "int"] => IntKind::UInt,
+                                ["long"] => IntKind::Long,
+                                ["unsigned", "long"] => IntKind::ULong,
+                                ["long", "long"] => IntKind::LongLong,
+                                ["unsigned", "long", "long"] => {
+                                    IntKind::ULongLong
+                                }
+                                ["int8_t"] => IntKind::I8,
+                                ["uint8_t"] => IntKind::U8,
+                                ["int16_t"] => IntKind::I16,
+                                ["uint16_t"] => IntKind::U16,
+                                ["int32_t"] => IntKind::I32,
+                                ["uint32_t"] => IntKind::U32,
+                                ["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 Err(ParseError::Continue),
+                            };
+
+                            (TypeKind::Int(kind), val)
+                        } else {
+                            return Err(ParseError::Continue);
+                        }
+                    }
                 };
 
                 let ty = Item::builtin_type(type_kind, true, ctx);