Auto merge of #58 - emilio:funcs, r=nox

Some function pointers, typedefs, and OSX's stdlib.

r? @nox

The change from indexing cursors to index USRs was because in the `inner_template_self` test, the `next` pointer pointed to a clang-generated class declaration that caused us to not catch the type as already resolved.

Also, that's the recommended way to check against same symbols from different translation units, though now we don't use it yet.

Author: bors-servo

src/clang.rs

@@ -17,14 +17,23 @@ pub struct Cursor {
 
 impl fmt::Debug for Cursor {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "Cursor({} kind: {}, loc: {})",
-               self.spelling(), kind_to_str(self.kind()), self.location())
+        write!(fmt, "Cursor({} kind: {}, loc: {}, usr: {:?})",
+               self.spelling(), kind_to_str(self.kind()), self.location(), self.usr())
     }
 }
 
 pub type CursorVisitor<'s> = for<'a, 'b> FnMut(&'a Cursor, &'b Cursor) -> Enum_CXChildVisitResult + 's;
 
 impl Cursor {
+    pub fn usr(&self) -> Option<String> {
+        let s = String_ { x: unsafe { clang_getCursorUSR(self.x) } }.to_string();
+        if s.is_empty() {
+            None
+        } else {
+            Some(s)
+        }
+    }
+
     pub fn is_declaration(&self) -> bool {
         unsafe { clang_isDeclaration(self.kind()) != 0 }
     }

src/codegen/mod.rs

@@ -311,6 +311,7 @@ impl CodeGenerator for Type {
             TypeKind::Float(..) |
             TypeKind::Array(..) |
             TypeKind::Pointer(..) |
+            TypeKind::BlockPointer |
             TypeKind::Reference(..) |
             TypeKind::TemplateRef(..) |
             TypeKind::Function(..) |
@@ -1306,6 +1307,11 @@ impl ToRustTy for Type {
                     IntKind::ULongLong => raw!(c_ulonglong),
                     IntKind::U16 => aster::ty::TyBuilder::new().u16(),
                     IntKind::U32 => aster::ty::TyBuilder::new().u32(),
+                    // FIXME: This doesn't generate the proper alignment, but we
+                    // can't do better right now. We should be able to use
+                    // i128/u128 when they're available.
+                    IntKind::U128 |
+                    IntKind::I128 => ArrayTyBuilder::new().with_len(2).build(aster::ty::TyBuilder::new().u64()),
                 }
             }
             TypeKind::Float(fk) => {
@@ -1377,10 +1383,23 @@ impl ToRustTy for Type {
 
                 utils::build_templated_path(item, ctx, false)
             }
+            TypeKind::BlockPointer => {
+                let void = raw!(c_void);
+                void.to_ptr(/* is_const = */ false, ctx.span())
+            }
             TypeKind::Pointer(inner) |
             TypeKind::Reference(inner) => {
                 let inner = ctx.resolve_item(inner);
-                inner.to_rust_ty(ctx).to_ptr(inner.expect_type().is_const(), ctx.span())
+                let inner_ty = inner.expect_type();
+                let ty = inner.to_rust_ty(ctx);
+
+                // Avoid the first function pointer level, since it's already
+                // represented in Rust.
+                if inner_ty.canonical_type(ctx).is_function() {
+                    ty
+                } else {
+                    ty.to_ptr(inner.expect_type().is_const(), ctx.span())
+                }
             }
             TypeKind::Named(..) => {
                 let name = item.canonical_name(ctx);

src/ir/context.rs

@@ -14,6 +14,18 @@ use syntax::ext::base::ExtCtxt;
 use parse::ClangItemParser;
 use BindgenOptions;
 
+/// A key used to index a resolved type, so we only process it once.
+///
+/// This is almost always a USR string (an unique identifier generated by
+/// clang), but it can also be the canonical declaration if the type is unnamed,
+/// in which case clang may generate the same USR for multiple nested unnamed
+/// types.
+#[derive(Eq, PartialEq, Hash, Debug)]
+enum TypeKey {
+    USR(String),
+    Declaration(Cursor),
+}
+
 // This is just convenience to avoid creating a manual debug impl for the
 // context.
 struct GenContext<'ctx>(ExtCtxt<'ctx>);
@@ -33,11 +45,9 @@ pub struct BindgenContext<'ctx> {
     /// output.
     items: BTreeMap<ItemId, Item>,
 
-    /// Clang cursor to type map. This is needed to be able to associate types
-    /// with item ids during parsing.
-    ///
-    /// The cursor used for storage is the definition cursor.
-    types: HashMap<Cursor, ItemId>,
+    /// Clang USR to type map. This is needed to be able to associate types with
+    /// item ids during parsing.
+    types: HashMap<TypeKey, ItemId>,
 
     /// A cursor to module map. Similar reason than above.
     modules: HashMap<Cursor, ItemId>,
@@ -131,29 +141,46 @@ impl<'ctx> BindgenContext<'ctx> {
 
         let id = item.id();
         let is_type = item.kind().is_type();
+        let is_unnamed = is_type && item.expect_type().name().is_none();
         let old_item = self.items.insert(id, item);
         assert!(old_item.is_none(), "Inserted type twice?");
 
+        // Unnamed items can have an USR, but they can't be referenced from
+        // other sites explicitly and the USR can match if the unnamed items are
+        // nested, so don't bother tracking them.
         if is_type && declaration.is_some() {
-            let declaration = declaration.unwrap();
-            debug_assert_eq!(declaration, declaration.canonical());
-            if declaration.is_valid() {
-                let old = self.types.insert(declaration, id);
-                debug_assert_eq!(old, None);
-            } else if location.is_some() &&
-                      (location.unwrap().kind() == CXCursor_ClassTemplate ||
-                       location.unwrap().kind() == CXCursor_ClassTemplatePartialSpecialization) {
-                let old = self.types.insert(location.unwrap().canonical(), id);
-                debug_assert_eq!(old, None);
-            } else {
+            let mut declaration = declaration.unwrap();
+            if !declaration.is_valid() {
+                if let Some(location) = location {
+                    if location.kind() == CXCursor_ClassTemplate ||
+                       location.kind() == CXCursor_ClassTemplatePartialSpecialization {
+                        declaration = location;
+                    }
+                }
+            }
+            declaration = declaration.canonical();
+            if !declaration.is_valid() {
                 // This could happen, for example, with types like `int*` or
                 // similar.
                 //
                 // Fortunately, we don't care about those types being
                 // duplicated, so we can just ignore them.
                 debug!("Invalid declaration {:?} found for type {:?}",
                        declaration, self.items.get(&id).unwrap().kind().expect_type());
+                return;
             }
+
+            let key = if is_unnamed {
+                TypeKey::Declaration(declaration)
+            } else if let Some(usr) = declaration.usr() {
+                TypeKey::USR(usr)
+            } else {
+                error!("Valid declaration with no USR: {:?}, {:?}", declaration, location);
+                return;
+            };
+
+            let old = self.types.insert(key, id);
+            debug_assert_eq!(old, None);
         }
     }
 
@@ -206,7 +233,7 @@ impl<'ctx> BindgenContext<'ctx> {
         self.collected_typerefs
     }
 
-    fn collect_typerefs(&mut self) -> Vec<(ItemId, clang::Type, Option<clang::Cursor>)> {
+    fn collect_typerefs(&mut self) -> Vec<(ItemId, clang::Type, Option<clang::Cursor>, Option<ItemId>)> {
         debug_assert!(!self.collected_typerefs);
         self.collected_typerefs = true;
         let mut typerefs = vec![];
@@ -218,8 +245,8 @@ impl<'ctx> BindgenContext<'ctx> {
             };
 
             match *ty.kind() {
-                TypeKind::UnresolvedTypeRef(ref ty, loc) => {
-                    typerefs.push((*id, ty.clone(), loc));
+                TypeKind::UnresolvedTypeRef(ref ty, loc, parent_id) => {
+                    typerefs.push((*id, ty.clone(), loc, parent_id));
                 }
                 _ => {},
             };
@@ -230,9 +257,9 @@ impl<'ctx> BindgenContext<'ctx> {
     fn resolve_typerefs(&mut self) {
         let typerefs = self.collect_typerefs();
 
-        for (id, ty, loc) in typerefs {
+        for (id, ty, loc, parent_id) in typerefs {
             let _resolved = {
-                let resolved = Item::from_ty(&ty, loc, None, self)
+                let resolved = Item::from_ty(&ty, loc, parent_id, self)
                                      .expect("What happened?");
                 let mut item = self.items.get_mut(&id).unwrap();
 
@@ -494,8 +521,15 @@ impl<'ctx> BindgenContext<'ctx> {
         }
         let canonical_declaration = declaration.canonical();
         if canonical_declaration.is_valid() {
-            // First lookup to see if we already have it resolved.
-            let id = self.types.get(&canonical_declaration).map(|id| *id);
+            let id =
+                self.types.get(&TypeKey::Declaration(canonical_declaration))
+                    .map(|id| *id)
+                    .or_else(|| {
+                        canonical_declaration.usr().and_then(|usr| {
+                            self.types.get(&TypeKey::USR(usr))
+                        })
+                        .map(|id| *id)
+                    });
             if let Some(id) = id {
                 debug!("Already resolved ty {:?}, {:?}, {:?} {:?}",
                        id, declaration, ty, location);
@@ -572,6 +606,8 @@ impl<'ctx> BindgenContext<'ctx> {
             CXType_ULong => TypeKind::Int(IntKind::ULong),
             CXType_LongLong => TypeKind::Int(IntKind::LongLong),
             CXType_ULongLong => TypeKind::Int(IntKind::ULongLong),
+            CXType_Int128 => TypeKind::Int(IntKind::I128),
+            CXType_UInt128 => TypeKind::Int(IntKind::U128),
             CXType_Float => TypeKind::Float(FloatKind::Float),
             CXType_Double => TypeKind::Float(FloatKind::Double),
             CXType_LongDouble => TypeKind::Float(FloatKind::LongDouble),

src/ir/int.rs

@@ -13,6 +13,8 @@ pub enum IntKind {
     ULongLong,
     U16, // For Char16 and Wchar
     U32, // For Char32
+    I128,
+    U128,
     // Though now we're at it we could add equivalents for the rust types...
 }
 
@@ -21,10 +23,10 @@ impl IntKind {
         use self::IntKind::*;
         match *self {
             Bool | UChar | UShort |
-            UInt | ULong | ULongLong | U16 | U32 => false,
+            UInt | ULong | ULongLong | U16 | U32 | U128 => false,
 
             Char | Short | Int |
-            Long | LongLong => true,
+            Long | LongLong | I128 => true,
         }
     }
 }

src/ir/item.rs

@@ -191,10 +191,19 @@ impl Item {
             TypeKind::Array(inner, _) |
             TypeKind::Pointer(inner) |
             TypeKind::Reference(inner) |
-            TypeKind::Alias(_, inner) |
             TypeKind::ResolvedTypeRef(inner) => {
                 ctx.resolve_item(inner).applicable_template_args(ctx)
             }
+            TypeKind::Alias(_, inner) => {
+                let parent_args = ctx.resolve_item(self.parent_id())
+                   .applicable_template_args(ctx);
+                let inner = ctx.resolve_type(inner);
+                // Avoid unused type parameters, sigh.
+                parent_args.iter().cloned().filter(|arg| {
+                    let arg = ctx.resolve_type(*arg);
+                    arg.is_named() && inner.signature_contains_named_type(ctx, arg)
+                }).collect()
+            }
             // XXX Is this completely correct? Partial template specialization
             // is hard anyways, sigh...
             TypeKind::TemplateRef(_, ref args) => {
@@ -436,11 +445,19 @@ impl ClangItemParser for Item {
                       location: Option<clang::Cursor>,
                       parent_id: Option<ItemId>,
                       context: &mut BindgenContext) -> ItemId {
-        debug!("from_ty_or_ref: {:?}, {:?}, {:?}", ty, location, parent_id);
+        Self::from_ty_or_ref_with_id(ItemId::next(), ty, location, parent_id, context)
+    }
+
+    fn from_ty_or_ref_with_id(potential_id: ItemId,
+                              ty: clang::Type,
+                              location: Option<clang::Cursor>,
+                              parent_id: Option<ItemId>,
+                              context: &mut BindgenContext) -> ItemId {
+        debug!("from_ty_or_ref_with_id: {:?} {:?}, {:?}, {:?}", potential_id, ty, location, parent_id);
 
         if context.collected_typerefs() {
             debug!("refs already collected, resolving directly");
-            return Self::from_ty(&ty, location, parent_id, context)
+            return Self::from_ty_with_id(potential_id, &ty, location, parent_id, context)
                         .expect("Unable to resolve type");
         }
 
@@ -452,15 +469,14 @@ impl ClangItemParser for Item {
         debug!("New unresolved type reference: {:?}, {:?}", ty, location);
 
         let is_const = ty.is_const();
-        let kind = TypeKind::UnresolvedTypeRef(ty, location);
-        let id = ItemId::next();
+        let kind = TypeKind::UnresolvedTypeRef(ty, location, parent_id);
         let current_module = context.current_module();
-        context.add_item(Item::new(id, None, None,
+        context.add_item(Item::new(potential_id, None, None,
                                    parent_id.unwrap_or(current_module),
                                    ItemKind::Type(Type::new(None, None, kind, is_const))),
                          Some(clang::Cursor::null()),
                          None);
-        id
+        potential_id
     }