Revision control
Copy as Markdown
Other Tools
//! A higher level Clang API built on top of the generated bindings in the
//! `clang_sys` module.
#![allow(non_upper_case_globals, dead_code)]
#![deny(clippy::missing_docs_in_private_items)]
use crate::ir::context::BindgenContext;
use clang_sys::*;
use std::cmp;
use std::ffi::{CStr, CString};
use std::fmt;
use std::hash::Hash;
use std::hash::Hasher;
use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong};
use std::{mem, ptr, slice};
/// Type representing a clang attribute.
///
/// Values of this type can be used to check for different attributes using the `has_attrs`
/// function.
pub(crate) struct Attribute {
name: &'static [u8],
kind: Option<CXCursorKind>,
token_kind: CXTokenKind,
}
impl Attribute {
/// A `warn_unused_result` attribute.
pub(crate) const MUST_USE: Self = Self {
name: b"warn_unused_result",
// FIXME(emilio): clang-sys doesn't expose `CXCursor_WarnUnusedResultAttr` (from clang 9).
kind: Some(440),
token_kind: CXToken_Identifier,
};
/// A `_Noreturn` attribute.
pub(crate) const NO_RETURN: Self = Self {
name: b"_Noreturn",
kind: None,
token_kind: CXToken_Keyword,
};
/// A `[[noreturn]]` attribute.
pub(crate) const NO_RETURN_CPP: Self = Self {
name: b"noreturn",
kind: None,
token_kind: CXToken_Identifier,
};
}
/// A cursor into the Clang AST, pointing to an AST node.
///
/// We call the AST node pointed to by the cursor the cursor's "referent".
#[derive(Copy, Clone)]
pub(crate) struct Cursor {
x: CXCursor,
}
impl fmt::Debug for Cursor {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(
fmt,
"Cursor({} kind: {}, loc: {}, usr: {:?})",
self.spelling(),
kind_to_str(self.kind()),
self.location(),
self.usr()
)
}
}
impl Cursor {
/// Get the Unified Symbol Resolution for this cursor's referent, if
/// available.
///
/// The USR can be used to compare entities across translation units.
pub(crate) fn usr(&self) -> Option<String> {
let s = unsafe { cxstring_into_string(clang_getCursorUSR(self.x)) };
if s.is_empty() {
None
} else {
Some(s)
}
}
/// Is this cursor's referent a declaration?
pub(crate) fn is_declaration(&self) -> bool {
unsafe { clang_isDeclaration(self.kind()) != 0 }
}
/// Is this cursor's referent an anonymous record or so?
pub(crate) fn is_anonymous(&self) -> bool {
unsafe { clang_Cursor_isAnonymous(self.x) != 0 }
}
/// Get this cursor's referent's spelling.
pub(crate) fn spelling(&self) -> String {
unsafe { cxstring_into_string(clang_getCursorSpelling(self.x)) }
}
/// Get this cursor's referent's display name.
///
/// This is not necessarily a valid identifier. It includes extra
/// information, such as parameters for a function, etc.
pub(crate) fn display_name(&self) -> String {
unsafe { cxstring_into_string(clang_getCursorDisplayName(self.x)) }
}
/// Get the mangled name of this cursor's referent.
pub(crate) fn mangling(&self) -> String {
unsafe { cxstring_into_string(clang_Cursor_getMangling(self.x)) }
}
/// Gets the C++ manglings for this cursor, or an error if the manglings
/// are not available.
pub(crate) fn cxx_manglings(&self) -> Result<Vec<String>, ()> {
use clang_sys::*;
unsafe {
let manglings = clang_Cursor_getCXXManglings(self.x);
if manglings.is_null() {
return Err(());
}
let count = (*manglings).Count as usize;
let mut result = Vec::with_capacity(count);
for i in 0..count {
let string_ptr = (*manglings).Strings.add(i);
result.push(cxstring_to_string_leaky(*string_ptr));
}
clang_disposeStringSet(manglings);
Ok(result)
}
}
/// Returns whether the cursor refers to a built-in definition.
pub(crate) fn is_builtin(&self) -> bool {
let (file, _, _, _) = self.location().location();
file.name().is_none()
}
/// Get the `Cursor` for this cursor's referent's lexical parent.
///
/// The lexical parent is the parent of the definition. The semantic parent
/// is the parent of the declaration. Generally, the lexical parent doesn't
/// have any effect on semantics, while the semantic parent does.
///
/// In the following snippet, the `Foo` class would be the semantic parent
/// of the out-of-line `method` definition, while the lexical parent is the
/// translation unit.
///
/// ```c++
/// class Foo {
/// void method();
/// };
///
/// void Foo::method() { /* ... */ }
/// ```
pub(crate) fn lexical_parent(&self) -> Cursor {
unsafe {
Cursor {
x: clang_getCursorLexicalParent(self.x),
}
}
}
/// Get the referent's semantic parent, if one is available.
///
/// See documentation for `lexical_parent` for details on semantic vs
/// lexical parents.
pub(crate) fn fallible_semantic_parent(&self) -> Option<Cursor> {
let sp = unsafe {
Cursor {
x: clang_getCursorSemanticParent(self.x),
}
};
if sp == *self || !sp.is_valid() {
return None;
}
Some(sp)
}
/// Get the referent's semantic parent.
///
/// See documentation for `lexical_parent` for details on semantic vs
/// lexical parents.
pub(crate) fn semantic_parent(&self) -> Cursor {
self.fallible_semantic_parent().unwrap()
}
/// Return the number of template arguments used by this cursor's referent,
/// if the referent is either a template instantiation. Returns `None`
/// otherwise.
///
/// NOTE: This may not return `Some` for partial template specializations,
/// see #193 and #194.
pub(crate) fn num_template_args(&self) -> Option<u32> {
// XXX: `clang_Type_getNumTemplateArguments` is sort of reliable, while
// `clang_Cursor_getNumTemplateArguments` is totally unreliable.
// Therefore, try former first, and only fallback to the latter if we
// have to.
self.cur_type()
.num_template_args()
.or_else(|| {
let n: c_int =
unsafe { clang_Cursor_getNumTemplateArguments(self.x) };
if n >= 0 {
Some(n as u32)
} else {
debug_assert_eq!(n, -1);
None
}
})
.or_else(|| {
let canonical = self.canonical();
if canonical != *self {
canonical.num_template_args()
} else {
None
}
})
}
/// Get a cursor pointing to this referent's containing translation unit.
///
/// Note that we shouldn't create a `TranslationUnit` struct here, because
/// bindgen assumes there will only be one of them alive at a time, and
/// disposes it on drop. That can change if this would be required, but I
/// think we can survive fine without it.
pub(crate) fn translation_unit(&self) -> Cursor {
assert!(self.is_valid());
unsafe {
let tu = clang_Cursor_getTranslationUnit(self.x);
let cursor = Cursor {
x: clang_getTranslationUnitCursor(tu),
};
assert!(cursor.is_valid());
cursor
}
}
/// Is the referent a top level construct?
pub(crate) fn is_toplevel(&self) -> bool {
let mut semantic_parent = self.fallible_semantic_parent();
while semantic_parent.is_some() &&
(semantic_parent.unwrap().kind() == CXCursor_Namespace ||
semantic_parent.unwrap().kind() ==
CXCursor_NamespaceAlias ||
semantic_parent.unwrap().kind() == CXCursor_NamespaceRef)
{
semantic_parent =
semantic_parent.unwrap().fallible_semantic_parent();
}
let tu = self.translation_unit();
// Yes, this can happen with, e.g., macro definitions.
semantic_parent == tu.fallible_semantic_parent()
}
/// There are a few kinds of types that we need to treat specially, mainly
/// not tracking the type declaration but the location of the cursor, given
/// clang doesn't expose a proper declaration for these types.
pub(crate) fn is_template_like(&self) -> bool {
matches!(
self.kind(),
CXCursor_ClassTemplate |
CXCursor_ClassTemplatePartialSpecialization |
CXCursor_TypeAliasTemplateDecl
)
}
/// Is this Cursor pointing to a function-like macro definition?
pub(crate) fn is_macro_function_like(&self) -> bool {
unsafe { clang_Cursor_isMacroFunctionLike(self.x) != 0 }
}
/// Get the kind of referent this cursor is pointing to.
pub(crate) fn kind(&self) -> CXCursorKind {
self.x.kind
}
/// Returns true if the cursor is a definition
pub(crate) fn is_definition(&self) -> bool {
unsafe { clang_isCursorDefinition(self.x) != 0 }
}
/// Is the referent a template specialization?
pub(crate) fn is_template_specialization(&self) -> bool {
self.specialized().is_some()
}
/// Is the referent a fully specialized template specialization without any
/// remaining free template arguments?
pub(crate) fn is_fully_specialized_template(&self) -> bool {
self.is_template_specialization() &&
self.kind() != CXCursor_ClassTemplatePartialSpecialization &&
self.num_template_args().unwrap_or(0) > 0
}
/// Is the referent a template specialization that still has remaining free
/// template arguments?
pub(crate) fn is_in_non_fully_specialized_template(&self) -> bool {
if self.is_toplevel() {
return false;
}
let parent = self.semantic_parent();
if parent.is_fully_specialized_template() {
return false;
}
if !parent.is_template_like() {
return parent.is_in_non_fully_specialized_template();
}
true
}
/// Is the referent any kind of template parameter?
pub(crate) fn is_template_parameter(&self) -> bool {
matches!(
self.kind(),
CXCursor_TemplateTemplateParameter |
CXCursor_TemplateTypeParameter |
CXCursor_NonTypeTemplateParameter
)
}
/// Does the referent's type or value depend on a template parameter?
pub(crate) fn is_dependent_on_template_parameter(&self) -> bool {
fn visitor(
found_template_parameter: &mut bool,
cur: Cursor,
) -> CXChildVisitResult {
// If we found a template parameter, it is dependent.
if cur.is_template_parameter() {
*found_template_parameter = true;
return CXChildVisit_Break;
}
// Get the referent and traverse it as well.
if let Some(referenced) = cur.referenced() {
if referenced.is_template_parameter() {
*found_template_parameter = true;
return CXChildVisit_Break;
}
referenced
.visit(|next| visitor(found_template_parameter, next));
if *found_template_parameter {
return CXChildVisit_Break;
}
}
// Continue traversing the AST at the original cursor.
CXChildVisit_Recurse
}
if self.is_template_parameter() {
return true;
}
let mut found_template_parameter = false;
self.visit(|next| visitor(&mut found_template_parameter, next));
found_template_parameter
}
/// Is this cursor pointing a valid referent?
pub(crate) fn is_valid(&self) -> bool {
unsafe { clang_isInvalid(self.kind()) == 0 }
}
/// Get the source location for the referent.
pub(crate) fn location(&self) -> SourceLocation {
unsafe {
SourceLocation {
x: clang_getCursorLocation(self.x),
}
}
}
/// Get the source location range for the referent.
pub(crate) fn extent(&self) -> CXSourceRange {
unsafe { clang_getCursorExtent(self.x) }
}
/// Get the raw declaration comment for this referent, if one exists.
pub(crate) fn raw_comment(&self) -> Option<String> {
let s = unsafe {
cxstring_into_string(clang_Cursor_getRawCommentText(self.x))
};
if s.is_empty() {
None
} else {
Some(s)
}
}
/// Get the referent's parsed comment.
pub(crate) fn comment(&self) -> Comment {
unsafe {
Comment {
x: clang_Cursor_getParsedComment(self.x),
}
}
}
/// Get the referent's type.
pub(crate) fn cur_type(&self) -> Type {
unsafe {
Type {
x: clang_getCursorType(self.x),
}
}
}
/// Given that this cursor's referent is a reference to another type, or is
/// a declaration, get the cursor pointing to the referenced type or type of
/// the declared thing.
pub(crate) fn definition(&self) -> Option<Cursor> {
unsafe {
let ret = Cursor {
x: clang_getCursorDefinition(self.x),
};
if ret.is_valid() && ret.kind() != CXCursor_NoDeclFound {
Some(ret)
} else {
None
}
}
}
/// Given that this cursor's referent is reference type, get the cursor
/// pointing to the referenced type.
pub(crate) fn referenced(&self) -> Option<Cursor> {
unsafe {
let ret = Cursor {
x: clang_getCursorReferenced(self.x),
};
if ret.is_valid() {
Some(ret)
} else {
None
}
}
}
/// Get the canonical cursor for this referent.
///
/// Many types can be declared multiple times before finally being properly
/// defined. This method allows us to get the canonical cursor for the
/// referent type.
pub(crate) fn canonical(&self) -> Cursor {
unsafe {
Cursor {
x: clang_getCanonicalCursor(self.x),
}
}
}
/// Given that this cursor points to either a template specialization or a
/// template instantiation, get a cursor pointing to the template definition
/// that is being specialized.
pub(crate) fn specialized(&self) -> Option<Cursor> {
unsafe {
let ret = Cursor {
x: clang_getSpecializedCursorTemplate(self.x),
};
if ret.is_valid() {
Some(ret)
} else {
None
}
}
}
/// Assuming that this cursor's referent is a template declaration, get the
/// kind of cursor that would be generated for its specializations.
pub(crate) fn template_kind(&self) -> CXCursorKind {
unsafe { clang_getTemplateCursorKind(self.x) }
}
/// Traverse this cursor's referent and its children.
///
/// Call the given function on each AST node traversed.
pub(crate) fn visit<Visitor>(&self, mut visitor: Visitor)
where
Visitor: FnMut(Cursor) -> CXChildVisitResult,
{
let data = &mut visitor as *mut Visitor;
unsafe {
clang_visitChildren(self.x, visit_children::<Visitor>, data.cast());
}
}
/// Traverse all of this cursor's children, sorted by where they appear in source code.
///
/// Call the given function on each AST node traversed.
pub(crate) fn visit_sorted<Visitor>(
&self,
ctx: &mut BindgenContext,
mut visitor: Visitor,
) where
Visitor: FnMut(&mut BindgenContext, Cursor),
{
// FIXME(#2556): The current source order stuff doesn't account well for different levels
// of includes, or includes that show up at the same byte offset because they are passed in
// via CLI.
const SOURCE_ORDER_ENABLED: bool = false;
if !SOURCE_ORDER_ENABLED {
return self.visit(|c| {
visitor(ctx, c);
CXChildVisit_Continue
});
}
let mut children = self.collect_children();
for child in &children {
if child.kind() == CXCursor_InclusionDirective {
if let Some(included_file) = child.get_included_file_name() {
let location = child.location();
let (source_file, _, _, offset) = location.location();
if let Some(source_file) = source_file.name() {
ctx.add_include(source_file, included_file, offset);
}
}
}
}
children
.sort_by(|child1, child2| child1.cmp_by_source_order(child2, ctx));
for child in children {
visitor(ctx, child);
}
}
/// Compare source order of two cursors, considering `#include` directives.
///
/// Built-in items provided by the compiler (which don't have a source file),
/// are sorted first. Remaining files are sorted by their position in the source file.
/// If the items' source files differ, they are sorted by the position of the first
/// `#include` for their source file. If no source files are included, `None` is returned.
fn cmp_by_source_order(
&self,
other: &Self,
ctx: &BindgenContext,
) -> cmp::Ordering {
let (file, _, _, offset) = self.location().location();
let (other_file, _, _, other_offset) = other.location().location();
let (file, other_file) = match (file.name(), other_file.name()) {
(Some(file), Some(other_file)) => (file, other_file),
// Built-in definitions should come first.
(Some(_), None) => return cmp::Ordering::Greater,
(None, Some(_)) => return cmp::Ordering::Less,
(None, None) => return cmp::Ordering::Equal,
};
if file == other_file {
// Both items are in the same source file, compare by byte offset.
return offset.cmp(&other_offset);
}
let include_location = ctx.included_file_location(&file);
let other_include_location = ctx.included_file_location(&other_file);
match (include_location, other_include_location) {
(Some((file2, offset2)), _) if file2 == other_file => {
offset2.cmp(&other_offset)
}
(Some(_), None) => cmp::Ordering::Greater,
(_, Some((other_file2, other_offset2))) if file == other_file2 => {
offset.cmp(&other_offset2)
}
(None, Some(_)) => cmp::Ordering::Less,
(Some((file2, offset2)), Some((other_file2, other_offset2))) => {
if file2 == other_file2 {
offset2.cmp(&other_offset2)
} else {
cmp::Ordering::Equal
}
}
(None, None) => cmp::Ordering::Equal,
}
}
/// Collect all of this cursor's children into a vec and return them.
pub(crate) fn collect_children(&self) -> Vec<Cursor> {
let mut children = vec![];
self.visit(|c| {
children.push(c);
CXChildVisit_Continue
});
children
}
/// Does this cursor have any children?
pub(crate) fn has_children(&self) -> bool {
let mut has_children = false;
self.visit(|_| {
has_children = true;
CXChildVisit_Break
});
has_children
}
/// Does this cursor have at least `n` children?
pub(crate) fn has_at_least_num_children(&self, n: usize) -> bool {
assert!(n > 0);
let mut num_left = n;
self.visit(|_| {
num_left -= 1;
if num_left == 0 {
CXChildVisit_Break
} else {
CXChildVisit_Continue
}
});
num_left == 0
}
/// Returns whether the given location contains a cursor with the given
/// kind in the first level of nesting underneath (doesn't look
/// recursively).
pub(crate) fn contains_cursor(&self, kind: CXCursorKind) -> bool {
let mut found = false;
self.visit(|c| {
if c.kind() == kind {
found = true;
CXChildVisit_Break
} else {
CXChildVisit_Continue
}
});
found
}
/// Is the referent an inlined function?
pub(crate) fn is_inlined_function(&self) -> bool {
unsafe { clang_Cursor_isFunctionInlined(self.x) != 0 }
}
/// Is the referent a defaulted function?
pub(crate) fn is_defaulted_function(&self) -> bool {
unsafe { clang_CXXMethod_isDefaulted(self.x) != 0 }
}
/// Is the referent a deleted function?
pub(crate) fn is_deleted_function(&self) -> bool {
// Unfortunately, libclang doesn't yet have an API for checking if a
// member function is deleted, but the following should be a good
// enough approximation.
// Deleted functions are implicitly inline according to paragraph 4 of
// [dcl.fct.def.delete] in the C++ standard. Normal inline functions
// have a definition in the same translation unit, so if this is an
// inline function without a definition, and it's not a defaulted
// function, we can reasonably safely conclude that it's a deleted
// function.
self.is_inlined_function() &&
self.definition().is_none() &&
!self.is_defaulted_function()
}
/// Is the referent a bit field declaration?
pub(crate) fn is_bit_field(&self) -> bool {
unsafe { clang_Cursor_isBitField(self.x) != 0 }
}
/// Get a cursor to the bit field's width expression, or `None` if it's not
/// a bit field.
pub(crate) fn bit_width_expr(&self) -> Option<Cursor> {
if !self.is_bit_field() {
return None;
}
let mut result = None;
self.visit(|cur| {
// The first child may or may not be a TypeRef, depending on whether
// the field's type is builtin. Skip it.
if cur.kind() == CXCursor_TypeRef {
return CXChildVisit_Continue;
}
// The next expression or literal is the bit width.
result = Some(cur);
CXChildVisit_Break
});
result
}
/// Get the width of this cursor's referent bit field, or `None` if the
/// referent is not a bit field or if the width could not be evaluated.
pub(crate) fn bit_width(&self) -> Option<u32> {
// It is not safe to check the bit width without ensuring it doesn't
// depend on a template parameter. See
if self.bit_width_expr()?.is_dependent_on_template_parameter() {
return None;
}
unsafe {
let w = clang_getFieldDeclBitWidth(self.x);
if w == -1 {
None
} else {
Some(w as u32)
}
}
}
/// Get the integer representation type used to hold this cursor's referent
/// enum type.
pub(crate) fn enum_type(&self) -> Option<Type> {
unsafe {
let t = Type {
x: clang_getEnumDeclIntegerType(self.x),
};
if t.is_valid() {
Some(t)
} else {
None
}
}
}
/// Get the boolean constant value for this cursor's enum variant referent.
///
/// Returns None if the cursor's referent is not an enum variant.
pub(crate) fn enum_val_boolean(&self) -> Option<bool> {
unsafe {
if self.kind() == CXCursor_EnumConstantDecl {
Some(clang_getEnumConstantDeclValue(self.x) != 0)
} else {
None
}
}
}
/// Get the signed constant value for this cursor's enum variant referent.
///
/// Returns None if the cursor's referent is not an enum variant.
pub(crate) fn enum_val_signed(&self) -> Option<i64> {
unsafe {
if self.kind() == CXCursor_EnumConstantDecl {
#[allow(clippy::unnecessary_cast)]
Some(clang_getEnumConstantDeclValue(self.x) as i64)
} else {
None
}
}
}
/// Get the unsigned constant value for this cursor's enum variant referent.
///
/// Returns None if the cursor's referent is not an enum variant.
pub(crate) fn enum_val_unsigned(&self) -> Option<u64> {
unsafe {
if self.kind() == CXCursor_EnumConstantDecl {
#[allow(clippy::unnecessary_cast)]
Some(clang_getEnumConstantDeclUnsignedValue(self.x) as u64)
} else {
None
}
}
}
/// Does this cursor have the given attributes?
pub(crate) fn has_attrs<const N: usize>(
&self,
attrs: &[Attribute; N],
) -> [bool; N] {
let mut found_attrs = [false; N];
let mut found_count = 0;
self.visit(|cur| {
let kind = cur.kind();
for (idx, attr) in attrs.iter().enumerate() {
let found_attr = &mut found_attrs[idx];
if !*found_attr {
// `attr.name` and` attr.token_kind` are checked against unexposed attributes only.
if attr.kind.map_or(false, |k| k == kind) ||
(kind == CXCursor_UnexposedAttr &&
cur.tokens().iter().any(|t| {
t.kind == attr.token_kind &&
t.spelling() == attr.name
}))
{
*found_attr = true;
found_count += 1;
if found_count == N {
return CXChildVisit_Break;
}
}
}
}
CXChildVisit_Continue
});
found_attrs
}
/// Given that this cursor's referent is a `typedef`, get the `Type` that is
/// being aliased.
pub(crate) fn typedef_type(&self) -> Option<Type> {
let inner = Type {
x: unsafe { clang_getTypedefDeclUnderlyingType(self.x) },
};
if inner.is_valid() {
Some(inner)
} else {
None
}
}
/// Get the linkage kind for this cursor's referent.
///
/// This only applies to functions and variables.
pub(crate) fn linkage(&self) -> CXLinkageKind {
unsafe { clang_getCursorLinkage(self.x) }
}
/// Get the visibility of this cursor's referent.
pub(crate) fn visibility(&self) -> CXVisibilityKind {
unsafe { clang_getCursorVisibility(self.x) }
}
/// Given that this cursor's referent is a function, return cursors to its
/// parameters.
///
/// Returns None if the cursor's referent is not a function/method call or
/// declaration.
pub(crate) fn args(&self) -> Option<Vec<Cursor>> {
// match self.kind() {
// CXCursor_FunctionDecl |
// CXCursor_CXXMethod => {
self.num_args().ok().map(|num| {
(0..num)
.map(|i| Cursor {
x: unsafe { clang_Cursor_getArgument(self.x, i as c_uint) },
})
.collect()
})
}
/// Given that this cursor's referent is a function/method call or
/// declaration, return the number of arguments it takes.
///
/// Returns Err if the cursor's referent is not a function/method call or
/// declaration.
pub(crate) fn num_args(&self) -> Result<u32, ()> {
unsafe {
let w = clang_Cursor_getNumArguments(self.x);
if w == -1 {
Err(())
} else {
Ok(w as u32)
}
}
}
/// Get the access specifier for this cursor's referent.
pub(crate) fn access_specifier(&self) -> CX_CXXAccessSpecifier {
unsafe { clang_getCXXAccessSpecifier(self.x) }
}
/// Is the cursor's referrent publically accessible in C++?
///
/// Returns true if self.access_specifier() is `CX_CXXPublic` or
/// `CX_CXXInvalidAccessSpecifier`.
pub(crate) fn public_accessible(&self) -> bool {
let access = self.access_specifier();
access == CX_CXXPublic || access == CX_CXXInvalidAccessSpecifier
}
/// Is this cursor's referent a field declaration that is marked as
/// `mutable`?
pub(crate) fn is_mutable_field(&self) -> bool {
unsafe { clang_CXXField_isMutable(self.x) != 0 }
}
/// Get the offset of the field represented by the Cursor.
pub(crate) fn offset_of_field(&self) -> Result<usize, LayoutError> {
let offset = unsafe { clang_Cursor_getOffsetOfField(self.x) };
if offset < 0 {
Err(LayoutError::from(offset as i32))
} else {
Ok(offset as usize)
}
}
/// Is this cursor's referent a member function that is declared `static`?
pub(crate) fn method_is_static(&self) -> bool {
unsafe { clang_CXXMethod_isStatic(self.x) != 0 }
}
/// Is this cursor's referent a member function that is declared `const`?
pub(crate) fn method_is_const(&self) -> bool {
unsafe { clang_CXXMethod_isConst(self.x) != 0 }
}
/// Is this cursor's referent a member function that is virtual?
pub(crate) fn method_is_virtual(&self) -> bool {
unsafe { clang_CXXMethod_isVirtual(self.x) != 0 }
}
/// Is this cursor's referent a member function that is pure virtual?
pub(crate) fn method_is_pure_virtual(&self) -> bool {
unsafe { clang_CXXMethod_isPureVirtual(self.x) != 0 }
}
/// Is this cursor's referent a struct or class with virtual members?
pub(crate) fn is_virtual_base(&self) -> bool {
unsafe { clang_isVirtualBase(self.x) != 0 }
}
/// Try to evaluate this cursor.
pub(crate) fn evaluate(&self) -> Option<EvalResult> {
EvalResult::new(*self)
}
/// Return the result type for this cursor
pub(crate) fn ret_type(&self) -> Option<Type> {
let rt = Type {
x: unsafe { clang_getCursorResultType(self.x) },
};
if rt.is_valid() {
Some(rt)
} else {
None
}
}
/// Gets the tokens that correspond to that cursor.
pub(crate) fn tokens(&self) -> RawTokens {
RawTokens::new(self)
}
/// Gets the tokens that correspond to that cursor as `cexpr` tokens.
pub(crate) fn cexpr_tokens(self) -> Vec<cexpr::token::Token> {
self.tokens()
.iter()
.filter_map(|token| token.as_cexpr_token())
.collect()
}
/// Obtain the real path name of a cursor of InclusionDirective kind.
///
/// Returns None if the cursor does not include a file, otherwise the file's full name
pub(crate) fn get_included_file_name(&self) -> Option<String> {
let file = unsafe { clang_sys::clang_getIncludedFile(self.x) };
if file.is_null() {
None
} else {
Some(unsafe {
cxstring_into_string(clang_sys::clang_getFileName(file))
})
}
}
}
/// A struct that owns the tokenizer result from a given cursor.
pub(crate) struct RawTokens<'a> {
cursor: &'a Cursor,
tu: CXTranslationUnit,
tokens: *mut CXToken,
token_count: c_uint,
}
impl<'a> RawTokens<'a> {
fn new(cursor: &'a Cursor) -> Self {
let mut tokens = ptr::null_mut();
let mut token_count = 0;
let range = cursor.extent();
let tu = unsafe { clang_Cursor_getTranslationUnit(cursor.x) };
unsafe { clang_tokenize(tu, range, &mut tokens, &mut token_count) };
Self {
cursor,
tu,
tokens,
token_count,
}
}
fn as_slice(&self) -> &[CXToken] {
if self.tokens.is_null() {
return &[];
}
unsafe { slice::from_raw_parts(self.tokens, self.token_count as usize) }
}
/// Get an iterator over these tokens.
pub(crate) fn iter(&self) -> ClangTokenIterator {
ClangTokenIterator {
tu: self.tu,
raw: self.as_slice().iter(),
}
}
}
impl<'a> Drop for RawTokens<'a> {
fn drop(&mut self) {
if !self.tokens.is_null() {
unsafe {
clang_disposeTokens(
self.tu,
self.tokens,
self.token_count as c_uint,
);
}
}
}
}
/// A raw clang token, that exposes only kind, spelling, and extent. This is a
/// slightly more convenient version of `CXToken` which owns the spelling
/// string and extent.
#[derive(Debug)]
pub(crate) struct ClangToken {
spelling: CXString,
/// The extent of the token. This is the same as the relevant member from
/// `CXToken`.
pub(crate) extent: CXSourceRange,
/// The kind of the token. This is the same as the relevant member from
/// `CXToken`.
pub(crate) kind: CXTokenKind,
}
impl ClangToken {
/// Get the token spelling, without being converted to utf-8.
pub(crate) fn spelling(&self) -> &[u8] {
let c_str = unsafe {
CStr::from_ptr(clang_getCString(self.spelling) as *const _)
};
c_str.to_bytes()
}
/// Converts a ClangToken to a `cexpr` token if possible.
pub(crate) fn as_cexpr_token(&self) -> Option<cexpr::token::Token> {
use cexpr::token;
let kind = match self.kind {
CXToken_Punctuation => token::Kind::Punctuation,
CXToken_Literal => token::Kind::Literal,
CXToken_Identifier => token::Kind::Identifier,
CXToken_Keyword => token::Kind::Keyword,
// NB: cexpr is not too happy about comments inside
// expressions, so we strip them down here.
CXToken_Comment => return None,
_ => {
warn!("Found unexpected token kind: {:?}", self);
return None;
}
};
Some(token::Token {
kind,
raw: self.spelling().to_vec().into_boxed_slice(),
})
}
}
impl Drop for ClangToken {
fn drop(&mut self) {
unsafe { clang_disposeString(self.spelling) }
}
}
/// An iterator over a set of Tokens.
pub(crate) struct ClangTokenIterator<'a> {
tu: CXTranslationUnit,
raw: slice::Iter<'a, CXToken>,
}
impl<'a> Iterator for ClangTokenIterator<'a> {
type Item = ClangToken;
fn next(&mut self) -> Option<Self::Item> {
let raw = self.raw.next()?;
unsafe {
let kind = clang_getTokenKind(*raw);
let spelling = clang_getTokenSpelling(self.tu, *raw);
let extent = clang_getTokenExtent(self.tu, *raw);
Some(ClangToken {
kind,
extent,
spelling,
})
}
}
}
/// Checks whether the name looks like an identifier, i.e. is alphanumeric
/// (including '_') and does not start with a digit.
pub(crate) fn is_valid_identifier(name: &str) -> bool {
let mut chars = name.chars();
let first_valid = chars
.next()
.map(|c| c.is_alphabetic() || c == '_')
.unwrap_or(false);
first_valid && chars.all(|c| c.is_alphanumeric() || c == '_')
}
extern "C" fn visit_children<Visitor>(
cur: CXCursor,
_parent: CXCursor,
data: CXClientData,
) -> CXChildVisitResult
where
Visitor: FnMut(Cursor) -> CXChildVisitResult,
{
let func: &mut Visitor = unsafe { &mut *(data as *mut Visitor) };
let child = Cursor { x: cur };
(*func)(child)
}
impl PartialEq for Cursor {
fn eq(&self, other: &Cursor) -> bool {
unsafe { clang_equalCursors(self.x, other.x) == 1 }
}
}
impl Eq for Cursor {}
impl Hash for Cursor {
fn hash<H: Hasher>(&self, state: &mut H) {
unsafe { clang_hashCursor(self.x) }.hash(state)
}
}
/// The type of a node in clang's AST.
#[derive(Clone, Copy)]
pub(crate) struct Type {
x: CXType,
}
impl PartialEq for Type {
fn eq(&self, other: &Self) -> bool {
unsafe { clang_equalTypes(self.x, other.x) != 0 }
}
}
impl Eq for Type {}
impl fmt::Debug for Type {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(
fmt,
"Type({}, kind: {}, cconv: {}, decl: {:?}, canon: {:?})",
self.spelling(),
type_to_str(self.kind()),
self.call_conv(),
self.declaration(),
self.declaration().canonical()
)
}
}
/// An error about the layout of a struct, class, or type.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub(crate) enum LayoutError {
/// Asked for the layout of an invalid type.
Invalid,
/// Asked for the layout of an incomplete type.
Incomplete,
/// Asked for the layout of a dependent type.
Dependent,
/// Asked for the layout of a type that does not have constant size.
NotConstantSize,
/// Asked for the layout of a field in a type that does not have such a
/// field.
InvalidFieldName,
/// An unknown layout error.
Unknown,
}
impl ::std::convert::From<i32> for LayoutError {
fn from(val: i32) -> Self {
use self::LayoutError::*;
match val {
CXTypeLayoutError_Invalid => Invalid,
CXTypeLayoutError_Incomplete => Incomplete,
CXTypeLayoutError_Dependent => Dependent,
CXTypeLayoutError_NotConstantSize => NotConstantSize,
CXTypeLayoutError_InvalidFieldName => InvalidFieldName,
_ => Unknown,
}
}
}
impl Type {
/// Get this type's kind.
pub(crate) fn kind(&self) -> CXTypeKind {
self.x.kind
}
/// Get a cursor pointing to this type's declaration.
pub(crate) fn declaration(&self) -> Cursor {
unsafe {
Cursor {
x: clang_getTypeDeclaration(self.x),
}
}
}
/// Get the canonical declaration of this type, if it is available.
pub(crate) fn canonical_declaration(
&self,
location: Option<&Cursor>,
) -> Option<CanonicalTypeDeclaration> {
let mut declaration = self.declaration();
if !declaration.is_valid() {
if let Some(location) = location {
let mut location = *location;
if let Some(referenced) = location.referenced() {
location = referenced;
}
if location.is_template_like() {
declaration = location;
}
}
}
let canonical = declaration.canonical();
if canonical.is_valid() && canonical.kind() != CXCursor_NoDeclFound {
Some(CanonicalTypeDeclaration(*self, canonical))
} else {
None
}
}
/// Get a raw display name for this type.
pub(crate) fn spelling(&self) -> String {
let s = unsafe { cxstring_into_string(clang_getTypeSpelling(self.x)) };
// Clang 5.0 introduced changes in the spelling API so it returned the
// full qualified name. Let's undo that here.
if s.split("::").all(is_valid_identifier) {
if let Some(s) = s.split("::").last() {
return s.to_owned();
}
}
s
}
/// Is this type const qualified?
pub(crate) fn is_const(&self) -> bool {
unsafe { clang_isConstQualifiedType(self.x) != 0 }
}
#[inline]
fn is_non_deductible_auto_type(&self) -> bool {
debug_assert_eq!(self.kind(), CXType_Auto);
self.canonical_type() == *self
}
#[inline]
fn clang_size_of(&self, ctx: &BindgenContext) -> c_longlong {
match self.kind() {
CXType_RValueReference | CXType_LValueReference => {
ctx.target_pointer_size() as c_longlong
}
CXType_Auto if self.is_non_deductible_auto_type() => -6,
_ => unsafe { clang_Type_getSizeOf(self.x) },
}
}
#[inline]
fn clang_align_of(&self, ctx: &BindgenContext) -> c_longlong {
match self.kind() {
CXType_RValueReference | CXType_LValueReference => {
ctx.target_pointer_size() as c_longlong
}
CXType_Auto if self.is_non_deductible_auto_type() => -6,
_ => unsafe { clang_Type_getAlignOf(self.x) },
}
}
/// What is the size of this type? Paper over invalid types by returning `0`
/// for them.
pub(crate) fn size(&self, ctx: &BindgenContext) -> usize {
let val = self.clang_size_of(ctx);
if val < 0 {
0
} else {
val as usize
}
}
/// What is the size of this type?
pub(crate) fn fallible_size(
&self,
ctx: &BindgenContext,
) -> Result<usize, LayoutError> {
let val = self.clang_size_of(ctx);
if val < 0 {
Err(LayoutError::from(val as i32))
} else {
Ok(val as usize)
}
}
/// What is the alignment of this type? Paper over invalid types by
/// returning `0`.
pub(crate) fn align(&self, ctx: &BindgenContext) -> usize {
let val = self.clang_align_of(ctx);
if val < 0 {
0
} else {
val as usize
}
}
/// What is the alignment of this type?
pub(crate) fn fallible_align(
&self,
ctx: &BindgenContext,
) -> Result<usize, LayoutError> {
let val = self.clang_align_of(ctx);
if val < 0 {
Err(LayoutError::from(val as i32))
} else {
Ok(val as usize)
}
}
/// Get the layout for this type, or an error describing why it does not
/// have a valid layout.
pub(crate) fn fallible_layout(
&self,
ctx: &BindgenContext,
) -> Result<crate::ir::layout::Layout, LayoutError> {
use crate::ir::layout::Layout;
let size = self.fallible_size(ctx)?;
let align = self.fallible_align(ctx)?;
Ok(Layout::new(size, align))
}
/// Get the number of template arguments this type has, or `None` if it is
/// not some kind of template.
pub(crate) fn num_template_args(&self) -> Option<u32> {
let n = unsafe { clang_Type_getNumTemplateArguments(self.x) };
if n >= 0 {
Some(n as u32)
} else {
debug_assert_eq!(n, -1);
None
}
}
/// If this type is a class template specialization, return its
/// template arguments. Otherwise, return None.
pub(crate) fn template_args(&self) -> Option<TypeTemplateArgIterator> {
self.num_template_args().map(|n| TypeTemplateArgIterator {
x: self.x,
length: n,
index: 0,
})
}
/// Given that this type is a function prototype, return the types of its parameters.
///
/// Returns None if the type is not a function prototype.
pub(crate) fn args(&self) -> Option<Vec<Type>> {
self.num_args().ok().map(|num| {
(0..num)
.map(|i| Type {
x: unsafe { clang_getArgType(self.x, i as c_uint) },
})
.collect()
})
}
/// Given that this type is a function prototype, return the number of arguments it takes.
///
/// Returns Err if the type is not a function prototype.
pub(crate) fn num_args(&self) -> Result<u32, ()> {
unsafe {
let w = clang_getNumArgTypes(self.x);
if w == -1 {
Err(())
} else {
Ok(w as u32)
}
}
}
/// Given that this type is a pointer type, return the type that it points
/// to.
pub(crate) fn pointee_type(&self) -> Option<Type> {
match self.kind() {
CXType_Pointer |
CXType_RValueReference |
CXType_LValueReference |
CXType_MemberPointer |
CXType_BlockPointer |
CXType_ObjCObjectPointer => {
let ret = Type {
x: unsafe { clang_getPointeeType(self.x) },
};
debug_assert!(ret.is_valid());
Some(ret)
}
_ => None,
}
}
/// Given that this type is an array, vector, or complex type, return the
/// type of its elements.
pub(crate) fn elem_type(&self) -> Option<Type> {
let current_type = Type {
x: unsafe { clang_getElementType(self.x) },
};
if current_type.is_valid() {
Some(current_type)
} else {
None
}
}
/// Given that this type is an array or vector type, return its number of
/// elements.
pub(crate) fn num_elements(&self) -> Option<usize> {
let num_elements_returned = unsafe { clang_getNumElements(self.x) };
if num_elements_returned != -1 {
Some(num_elements_returned as usize)
} else {
None
}
}
/// Get the canonical version of this type. This sees through `typedef`s and
/// aliases to get the underlying, canonical type.
pub(crate) fn canonical_type(&self) -> Type {
unsafe {
Type {
x: clang_getCanonicalType(self.x),
}
}
}
/// Is this type a variadic function type?
pub(crate) fn is_variadic(&self) -> bool {
unsafe { clang_isFunctionTypeVariadic(self.x) != 0 }
}
/// Given that this type is a function type, get the type of its return
/// value.
pub(crate) fn ret_type(&self) -> Option<Type> {
let rt = Type {
x: unsafe { clang_getResultType(self.x) },
};
if rt.is_valid() {
Some(rt)
} else {
None
}
}
/// Given that this type is a function type, get its calling convention. If
/// this is not a function type, `CXCallingConv_Invalid` is returned.
pub(crate) fn call_conv(&self) -> CXCallingConv {
unsafe { clang_getFunctionTypeCallingConv(self.x) }
}
/// For elaborated types (types which use `class`, `struct`, or `union` to
/// disambiguate types from local bindings), get the underlying type.
pub(crate) fn named(&self) -> Type {
unsafe {
Type {
x: clang_Type_getNamedType(self.x),
}
}
}
/// Is this a valid type?
pub(crate) fn is_valid(&self) -> bool {
self.kind() != CXType_Invalid
}
/// Is this a valid and exposed type?
pub(crate) fn is_valid_and_exposed(&self) -> bool {
self.is_valid() && self.kind() != CXType_Unexposed
}
/// Is this type a fully instantiated template?
pub(crate) fn is_fully_instantiated_template(&self) -> bool {
// Yep, the spelling of this containing type-parameter is extremely
// nasty... But can happen in <type_traits>. Unfortunately I couldn't
// reduce it enough :(
self.template_args().map_or(false, |args| args.len() > 0) &&
!matches!(
self.declaration().kind(),
CXCursor_ClassTemplatePartialSpecialization |
CXCursor_TypeAliasTemplateDecl |
CXCursor_TemplateTemplateParameter
)
}
/// Is this type an associated template type? Eg `T::Associated` in
/// this example:
///
/// ```c++
/// template <typename T>
/// class Foo {
/// typename T::Associated member;
/// };
/// ```
pub(crate) fn is_associated_type(&self) -> bool {
// This is terrible :(
fn hacky_parse_associated_type<S: AsRef<str>>(spelling: S) -> bool {
lazy_static! {
static ref ASSOC_TYPE_RE: regex::Regex = regex::Regex::new(
r"typename type\-parameter\-\d+\-\d+::.+"
)
.unwrap();
}
ASSOC_TYPE_RE.is_match(spelling.as_ref())
}
self.kind() == CXType_Unexposed &&
(hacky_parse_associated_type(self.spelling()) ||
hacky_parse_associated_type(
self.canonical_type().spelling(),
))
}
}
/// The `CanonicalTypeDeclaration` type exists as proof-by-construction that its
/// cursor is the canonical declaration for its type. If you have a
/// `CanonicalTypeDeclaration` instance, you know for sure that the type and
/// cursor match up in a canonical declaration relationship, and it simply
/// cannot be otherwise.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct CanonicalTypeDeclaration(Type, Cursor);
impl CanonicalTypeDeclaration {
/// Get the type.
pub(crate) fn ty(&self) -> &Type {
&self.0
}
/// Get the type's canonical declaration cursor.
pub(crate) fn cursor(&self) -> &Cursor {
&self.1
}
}
/// An iterator for a type's template arguments.
pub(crate) struct TypeTemplateArgIterator {
x: CXType,
length: u32,
index: u32,
}
impl Iterator for TypeTemplateArgIterator {
type Item = Type;
fn next(&mut self) -> Option<Type> {
if self.index < self.length {
let idx = self.index as c_uint;
self.index += 1;
Some(Type {
x: unsafe { clang_Type_getTemplateArgumentAsType(self.x, idx) },
})
} else {
None
}
}
}
impl ExactSizeIterator for TypeTemplateArgIterator {
fn len(&self) -> usize {
assert!(self.index <= self.length);
(self.length - self.index) as usize
}
}
/// A `SourceLocation` is a file, line, column, and byte offset location for
/// some source text.
pub(crate) struct SourceLocation {
x: CXSourceLocation,
}
impl SourceLocation {
/// Get the (file, line, column, byte offset) tuple for this source
/// location.
pub(crate) fn location(&self) -> (File, usize, usize, usize) {
unsafe {
let mut file = mem::zeroed();
let mut line = 0;
let mut col = 0;
let mut off = 0;
clang_getSpellingLocation(
self.x, &mut file, &mut line, &mut col, &mut off,
);
(File { x: file }, line as usize, col as usize, off as usize)
}
}
}
impl fmt::Display for SourceLocation {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let (file, line, col, _) = self.location();
if let Some(name) = file.name() {
write!(f, "{}:{}:{}", name, line, col)
} else {
"builtin definitions".fmt(f)
}
}
}
impl fmt::Debug for SourceLocation {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self)
}
}
/// A comment in the source text.
///
/// Comments are sort of parsed by Clang, and have a tree structure.
pub(crate) struct Comment {
x: CXComment,
}
impl Comment {
/// What kind of comment is this?
pub(crate) fn kind(&self) -> CXCommentKind {
unsafe { clang_Comment_getKind(self.x) }
}
/// Get this comment's children comment
pub(crate) fn get_children(&self) -> CommentChildrenIterator {
CommentChildrenIterator {
parent: self.x,
length: unsafe { clang_Comment_getNumChildren(self.x) },
index: 0,
}
}
/// Given that this comment is the start or end of an HTML tag, get its tag
/// name.
pub(crate) fn get_tag_name(&self) -> String {
unsafe { cxstring_into_string(clang_HTMLTagComment_getTagName(self.x)) }
}
/// Given that this comment is an HTML start tag, get its attributes.
pub(crate) fn get_tag_attrs(&self) -> CommentAttributesIterator {
CommentAttributesIterator {
x: self.x,
length: unsafe { clang_HTMLStartTag_getNumAttrs(self.x) },
index: 0,
}
}
}
/// An iterator for a comment's children
pub(crate) struct CommentChildrenIterator {
parent: CXComment,
length: c_uint,
index: c_uint,
}
impl Iterator for CommentChildrenIterator {
type Item = Comment;
fn next(&mut self) -> Option<Comment> {
if self.index < self.length {
let idx = self.index;
self.index += 1;
Some(Comment {
x: unsafe { clang_Comment_getChild(self.parent, idx) },
})
} else {
None
}
}
}
/// An HTML start tag comment attribute
pub(crate) struct CommentAttribute {
/// HTML start tag attribute name
pub(crate) name: String,
/// HTML start tag attribute value
pub(crate) value: String,
}
/// An iterator for a comment's attributes
pub(crate) struct CommentAttributesIterator {
x: CXComment,
length: c_uint,
index: c_uint,
}
impl Iterator for CommentAttributesIterator {
type Item = CommentAttribute;
fn next(&mut self) -> Option<CommentAttribute> {
if self.index < self.length {
let idx = self.index;
self.index += 1;
Some(CommentAttribute {
name: unsafe {
cxstring_into_string(clang_HTMLStartTag_getAttrName(
self.x, idx,
))
},
value: unsafe {
cxstring_into_string(clang_HTMLStartTag_getAttrValue(
self.x, idx,
))
},
})
} else {
None
}
}
}
/// A source file.
pub(crate) struct File {
x: CXFile,
}
impl File {
/// Get the name of this source file.
pub(crate) fn name(&self) -> Option<String> {
if self.x.is_null() {
return None;
}
Some(unsafe { cxstring_into_string(clang_getFileName(self.x)) })
}
}
fn cxstring_to_string_leaky(s: CXString) -> String {
if s.data.is_null() {
return "".to_owned();
}
let c_str = unsafe { CStr::from_ptr(clang_getCString(s) as *const _) };
c_str.to_string_lossy().into_owned()
}
fn cxstring_into_string(s: CXString) -> String {
let ret = cxstring_to_string_leaky(s);
unsafe { clang_disposeString(s) };
ret
}
/// An `Index` is an environment for a set of translation units that will
/// typically end up linked together in one final binary.
pub(crate) struct Index {
x: CXIndex,
}
impl Index {
/// Construct a new `Index`.
///
/// The `pch` parameter controls whether declarations in pre-compiled
/// headers are included when enumerating a translation unit's "locals".
///
/// The `diag` parameter controls whether debugging diagnostics are enabled.
pub(crate) fn new(pch: bool, diag: bool) -> Index {
unsafe {
Index {
x: clang_createIndex(pch as c_int, diag as c_int),
}
}
}
}
impl fmt::Debug for Index {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "Index {{ }}")
}
}
impl Drop for Index {
fn drop(&mut self) {
unsafe {
clang_disposeIndex(self.x);
}
}
}
/// A translation unit (or "compilation unit").
pub(crate) struct TranslationUnit {
x: CXTranslationUnit,
}
impl fmt::Debug for TranslationUnit {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "TranslationUnit {{ }}")
}
}
impl TranslationUnit {
/// Parse a source file into a translation unit.
pub(crate) fn parse(
ix: &Index,
file: &str,
cmd_args: &[Box<str>],
unsaved: &[UnsavedFile],
opts: CXTranslationUnit_Flags,
) -> Option<TranslationUnit> {
let fname = CString::new(file).unwrap();
let _c_args: Vec<CString> = cmd_args
.iter()
.map(|s| CString::new(s.as_bytes()).unwrap())
.collect();
let c_args: Vec<*const c_char> =
_c_args.iter().map(|s| s.as_ptr()).collect();
let mut c_unsaved: Vec<CXUnsavedFile> =
unsaved.iter().map(|f| f.x).collect();
let tu = unsafe {
clang_parseTranslationUnit(
ix.x,
fname.as_ptr(),
c_args.as_ptr(),
c_args.len() as c_int,
c_unsaved.as_mut_ptr(),
c_unsaved.len() as c_uint,
opts,
)
};
if tu.is_null() {
None
} else {
Some(TranslationUnit { x: tu })
}
}
/// Get the Clang diagnostic information associated with this translation
/// unit.
pub(crate) fn diags(&self) -> Vec<Diagnostic> {
unsafe {
let num = clang_getNumDiagnostics(self.x) as usize;
let mut diags = vec![];
for i in 0..num {
diags.push(Diagnostic {
x: clang_getDiagnostic(self.x, i as c_uint),
});
}
diags
}
}
/// Get a cursor pointing to the root of this translation unit's AST.
pub(crate) fn cursor(&self) -> Cursor {
unsafe {
Cursor {
x: clang_getTranslationUnitCursor(self.x),
}
}
}
/// Is this the null translation unit?
pub(crate) fn is_null(&self) -> bool {
self.x.is_null()
}
}
impl Drop for TranslationUnit {
fn drop(&mut self) {
unsafe {
clang_disposeTranslationUnit(self.x);
}
}
}
/// A diagnostic message generated while parsing a translation unit.
pub(crate) struct Diagnostic {
x: CXDiagnostic,
}
impl Diagnostic {
/// Format this diagnostic message as a string, using the given option bit
/// flags.
pub(crate) fn format(&self) -> String {
unsafe {
let opts = clang_defaultDiagnosticDisplayOptions();
cxstring_into_string(clang_formatDiagnostic(self.x, opts))
}
}
/// What is the severity of this diagnostic message?
pub(crate) fn severity(&self) -> CXDiagnosticSeverity {
unsafe { clang_getDiagnosticSeverity(self.x) }
}
}
impl Drop for Diagnostic {
/// Destroy this diagnostic message.
fn drop(&mut self) {
unsafe {
clang_disposeDiagnostic(self.x);
}
}
}
/// A file which has not been saved to disk.
pub(crate) struct UnsavedFile {
x: CXUnsavedFile,
/// The name of the unsaved file. Kept here to avoid leaving dangling pointers in
/// `CXUnsavedFile`.
pub(crate) name: CString,
contents: CString,
}
impl UnsavedFile {
/// Construct a new unsaved file with the given `name` and `contents`.
pub(crate) fn new(name: &str, contents: &str) -> UnsavedFile {
let name = CString::new(name.as_bytes()).unwrap();
let contents = CString::new(contents.as_bytes()).unwrap();
let x = CXUnsavedFile {
Filename: name.as_ptr(),
Contents: contents.as_ptr(),
Length: contents.as_bytes().len() as c_ulong,
};
UnsavedFile { x, name, contents }
}
}
impl fmt::Debug for UnsavedFile {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(
fmt,
"UnsavedFile(name: {:?}, contents: {:?})",
self.name, self.contents
)
}
}
/// Convert a cursor kind into a static string.
pub(crate) fn kind_to_str(x: CXCursorKind) -> String {
unsafe { cxstring_into_string(clang_getCursorKindSpelling(x)) }
}
/// Convert a type kind to a static string.
pub(crate) fn type_to_str(x: CXTypeKind) -> String {
unsafe { cxstring_into_string(clang_getTypeKindSpelling(x)) }
}
/// Dump the Clang AST to stdout for debugging purposes.
pub(crate) fn ast_dump(c: &Cursor, depth: isize) -> CXChildVisitResult {
fn print_indent<S: AsRef<str>>(depth: isize, s: S) {
for _ in 0..depth {
print!(" ");
}
println!("{}", s.as_ref());
}
fn print_cursor<S: AsRef<str>>(depth: isize, prefix: S, c: &Cursor) {
let prefix = prefix.as_ref();
print_indent(
depth,
format!(" {}kind = {}", prefix, kind_to_str(c.kind())),
);
print_indent(
depth,
format!(" {}spelling = \"{}\"", prefix, c.spelling()),
);
print_indent(depth, format!(" {}location = {}", prefix, c.location()));
print_indent(
depth,
format!(" {}is-definition? {}", prefix, c.is_definition()),
);
print_indent(
depth,
format!(" {}is-declaration? {}", prefix, c.is_declaration()),
);
print_indent(
depth,
format!(
" {}is-inlined-function? {}",
prefix,
c.is_inlined_function()
),
);
let templ_kind = c.template_kind();
if templ_kind != CXCursor_NoDeclFound {
print_indent(
depth,
format!(
" {}template-kind = {}",
prefix,
kind_to_str(templ_kind)
),
);
}
if let Some(usr) = c.usr() {
print_indent(depth, format!(" {}usr = \"{}\"", prefix, usr));
}
if let Ok(num) = c.num_args() {
print_indent(depth, format!(" {}number-of-args = {}", prefix, num));
}
if let Some(num) = c.num_template_args() {
print_indent(
depth,
format!(" {}number-of-template-args = {}", prefix, num),
);
}
if c.is_bit_field() {
let width = match c.bit_width() {
Some(w) => w.to_string(),
None => "<unevaluable>".to_string(),
};
print_indent(depth, format!(" {}bit-width = {}", prefix, width));
}
if let Some(ty) = c.enum_type() {
print_indent(
depth,
format!(" {}enum-type = {}", prefix, type_to_str(ty.kind())),
);
}
if let Some(val) = c.enum_val_signed() {
print_indent(depth, format!(" {}enum-val = {}", prefix, val));
}
if let Some(ty) = c.typedef_type() {
print_indent(
depth,
format!(" {}typedef-type = {}", prefix, type_to_str(ty.kind())),
);
}
if let Some(ty) = c.ret_type() {
print_indent(
depth,
format!(" {}ret-type = {}", prefix, type_to_str(ty.kind())),
);
}
if let Some(refd) = c.referenced() {
if refd != *c {
println!();
print_cursor(
depth,
String::from(prefix) + "referenced.",
&refd,
);
}
}
let canonical = c.canonical();
if canonical != *c {
println!();
print_cursor(
depth,
String::from(prefix) + "canonical.",
&canonical,
);
}
if let Some(specialized) = c.specialized() {
if specialized != *c {
println!();
print_cursor(
depth,
String::from(prefix) + "specialized.",
&specialized,
);
}
}
if let Some(parent) = c.fallible_semantic_parent() {
println!();
print_cursor(
depth,
String::from(prefix) + "semantic-parent.",
&parent,
);
}
}
fn print_type<S: AsRef<str>>(depth: isize, prefix: S, ty: &Type) {
let prefix = prefix.as_ref();
let kind = ty.kind();
print_indent(depth, format!(" {}kind = {}", prefix, type_to_str(kind)));
if kind == CXType_Invalid {
return;
}
print_indent(depth, format!(" {}cconv = {}", prefix, ty.call_conv()));
print_indent(
depth,
format!(" {}spelling = \"{}\"", prefix, ty.spelling()),
);
let num_template_args =
unsafe { clang_Type_getNumTemplateArguments(ty.x) };
if num_template_args >= 0 {
print_indent(
depth,
format!(
" {}number-of-template-args = {}",
prefix, num_template_args
),
);
}
if let Some(num) = ty.num_elements() {
print_indent(
depth,
format!(" {}number-of-elements = {}", prefix, num),
);
}
print_indent(
depth,
format!(" {}is-variadic? {}", prefix, ty.is_variadic()),
);
let canonical = ty.canonical_type();
if canonical != *ty {
println!();
print_type(depth, String::from(prefix) + "canonical.", &canonical);
}
if let Some(pointee) = ty.pointee_type() {
if pointee != *ty {
println!();
print_type(depth, String::from(prefix) + "pointee.", &pointee);
}
}
if let Some(elem) = ty.elem_type() {
if elem != *ty {
println!();
print_type(depth, String::from(prefix) + "elements.", &elem);
}
}
if let Some(ret) = ty.ret_type() {
if ret != *ty {
println!();
print_type(depth, String::from(prefix) + "return.", &ret);
}
}
let named = ty.named();
if named != *ty && named.is_valid() {
println!();
print_type(depth, String::from(prefix) + "named.", &named);
}
}
print_indent(depth, "(");
print_cursor(depth, "", c);
println!();
let ty = c.cur_type();
print_type(depth, "type.", &ty);
let declaration = ty.declaration();
if declaration != *c && declaration.kind() != CXCursor_NoDeclFound {
println!();
print_cursor(depth, "type.declaration.", &declaration);
}
// Recurse.
let mut found_children = false;
c.visit(|s| {
if !found_children {
println!();
found_children = true;
}
ast_dump(&s, depth + 1)
});
print_indent(depth, ")");
CXChildVisit_Continue
}
/// Try to extract the clang version to a string
pub(crate) fn extract_clang_version() -> String {
unsafe { cxstring_into_string(clang_getClangVersion()) }
}
/// A wrapper for the result of evaluating an expression.
#[derive(Debug)]
pub(crate) struct EvalResult {
x: CXEvalResult,
ty: Type,
}
impl EvalResult {
/// Evaluate `cursor` and return the result.
pub(crate) fn new(cursor: Cursor) -> Option<Self> {
{
let mut found_cant_eval = false;
cursor.visit(|c| {
if c.kind() == CXCursor_TypeRef &&
c.cur_type().canonical_type().kind() == CXType_Unexposed
{
found_cant_eval = true;
return CXChildVisit_Break;
}
CXChildVisit_Recurse
});
if found_cant_eval {
return None;
}
}
Some(EvalResult {
x: unsafe { clang_Cursor_Evaluate(cursor.x) },
ty: cursor.cur_type().canonical_type(),
})
}
fn kind(&self) -> CXEvalResultKind {
unsafe { clang_EvalResult_getKind(self.x) }
}
/// Try to get back the result as a double.
pub(crate) fn as_double(&self) -> Option<f64> {
match self.kind() {
CXEval_Float => {
Some(unsafe { clang_EvalResult_getAsDouble(self.x) })
}
_ => None,
}
}
/// Try to get back the result as an integer.
pub(crate) fn as_int(&self) -> Option<i64> {
if self.kind() != CXEval_Int {
return None;
}
if unsafe { clang_EvalResult_isUnsignedInt(self.x) } != 0 {
let value = unsafe { clang_EvalResult_getAsUnsigned(self.x) };
if value > i64::max_value() as c_ulonglong {
return None;
}
return Some(value as i64);
}
let value = unsafe { clang_EvalResult_getAsLongLong(self.x) };
if value > i64::max_value() as c_longlong {
return None;
}
if value < i64::min_value() as c_longlong {
return None;
}
#[allow(clippy::unnecessary_cast)]
Some(value as i64)
}
/// Evaluates the expression as a literal string, that may or may not be
/// valid utf-8.
pub(crate) fn as_literal_string(&self) -> Option<Vec<u8>> {
if self.kind() != CXEval_StrLiteral {
return None;
}
let char_ty = self.ty.pointee_type().or_else(|| self.ty.elem_type())?;
match char_ty.kind() {
CXType_Char_S | CXType_SChar | CXType_Char_U | CXType_UChar => {
let ret = unsafe {
CStr::from_ptr(clang_EvalResult_getAsStr(self.x))
};
Some(ret.to_bytes().to_vec())
}
// FIXME: Support generating these.
CXType_Char16 => None,
CXType_Char32 => None,
CXType_WChar => None,
_ => None,
}
}
}
impl Drop for EvalResult {
fn drop(&mut self) {
unsafe { clang_EvalResult_dispose(self.x) };
}
}
/// ABI kinds as defined in
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub(crate) enum ABIKind {
/// All the regular targets like Linux, Mac, WASM, etc. implement the Itanium ABI
GenericItanium,
/// The ABI used when compiling for the MSVC target
Microsoft,
}
/// Target information obtained from libclang.
#[derive(Debug)]
pub(crate) struct TargetInfo {
/// The target triple.
pub(crate) triple: String,
/// The width of the pointer _in bits_.
pub(crate) pointer_width: usize,
/// The ABI of the target
pub(crate) abi: ABIKind,
}
impl TargetInfo {
/// Tries to obtain target information from libclang.
pub(crate) fn new(tu: &TranslationUnit) -> Self {
let triple;
let pointer_width;
unsafe {
let ti = clang_getTranslationUnitTargetInfo(tu.x);
triple = cxstring_into_string(clang_TargetInfo_getTriple(ti));
pointer_width = clang_TargetInfo_getPointerWidth(ti);
clang_TargetInfo_dispose(ti);
}
assert!(pointer_width > 0);
assert_eq!(pointer_width % 8, 0);
let abi = if triple.contains("msvc") {
ABIKind::Microsoft
} else {
ABIKind::GenericItanium
};
TargetInfo {
triple,
pointer_width: pointer_width as usize,
abi,
}
}
}