clang: Evaluate more complex constant expressions in variables.

Author: emilio

src/clang.rs

@@ -475,6 +475,11 @@ impl Cursor {
     pub fn is_virtual_base(&self) -> bool {
         unsafe { clang_isVirtualBase(self.x) != 0 }
     }
+
+    /// Try to evaluate this cursor.
+    pub fn evaluate(&self) -> EvalResult {
+        EvalResult::new(*self)
+    }
 }
 
 extern "C" fn visit_children<Visitor>(cur: CXCursor,
@@ -1259,3 +1264,35 @@ pub fn ast_dump(c: &Cursor, depth: isize) -> Enum_CXVisitorResult {
 pub fn extract_clang_version() -> String {
     unsafe { clang_getClangVersion().into() }
 }
+
+#[derive(Debug)]
+pub struct EvalResult {
+    x: CXEvalResult,
+}
+
+impl EvalResult {
+    pub fn new(cursor: Cursor) -> Self {
+        EvalResult {
+            x: unsafe { clang_Cursor_Evaluate(cursor.x) },
+        }
+    }
+
+    pub fn kind(&self) -> Enum_CXEvalResultKind {
+        unsafe { clang_EvalResult_getKind(self.x) }
+    }
+
+    pub fn as_int(&self) -> Option<i32> {
+        match self.kind() {
+            CXEval_Int => {
+                Some(unsafe { clang_EvalResult_getAsInt(self.x) } as i32)
+            }
+            _ => None,
+        }
+    }
+}
+
+impl Drop for EvalResult {
+    fn drop(&mut self) {
+        unsafe { clang_EvalResult_dispose(self.x) };
+    }
+}

src/ir/var.rs

@@ -159,13 +159,23 @@ impl ClangSubItemParser for Var {
                 // tests/headers/inner_const.hpp
                 //
                 // That's fine because in that case we know it's not a literal.
-                let value = ctx.safe_resolve_type(ty)
+                let is_integer = ctx.safe_resolve_type(ty)
                     .and_then(|t| t.safe_canonical_type(ctx))
-                    .and_then(|t| if t.is_integer() { Some(t) } else { None })
-                    .and_then(|_| {
-                        get_integer_literal_from_cursor(&cursor,
-                                                        ctx.translation_unit())
-                    });
+                    .map(|t| t.is_integer())
+                    .unwrap_or(false);
+
+                let value = if is_integer {
+                    cursor.evaluate()
+                        .as_int()
+                        .map(|val| val as i64)
+                        .or_else(|| {
+                            let tu = ctx.translation_unit();
+                            get_integer_literal_from_cursor(&cursor, tu)
+                        })
+                } else {
+                    None
+                };
+
 
                 let mangling = cursor_mangling(&cursor);
 

tests/expectations/tests/constant-evaluate.rs

@@ -0,0 +1,12 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+pub const foo: _bindgen_ty_1 = _bindgen_ty_1::foo;
+pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum _bindgen_ty_1 { foo = 4, bar = 8, }
+pub const BAZ: ::std::os::raw::c_longlong = 24;

tests/headers/constant-evaluate.h

@@ -0,0 +1,7 @@
+
+enum {
+  foo = 4,
+  bar = 8,
+};
+
+const long long BAZ = (1 << foo) | bar;