Merge remote-tracking branch 'servo/master' into aligned-attribute

# Conflicts:
#	src/ir/mod.rs

Author: flier

.travis.yml

@@ -9,6 +9,7 @@ addons:
 
 os:
   - linux
+  - osx
 
 rust:
   - stable

ci/before_install.sh

@@ -1,6 +1,11 @@
 set -e
 pushd ~
 
+# Workaround for Travis CI macOS bug (https://github.com/travis-ci/travis-ci/issues/6307)
+if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
+    rvm get head || true
+fi
+
 function llvm_version_triple() {
     if [ "$1" == "3.8" ]; then
         echo "3.8.0"
@@ -18,9 +23,17 @@ function llvm_download() {
     tar -xf ${LLVM}.tar.xz -C llvm --strip-components=1
 
     export LLVM_CONFIG_PATH=`pwd`/llvm/bin/llvm-config
+    if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
+        cp llvm/lib/libclang.dylib /usr/local/lib/libclang.dylib
+    fi
 }
 
-llvm_download linux-gnu-ubuntu-14.04
+
+if [ "${TRAVIS_OS_NAME}" == "linux" ]; then
+    llvm_download linux-gnu-ubuntu-14.04
+else
+    llvm_download apple-darwin
+fi
 
 popd
 set +e

src/clang.rs

@@ -201,14 +201,14 @@ impl Cursor {
     }
 
     /// Is the referent a template specialization?
-    pub fn is_template(&self) -> bool {
+    pub 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 fn is_fully_specialized_template(&self) -> bool {
-        self.is_template() && self.num_template_args().unwrap_or(0) > 0
+        self.is_template_specialization() && self.num_template_args().unwrap_or(0) > 0
     }
 
     /// Is the referent a template specialization that still has remaining free
@@ -217,9 +217,17 @@ impl Cursor {
         if self.is_toplevel() {
             return false;
         }
+
         let parent = self.semantic_parent();
-        (parent.is_template() && !parent.is_fully_specialized_template()) ||
-        parent.is_in_non_fully_specialized_template()
+        if parent.is_fully_specialized_template() {
+            return false;
+        }
+
+        if !parent.is_template_like() {
+            return parent.is_in_non_fully_specialized_template();
+        }
+
+        return true;
     }
 
     /// Is this cursor pointing a valid referent?
@@ -688,7 +696,8 @@ impl Type {
             CXType_Pointer |
             CXType_RValueReference |
             CXType_LValueReference |
-            CXType_MemberPointer => {
+            CXType_MemberPointer |
+            CXType_ObjCObjectPointer => {
                 let ret = Type {
                     x: unsafe { clang_getPointeeType(self.x) },
                 };

src/codegen/mod.rs

@@ -13,6 +13,7 @@ use ir::item::{Item, ItemAncestors, ItemCanonicalName, ItemCanonicalPath};
 use ir::item_kind::ItemKind;
 use ir::layout::Layout;
 use ir::module::Module;
+use ir::objc::ObjCInterface;
 use ir::ty::{Type, TypeKind};
 use ir::type_collector::ItemSet;
 use ir::var::Var;
@@ -87,6 +88,9 @@ struct CodegenResult<'a> {
     /// Whether an incomplete array has been generated at least once.
     saw_incomplete_array: bool,
 
+    /// Whether Objective C types have been seen at least once.
+    saw_objc: bool,
+
     items_seen: HashSet<ItemId>,
     /// The set of generated function/var names, needed because in C/C++ is
     /// legal to do something like:
@@ -119,6 +123,7 @@ impl<'a> CodegenResult<'a> {
             items: vec![],
             saw_union: false,
             saw_incomplete_array: false,
+            saw_objc: false,
             codegen_id: codegen_id,
             items_seen: Default::default(),
             functions_seen: Default::default(),
@@ -140,6 +145,10 @@ impl<'a> CodegenResult<'a> {
         self.saw_incomplete_array = true;
     }
 
+    fn saw_objc(&mut self) {
+        self.saw_objc = true;
+    }
+
     fn seen(&self, item: ItemId) -> bool {
         self.items_seen.contains(&item)
     }
@@ -184,6 +193,7 @@ impl<'a> CodegenResult<'a> {
 
         self.saw_union |= new.saw_union;
         self.saw_incomplete_array |= new.saw_incomplete_array;
+        self.saw_objc |= new.saw_objc;
 
         new.items
     }
@@ -359,6 +369,9 @@ impl CodeGenerator for Module {
                 if ctx.need_bindegen_complex_type() {
                     utils::prepend_complex_type(ctx, &mut *result);
                 }
+                if result.saw_objc {
+                    utils::prepend_objc_header(ctx, &mut *result);
+                }
             }
         };
 
@@ -514,7 +527,7 @@ impl CodeGenerator for Type {
             TypeKind::TemplateRef(..) |
             TypeKind::Function(..) |
             TypeKind::ResolvedTypeRef(..) |
-            TypeKind::Named(..) => {
+            TypeKind::Named => {
                 // These items don't need code generation, they only need to be
                 // converted to rust types in fields, arguments, and such.
                 return;
@@ -524,8 +537,8 @@ impl CodeGenerator for Type {
             }
             // NB: The code below will pick the correct
             // applicable_template_args.
-            TypeKind::TemplateAlias(ref spelling, inner, _) |
-            TypeKind::Alias(ref spelling, inner) => {
+            TypeKind::TemplateAlias(inner, _) |
+            TypeKind::Alias(inner) => {
                 let inner_item = ctx.resolve_item(inner);
                 let name = item.canonical_name(ctx);
 
@@ -541,6 +554,7 @@ impl CodeGenerator for Type {
 
                 // If this is a known named type, disallow generating anything
                 // for it too.
+                let spelling = self.name().expect("Unnamed alias?");
                 if utils::type_from_named(ctx, spelling, inner).is_some() {
                     return;
                 }
@@ -556,6 +570,26 @@ impl CodeGenerator for Type {
                     inner_item.to_rust_ty(ctx)
                 };
 
+                {
+                    // FIXME(emilio): This is a workaround to avoid generating
+                    // incorrect type aliases because of types that we haven't
+                    // been able to resolve (because, eg, they depend on a
+                    // template parameter).
+                    //
+                    // It's kind of a shame not generating them even when they
+                    // could be referenced, but we already do the same for items
+                    // with invalid template parameters, and at least this way
+                    // they can be replaced, instead of generating plain invalid
+                    // code.
+                    let inner_canon_type =
+                        inner_item.expect_type().canonical_type(ctx);
+                    if inner_canon_type.is_invalid_named_type() {
+                        warn!("Item contained invalid named type, skipping: \
+                              {:?}, {:?}", item, inner_item);
+                        return;
+                    }
+                }
+
                 let rust_name = ctx.rust_ident(&name);
                 let mut typedef = aster::AstBuilder::new().item().pub_();
 
@@ -593,9 +627,8 @@ impl CodeGenerator for Type {
                     for template_arg in applicable_template_args.iter() {
                         let template_arg = ctx.resolve_type(*template_arg);
                         if template_arg.is_named() {
-                            let name = template_arg.name().unwrap();
-                            if name.contains("typename ") {
-                                warn!("Item contained `typename`'d template \
+                            if template_arg.is_invalid_named_type() {
+                                warn!("Item contained invalid template \
                                        parameter: {:?}", item);
                                 return;
                             }
@@ -610,6 +643,9 @@ impl CodeGenerator for Type {
             TypeKind::Enum(ref ei) => {
                 ei.codegen(ctx, result, whitelisted_items, item)
             }
+            TypeKind::ObjCInterface(ref interface) => {
+                interface.codegen(ctx, result, whitelisted_items, item)
+            }
             ref u @ TypeKind::UnresolvedTypeRef(..) => {
                 unreachable!("Should have been resolved after parsing {:?}!", u)
             }
@@ -2040,14 +2076,15 @@ impl ToRustTy for Type {
                 P(inner_ty)
             }
             TypeKind::ResolvedTypeRef(inner) => inner.to_rust_ty(ctx),
-            TypeKind::TemplateAlias(ref spelling, inner, _) |
-            TypeKind::Alias(ref spelling, inner) => {
+            TypeKind::TemplateAlias(inner, _) |
+            TypeKind::Alias(inner) => {
                 let applicable_named_args =
                     item.applicable_template_args(ctx)
                         .into_iter()
                         .filter(|arg| ctx.resolve_type(*arg).is_named())
                         .collect::<Vec<_>>();
 
+                let spelling = self.name().expect("Unnamed alias?");
                 if item.is_opaque(ctx) && !applicable_named_args.is_empty() {
                     // Pray if there's no available layout.
                     let layout = self.layout(ctx).unwrap_or_else(Layout::zero);
@@ -2101,11 +2138,14 @@ impl ToRustTy for Type {
                     ty.to_ptr(is_const, ctx.span())
                 }
             }
-            TypeKind::Named(..) => {
+            TypeKind::Named => {
                 let name = item.canonical_name(ctx);
                 let ident = ctx.rust_ident(&name);
                 quote_ty!(ctx.ext_cx(), $ident)
             }
+            TypeKind::ObjCInterface(..) => {
+                quote_ty!(ctx.ext_cx(), id)
+            },
             ref u @ TypeKind::UnresolvedTypeRef(..) => {
                 unreachable!("Should have been resolved after parsing {:?}!", u)
             }
@@ -2139,10 +2179,22 @@ impl ToRustTy for FunctionSig {
             //     the array type derivation.
             //
             // [1]: http://c0x.coding-guidelines.com/6.7.5.3.html
-            let arg_ty = if let TypeKind::Array(t, _) = *arg_ty.canonical_type(ctx).kind() {
-                t.to_rust_ty(ctx).to_ptr(arg_ty.is_const(), ctx.span())
-            } else {
-                arg_item.to_rust_ty(ctx)
+            let arg_ty = match *arg_ty.canonical_type(ctx).kind() {
+                TypeKind::Array(t, _) => {
+                    t.to_rust_ty(ctx).to_ptr(arg_ty.is_const(), ctx.span())
+                },
+                TypeKind::Pointer(inner) => {
+                    let inner = ctx.resolve_item(inner);
+                    let inner_ty = inner.expect_type();
+                    if let TypeKind::ObjCInterface(_) = *inner_ty.canonical_type(ctx).kind() {
+                        quote_ty!(ctx.ext_cx(), id)
+                    } else {
+                        arg_item.to_rust_ty(ctx)
+                    }
+                },
+                _ => {
+                    arg_item.to_rust_ty(ctx)
+                }
             };
 
             let arg_name = match *name {
@@ -2261,6 +2313,85 @@ impl CodeGenerator for Function {
     }
 }
 
+impl CodeGenerator for ObjCInterface {
+    type Extra = Item;
+    fn codegen<'a>(&self,
+                   ctx: &BindgenContext,
+                   result: &mut CodegenResult<'a>,
+                   _whitelisted_items: &ItemSet,
+                   _: &Item) {
+        let mut impl_items = vec![];
+        let mut trait_items = vec![];
+
+        for method in self.methods() {
+            let method_name = ctx.rust_ident(method.name());
+
+            let body = quote_stmt!(ctx.ext_cx(), msg_send![self, $method_name])
+                .unwrap();
+            let block = ast::Block {
+                stmts: vec![body],
+                id: ast::DUMMY_NODE_ID,
+                rules: ast::BlockCheckMode::Default,
+                span: ctx.span(),
+            };
+
+            let sig = aster::AstBuilder::new()
+                .method_sig()
+                .unsafe_()
+                .fn_decl()
+                .self_()
+                .build(ast::SelfKind::Value(ast::Mutability::Immutable))
+                .build(ast::FunctionRetTy::Default(ctx.span()));
+            let attrs = vec![];
+
+            let impl_item = ast::ImplItem {
+                id: ast::DUMMY_NODE_ID,
+                ident: ctx.rust_ident(method.rust_name()),
+                vis: ast::Visibility::Inherited, // Public,
+                attrs: attrs.clone(),
+                node: ast::ImplItemKind::Method(sig.clone(), P(block)),
+                defaultness: ast::Defaultness::Final,
+                span: ctx.span(),
+            };
+
+            let trait_item = ast::TraitItem {
+                id: ast::DUMMY_NODE_ID,
+                ident: ctx.rust_ident(method.rust_name()),
+                attrs: attrs,
+                node: ast::TraitItemKind::Method(sig, None),
+                span: ctx.span(),
+            };
+
+            impl_items.push(impl_item);
+            trait_items.push(trait_item)
+        }
+
+
+        let trait_block = aster::AstBuilder::new()
+            .item()
+            .pub_()
+            .trait_(self.name())
+            .with_items(trait_items)
+            .build();
+
+        let ty_for_impl = quote_ty!(ctx.ext_cx(), id);
+        let impl_block = aster::AstBuilder::new()
+            .item()
+            .impl_()
+            .trait_()
+            .id(self.name())
+            .build()
+            .with_items(impl_items)
+            .build_ty(ty_for_impl);
+
+        result.push(trait_block);
+        result.push(impl_block);
+        result.saw_objc();
+    }
+}
+
+
+
 pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
     context.gen(|context| {
         let counter = Cell::new(0);
@@ -2294,6 +2425,32 @@ mod utils {
     use syntax::ast;
     use syntax::ptr::P;
 
+
+    pub fn prepend_objc_header(ctx: &BindgenContext,
+                               result: &mut Vec<P<ast::Item>>) {
+        let use_objc = if ctx.options().objc_extern_crate {
+            quote_item!(ctx.ext_cx(),
+                use objc;
+            ).unwrap()
+        } else {
+            quote_item!(ctx.ext_cx(),
+                #[macro_use]
+                extern crate objc;
+            ).unwrap()
+        };
+
+
+        let id_type = quote_item!(ctx.ext_cx(),
+            #[allow(non_camel_case_types)]
+            pub type id = *mut objc::runtime::Object;
+        )
+            .unwrap();
+
+        let items = vec![use_objc, id_type];
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+
     pub fn prepend_union_types(ctx: &BindgenContext,
                                result: &mut Vec<P<ast::Item>>) {
         let prefix = ctx.trait_prefix();