code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/bindgen-0.69.5/ir/objc.rs

@@ -1,354 +0,0 @@
-//! Objective C types
-
-use super::context::{BindgenContext, ItemId};
-use super::function::FunctionSig;
-use super::item::Item;
-use super::traversal::{Trace, Tracer};
-use super::ty::TypeKind;
-use crate::clang;
-use clang_sys::CXChildVisit_Continue;
-use clang_sys::CXCursor_ObjCCategoryDecl;
-use clang_sys::CXCursor_ObjCClassMethodDecl;
-use clang_sys::CXCursor_ObjCClassRef;
-use clang_sys::CXCursor_ObjCInstanceMethodDecl;
-use clang_sys::CXCursor_ObjCProtocolDecl;
-use clang_sys::CXCursor_ObjCProtocolRef;
-use clang_sys::CXCursor_ObjCSuperClassRef;
-use clang_sys::CXCursor_TemplateTypeParameter;
-use proc_macro2::{Ident, Span, TokenStream};
-
-/// Objective C interface as used in TypeKind
-///
-/// Also protocols and categories are parsed as this type
-#[derive(Debug)]
-pub(crate) struct ObjCInterface {
-    /// The name
-    /// like, NSObject
-    name: String,
-
-    category: Option<String>,
-
-    is_protocol: bool,
-
-    /// The list of template names almost always, ObjectType or KeyType
-    pub(crate) template_names: Vec<String>,
-
-    /// The list of protocols that this interface conforms to.
-    pub(crate) conforms_to: Vec<ItemId>,
-
-    /// The direct parent for this interface.
-    pub(crate) parent_class: Option<ItemId>,
-
-    /// List of the methods defined in this interfae
-    methods: Vec<ObjCMethod>,
-
-    class_methods: Vec<ObjCMethod>,
-}
-
-/// The objective c methods
-#[derive(Debug)]
-pub(crate) struct ObjCMethod {
-    /// The original method selector name
-    /// like, dataWithBytes:length:
-    name: String,
-
-    /// Method name as converted to rust
-    /// like, dataWithBytes_length_
-    rust_name: String,
-
-    signature: FunctionSig,
-
-    /// Is class method?
-    is_class_method: bool,
-}
-
-impl ObjCInterface {
-    fn new(name: &str) -> ObjCInterface {
-        ObjCInterface {
-            name: name.to_owned(),
-            category: None,
-            is_protocol: false,
-            template_names: Vec::new(),
-            parent_class: None,
-            conforms_to: Vec::new(),
-            methods: Vec::new(),
-            class_methods: Vec::new(),
-        }
-    }
-
-    /// The name
-    /// like, NSObject
-    pub(crate) fn name(&self) -> &str {
-        self.name.as_ref()
-    }
-
-    /// Formats the name for rust
-    /// Can be like NSObject, but with categories might be like NSObject_NSCoderMethods
-    /// and protocols are like PNSObject
-    pub(crate) fn rust_name(&self) -> String {
-        if let Some(ref cat) = self.category {
-            format!("{}_{}", self.name(), cat)
-        } else if self.is_protocol {
-            format!("P{}", self.name())
-        } else {
-            format!("I{}", self.name().to_owned())
-        }
-    }
-
-    /// Is this a template interface?
-    pub(crate) fn is_template(&self) -> bool {
-        !self.template_names.is_empty()
-    }
-
-    /// List of the methods defined in this interface
-    pub(crate) fn methods(&self) -> &Vec<ObjCMethod> {
-        &self.methods
-    }
-
-    /// Is this a protocol?
-    pub(crate) fn is_protocol(&self) -> bool {
-        self.is_protocol
-    }
-
-    /// Is this a category?
-    pub(crate) fn is_category(&self) -> bool {
-        self.category.is_some()
-    }
-
-    /// List of the class methods defined in this interface
-    pub(crate) fn class_methods(&self) -> &Vec<ObjCMethod> {
-        &self.class_methods
-    }
-
-    /// Parses the Objective C interface from the cursor
-    pub(crate) fn from_ty(
-        cursor: &clang::Cursor,
-        ctx: &mut BindgenContext,
-    ) -> Option<Self> {
-        let name = cursor.spelling();
-        let mut interface = Self::new(&name);
-
-        if cursor.kind() == CXCursor_ObjCProtocolDecl {
-            interface.is_protocol = true;
-        }
-
-        cursor.visit(|c| {
-            match c.kind() {
-                CXCursor_ObjCClassRef => {
-                    if cursor.kind() == CXCursor_ObjCCategoryDecl {
-                        // We are actually a category extension, and we found the reference
-                        // to the original interface, so name this interface approriately
-                        interface.name = c.spelling();
-                        interface.category = Some(cursor.spelling());
-                    }
-                }
-                CXCursor_ObjCProtocolRef => {
-                    // Gather protocols this interface conforms to
-                    let needle = format!("P{}", c.spelling());
-                    let items_map = ctx.items();
-                    debug!(
-                        "Interface {} conforms to {}, find the item",
-                        interface.name, needle
-                    );
-
-                    for (id, item) in items_map {
-                        if let Some(ty) = item.as_type() {
-                            if let TypeKind::ObjCInterface(ref protocol) =
-                                *ty.kind()
-                            {
-                                if protocol.is_protocol {
-                                    debug!(
-                                        "Checking protocol {}, ty.name {:?}",
-                                        protocol.name,
-                                        ty.name()
-                                    );
-                                    if Some(needle.as_ref()) == ty.name() {
-                                        debug!(
-                                            "Found conforming protocol {:?}",
-                                            item
-                                        );
-                                        interface.conforms_to.push(id);
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                CXCursor_ObjCInstanceMethodDecl |
-                CXCursor_ObjCClassMethodDecl => {
-                    let name = c.spelling();
-                    let signature =
-                        FunctionSig::from_ty(&c.cur_type(), &c, ctx)
-                            .expect("Invalid function sig");
-                    let is_class_method =
-                        c.kind() == CXCursor_ObjCClassMethodDecl;
-                    let method =
-                        ObjCMethod::new(&name, signature, is_class_method);
-                    interface.add_method(method);
-                }
-                CXCursor_TemplateTypeParameter => {
-                    let name = c.spelling();
-                    interface.template_names.push(name);
-                }
-                CXCursor_ObjCSuperClassRef => {
-                    let item = Item::from_ty_or_ref(c.cur_type(), c, None, ctx);
-                    interface.parent_class = Some(item.into());
-                }
-                _ => {}
-            }
-            CXChildVisit_Continue
-        });
-        Some(interface)
-    }
-
-    fn add_method(&mut self, method: ObjCMethod) {
-        if method.is_class_method {
-            self.class_methods.push(method);
-        } else {
-            self.methods.push(method);
-        }
-    }
-}
-
-impl ObjCMethod {
-    fn new(
-        name: &str,
-        signature: FunctionSig,
-        is_class_method: bool,
-    ) -> ObjCMethod {
-        let split_name: Vec<&str> = name.split(':').collect();
-
-        let rust_name = split_name.join("_");
-
-        ObjCMethod {
-            name: name.to_owned(),
-            rust_name,
-            signature,
-            is_class_method,
-        }
-    }
-
-    /// Method name as converted to rust
-    /// like, dataWithBytes_length_
-    pub(crate) fn rust_name(&self) -> &str {
-        self.rust_name.as_ref()
-    }
-
-    /// Returns the methods signature as FunctionSig
-    pub(crate) fn signature(&self) -> &FunctionSig {
-        &self.signature
-    }
-
-    /// Is this a class method?
-    pub(crate) fn is_class_method(&self) -> bool {
-        self.is_class_method
-    }
-
-    /// Formats the method call
-    pub(crate) fn format_method_call(
-        &self,
-        args: &[TokenStream],
-    ) -> TokenStream {
-        let split_name: Vec<Option<Ident>> = self
-            .name
-            .split(':')
-            .enumerate()
-            .map(|(idx, name)| {
-                if name.is_empty() {
-                    None
-                } else if idx == 0 {
-                    // Try to parse the method name as an identifier. Having a keyword is ok
-                    // unless it is `crate`, `self`, `super` or `Self`, so we try to add the `_`
-                    // suffix to it and parse it.
-                    if ["crate", "self", "super", "Self"].contains(&name) {
-                        Some(Ident::new(
-                            &format!("{}_", name),
-                            Span::call_site(),
-                        ))
-                    } else {
-                        Some(Ident::new(name, Span::call_site()))
-                    }
-                } else {
-                    // Try to parse the current joining name as an identifier. This might fail if the name
-                    // is a keyword, so we try to  "r#" to it and parse again, this could also fail
-                    // if the name is `crate`, `self`, `super` or `Self`, so we try to add the `_`
-                    // suffix to it and parse again. If this also fails, we panic with the first
-                    // error.
-                    Some(
-                        syn::parse_str::<Ident>(name)
-                            .or_else(|err| {
-                                syn::parse_str::<Ident>(&format!("r#{}", name))
-                                    .map_err(|_| err)
-                            })
-                            .or_else(|err| {
-                                syn::parse_str::<Ident>(&format!("{}_", name))
-                                    .map_err(|_| err)
-                            })
-                            .expect("Invalid identifier"),
-                    )
-                }
-            })
-            .collect();
-
-        // No arguments
-        if args.is_empty() && split_name.len() == 1 {
-            let name = &split_name[0];
-            return quote! {
-                #name
-            };
-        }
-
-        // Check right amount of arguments
-        assert!(
-            args.len() == split_name.len() - 1,
-            "Incorrect method name or arguments for objc method, {:?} vs {:?}",
-            args,
-            split_name
-        );
-
-        // Get arguments without type signatures to pass to `msg_send!`
-        let mut args_without_types = vec![];
-        for arg in args.iter() {
-            let arg = arg.to_string();
-            let name_and_sig: Vec<&str> = arg.split(' ').collect();
-            let name = name_and_sig[0];
-            args_without_types.push(Ident::new(name, Span::call_site()))
-        }
-
-        let args = split_name.into_iter().zip(args_without_types).map(
-            |(arg, arg_val)| {
-                if let Some(arg) = arg {
-                    quote! { #arg: #arg_val }
-                } else {
-                    quote! { #arg_val: #arg_val }
-                }
-            },
-        );
-
-        quote! {
-            #( #args )*
-        }
-    }
-}
-
-impl Trace for ObjCInterface {
-    type Extra = ();
-
-    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        for method in &self.methods {
-            method.signature.trace(context, tracer, &());
-        }
-
-        for class_method in &self.class_methods {
-            class_method.signature.trace(context, tracer, &());
-        }
-
-        for protocol in &self.conforms_to {
-            tracer.visit(*protocol);
-        }
-    }
-}

data/ext/cargo-vendor/bindgen-0.69.5/ir/template.rs

@@ -1,342 +0,0 @@
-//! Template declaration and instantiation related things.
-//!
-//! The nomenclature surrounding templates is often confusing, so here are a few
-//! brief definitions:
-//!
-//! * "Template definition": a class/struct/alias/function definition that takes
-//! generic template parameters. For example:
-//!
-//! ```c++
-//! template<typename T>
-//! class List<T> {
-//!     // ...
-//! };
-//! ```
-//!
-//! * "Template instantiation": an instantiation is a use of a template with
-//! concrete template arguments. For example, `List<int>`.
-//!
-//! * "Template specialization": an alternative template definition providing a
-//! custom definition for instantiations with the matching template
-//! arguments. This C++ feature is unsupported by bindgen. For example:
-//!
-//! ```c++
-//! template<>
-//! class List<int> {
-//!     // Special layout for int lists...
-//! };
-//! ```
-
-use super::context::{BindgenContext, ItemId, TypeId};
-use super::item::{IsOpaque, Item, ItemAncestors};
-use super::traversal::{EdgeKind, Trace, Tracer};
-use crate::clang;
-
-/// Template declaration (and such declaration's template parameters) related
-/// methods.
-///
-/// This trait's methods distinguish between `None` and `Some([])` for
-/// declarations that are not templates and template declarations with zero
-/// parameters, in general.
-///
-/// Consider this example:
-///
-/// ```c++
-/// template <typename T, typename U>
-/// class Foo {
-///     T use_of_t;
-///     U use_of_u;
-///
-///     template <typename V>
-///     using Bar = V*;
-///
-///     class Inner {
-///         T        x;
-///         U        y;
-///         Bar<int> z;
-///     };
-///
-///     template <typename W>
-///     class Lol {
-///         // No use of W, but here's a use of T.
-///         T t;
-///     };
-///
-///     template <typename X>
-///     class Wtf {
-///         // X is not used because W is not used.
-///         Lol<X> lololol;
-///     };
-/// };
-///
-/// class Qux {
-///     int y;
-/// };
-/// ```
-///
-/// The following table depicts the results of each trait method when invoked on
-/// each of the declarations above:
-///
-/// +------+----------------------+--------------------------+-------------------------+----
-/// |Decl. | self_template_params | num_self_template_params | all_template_parameters | ...
-/// +------+----------------------+--------------------------+-------------------------+----
-/// |Foo   | T, U                 | 2                        | T, U                    | ...
-/// |Bar   | V                    | 1                        | T, U, V                 | ...
-/// |Inner |                      | 0                        | T, U                    | ...
-/// |Lol   | W                    | 1                        | T, U, W                 | ...
-/// |Wtf   | X                    | 1                        | T, U, X                 | ...
-/// |Qux   |                      | 0                        |                         | ...
-/// +------+----------------------+--------------------------+------------------------+----
-///
-/// ----+------+-----+----------------------+
-/// ... |Decl. | ... | used_template_params |
-/// ----+------+-----+----------------------+
-/// ... |Foo   | ... | T, U                 |
-/// ... |Bar   | ... | V                    |
-/// ... |Inner | ... |                      |
-/// ... |Lol   | ... | T                    |
-/// ... |Wtf   | ... | T                    |
-/// ... |Qux   | ... |                      |
-/// ----+------+-----+----------------------+
-pub(crate) trait TemplateParameters: Sized {
-    /// Get the set of `ItemId`s that make up this template declaration's free
-    /// template parameters.
-    ///
-    /// Note that these might *not* all be named types: C++ allows
-    /// constant-value template parameters as well as template-template
-    /// parameters. Of course, Rust does not allow generic parameters to be
-    /// anything but types, so we must treat them as opaque, and avoid
-    /// instantiating them.
-    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>;
-
-    /// Get the number of free template parameters this template declaration
-    /// has.
-    fn num_self_template_params(&self, ctx: &BindgenContext) -> usize {
-        self.self_template_params(ctx).len()
-    }
-
-    /// Get the complete set of template parameters that can affect this
-    /// declaration.
-    ///
-    /// Note that this item doesn't need to be a template declaration itself for
-    /// `Some` to be returned here (in contrast to `self_template_params`). If
-    /// this item is a member of a template declaration, then the parent's
-    /// template parameters are included here.
-    ///
-    /// In the example above, `Inner` depends on both of the `T` and `U` type
-    /// parameters, even though it is not itself a template declaration and
-    /// therefore has no type parameters itself. Perhaps it helps to think about
-    /// how we would fully reference such a member type in C++:
-    /// `Foo<int,char>::Inner`. `Foo` *must* be instantiated with template
-    /// arguments before we can gain access to the `Inner` member type.
-    fn all_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
-    where
-        Self: ItemAncestors,
-    {
-        let mut ancestors: Vec<_> = self.ancestors(ctx).collect();
-        ancestors.reverse();
-        ancestors
-            .into_iter()
-            .flat_map(|id| id.self_template_params(ctx).into_iter())
-            .collect()
-    }
-
-    /// Get only the set of template parameters that this item uses. This is a
-    /// subset of `all_template_params` and does not necessarily contain any of
-    /// `self_template_params`.
-    fn used_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
-    where
-        Self: AsRef<ItemId>,
-    {
-        assert!(
-            ctx.in_codegen_phase(),
-            "template parameter usage is not computed until codegen"
-        );
-
-        let id = *self.as_ref();
-        ctx.resolve_item(id)
-            .all_template_params(ctx)
-            .into_iter()
-            .filter(|p| ctx.uses_template_parameter(id, *p))
-            .collect()
-    }
-}
-
-/// A trait for things which may or may not be a named template type parameter.
-pub(crate) trait AsTemplateParam {
-    /// Any extra information the implementor might need to make this decision.
-    type Extra;
-
-    /// Convert this thing to the item ID of a named template type parameter.
-    fn as_template_param(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> Option<TypeId>;
-
-    /// Is this a named template type parameter?
-    fn is_template_param(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> bool {
-        self.as_template_param(ctx, extra).is_some()
-    }
-}
-
-/// A concrete instantiation of a generic template.
-#[derive(Clone, Debug)]
-pub(crate) struct TemplateInstantiation {
-    /// The template definition which this is instantiating.
-    definition: TypeId,
-    /// The concrete template arguments, which will be substituted in the
-    /// definition for the generic template parameters.
-    args: Vec<TypeId>,
-}
-
-impl TemplateInstantiation {
-    /// Construct a new template instantiation from the given parts.
-    pub(crate) fn new<I>(definition: TypeId, args: I) -> TemplateInstantiation
-    where
-        I: IntoIterator<Item = TypeId>,
-    {
-        TemplateInstantiation {
-            definition,
-            args: args.into_iter().collect(),
-        }
-    }
-
-    /// Get the template definition for this instantiation.
-    pub(crate) fn template_definition(&self) -> TypeId {
-        self.definition
-    }
-
-    /// Get the concrete template arguments used in this instantiation.
-    pub(crate) fn template_arguments(&self) -> &[TypeId] {
-        &self.args[..]
-    }
-
-    /// Parse a `TemplateInstantiation` from a clang `Type`.
-    pub(crate) fn from_ty(
-        ty: &clang::Type,
-        ctx: &mut BindgenContext,
-    ) -> Option<TemplateInstantiation> {
-        use clang_sys::*;
-
-        let template_args = ty.template_args().map_or(vec![], |args| match ty
-            .canonical_type()
-            .template_args()
-        {
-            Some(canonical_args) => {
-                let arg_count = args.len();
-                args.chain(canonical_args.skip(arg_count))
-                    .filter(|t| t.kind() != CXType_Invalid)
-                    .map(|t| {
-                        Item::from_ty_or_ref(t, t.declaration(), None, ctx)
-                    })
-                    .collect()
-            }
-            None => args
-                .filter(|t| t.kind() != CXType_Invalid)
-                .map(|t| Item::from_ty_or_ref(t, t.declaration(), None, ctx))
-                .collect(),
-        });
-
-        let declaration = ty.declaration();
-        let definition = if declaration.kind() == CXCursor_TypeAliasTemplateDecl
-        {
-            Some(declaration)
-        } else {
-            declaration.specialized().or_else(|| {
-                let mut template_ref = None;
-                ty.declaration().visit(|child| {
-                    if child.kind() == CXCursor_TemplateRef {
-                        template_ref = Some(child);
-                        return CXVisit_Break;
-                    }
-
-                    // Instantiations of template aliases might have the
-                    // TemplateRef to the template alias definition arbitrarily
-                    // deep, so we need to recurse here and not only visit
-                    // direct children.
-                    CXChildVisit_Recurse
-                });
-
-                template_ref.and_then(|cur| cur.referenced())
-            })
-        };
-
-        let definition = match definition {
-            Some(def) => def,
-            None => {
-                if !ty.declaration().is_builtin() {
-                    warn!(
-                        "Could not find template definition for template \
-                         instantiation"
-                    );
-                }
-                return None;
-            }
-        };
-
-        let template_definition =
-            Item::from_ty_or_ref(definition.cur_type(), definition, None, ctx);
-
-        Some(TemplateInstantiation::new(
-            template_definition,
-            template_args,
-        ))
-    }
-}
-
-impl IsOpaque for TemplateInstantiation {
-    type Extra = Item;
-
-    /// Is this an opaque template instantiation?
-    fn is_opaque(&self, ctx: &BindgenContext, item: &Item) -> bool {
-        if self.template_definition().is_opaque(ctx, &()) {
-            return true;
-        }
-
-        // TODO(#774): This doesn't properly handle opaque instantiations where
-        // an argument is itself an instantiation because `canonical_name` does
-        // not insert the template arguments into the name, ie it for nested
-        // template arguments it creates "Foo" instead of "Foo<int>". The fully
-        // correct fix is to make `canonical_{name,path}` include template
-        // arguments properly.
-
-        let mut path = item.path_for_allowlisting(ctx).clone();
-        let args: Vec<_> = self
-            .template_arguments()
-            .iter()
-            .map(|arg| {
-                let arg_path =
-                    ctx.resolve_item(*arg).path_for_allowlisting(ctx);
-                arg_path[1..].join("::")
-            })
-            .collect();
-        {
-            let last = path.last_mut().unwrap();
-            last.push('<');
-            last.push_str(&args.join(", "));
-            last.push('>');
-        }
-
-        ctx.opaque_by_name(&path)
-    }
-}
-
-impl Trace for TemplateInstantiation {
-    type Extra = ();
-
-    fn trace<T>(&self, _ctx: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        tracer
-            .visit_kind(self.definition.into(), EdgeKind::TemplateDeclaration);
-        for arg in self.template_arguments() {
-            tracer.visit_kind(arg.into(), EdgeKind::TemplateArgument);
-        }
-    }
-}