Add more warnings to crate root

.github/workflows/ci.yml

@@ -181,6 +181,8 @@ jobs:
         $PUBLIC_CRATES
         --features=$INTERESTING_FEATURES
         --features=$LATEST_MACOS_FEATURE
+      env:
+        RUSTFLAGS: "--codegen=debuginfo=0" # Removed --deny=warnings
 
   ui:
     name: Compiler UI

crates/block-sys/src/lib.rs

@@ -14,11 +14,14 @@
 
 #![no_std]
 #![warn(elided_lifetimes_in_paths)]
+#![warn(missing_copy_implementations)]
 #![deny(non_ascii_idents)]
 #![warn(unreachable_pub)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![warn(clippy::cargo)]
 #![warn(clippy::ptr_as_ptr)]
+#![warn(clippy::missing_errors_doc)]
+#![warn(clippy::missing_panics_doc)]
 // Update in Cargo.toml as well.
 #![doc(html_root_url = "https://docs.rs/block-sys/0.2.0")]
 #![cfg_attr(feature = "unstable-docsrs", feature(doc_auto_cfg, doc_cfg_hide))]
@@ -291,6 +294,7 @@ pub struct Block_layout {
 }
 
 #[repr(C)]
+#[allow(missing_copy_implementations)]
 pub struct Block_descriptor_header {
     /// Reserved for future use. Currently always 0.
     pub reserved: c_ulong, // usize

crates/block2/src/block.rs

@@ -116,7 +116,7 @@ impl<A: BlockArguments, R: EncodeReturn> Block<A, R> {
         let ptr: *const Self = self;
         let layout = unsafe { ptr.cast::<ffi::Block_layout>().as_ref().unwrap_unchecked() };
         // TODO: Is `invoke` actually ever null?
-        let invoke = layout.invoke.unwrap();
+        let invoke = layout.invoke.unwrap_or_else(|| unreachable!());
 
         unsafe { A::__call_block(invoke, ptr as *mut Self, args) }
     }

crates/block2/src/lib.rs

@@ -76,12 +76,16 @@
 
 #![no_std]
 #![warn(elided_lifetimes_in_paths)]
+#![warn(missing_copy_implementations)]
+#![warn(missing_debug_implementations)]
 #![warn(missing_docs)]
 #![deny(non_ascii_idents)]
 #![warn(unreachable_pub)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![warn(clippy::cargo)]
 #![warn(clippy::ptr_as_ptr)]
+#![warn(clippy::missing_errors_doc)]
+#![warn(clippy::missing_panics_doc)]
 // Update in Cargo.toml as well.
 #![doc(html_root_url = "https://docs.rs/block2/0.3.0")]
 

crates/icrate/src/Foundation/__macro_helpers/cached.rs

@@ -6,6 +6,7 @@ use objc2::rc::Id;
 use objc2::Message;
 
 /// Allows storing an `Id` in a static and lazily loading it.
+#[derive(Debug)]
 pub struct CachedId<T> {
     ptr: AtomicPtr<T>,
 }

crates/icrate/src/Foundation/__macro_helpers/ns_string.rs

@@ -1,4 +1,5 @@
 #![cfg(feature = "Foundation_NSString")]
+#![allow(missing_copy_implementations)]
 //! Macro for making a static NSString.
 //!
 //! This closely follows what clang does, see:
@@ -37,6 +38,7 @@ extern "C" {
 /// [`CFRuntimeBase`]: <https://github.com/apple-oss-distributions/CF/blob/CF-1153.18/CFRuntime.h#L216-L228>
 /// [`CF_CONST_STRING`]: <https://github.com/apple-oss-distributions/CF/blob/CF-1153.18/CFInternal.h#L332-L336>
 #[repr(C)]
+#[derive(Debug)]
 pub struct CFConstString {
     isa: &'static AnyClass,
     // Important that we don't use `usize` here, since that would be wrong on
@@ -118,6 +120,7 @@ pub const fn is_ascii_no_nul(bytes: &[u8]) -> bool {
     true
 }
 
+#[derive(Debug)]
 pub struct Utf16Char {
     pub repr: [u16; 2],
     pub len: usize,
@@ -147,6 +150,7 @@ impl Utf16Char {
     }
 }
 
+#[derive(Debug)]
 pub struct EncodeUtf16Iter {
     str: &'static [u8],
     index: usize,

crates/icrate/src/lib.rs

@@ -7,6 +7,8 @@
 #![no_std]
 #![cfg_attr(feature = "unstable-docsrs", feature(doc_auto_cfg))]
 #![warn(elided_lifetimes_in_paths)]
+#![warn(missing_copy_implementations)]
+#![warn(missing_debug_implementations)]
 #![deny(non_ascii_idents)]
 #![warn(unreachable_pub)]
 #![deny(unsafe_op_in_unsafe_fn)]

crates/objc-sys/src/image_info.rs

@@ -5,6 +5,7 @@
 /// only used behind experimental features (`unstable-static-*`).
 #[repr(C)]
 #[doc(hidden)]
+#[allow(missing_copy_implementations)]
 pub struct __ImageInfo {
     // These are not actually `unsigned int`, even though the docs say so
     /// The version of the image info struct.

crates/objc-sys/src/lib.rs

@@ -15,11 +15,14 @@
 
 #![no_std]
 #![warn(elided_lifetimes_in_paths)]
+#![warn(missing_copy_implementations)]
 #![deny(non_ascii_idents)]
 #![warn(unreachable_pub)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![warn(clippy::cargo)]
 #![warn(clippy::ptr_as_ptr)]
+#![warn(clippy::missing_errors_doc)]
+#![warn(clippy::missing_panics_doc)]
 #![allow(clippy::upper_case_acronyms)]
 #![allow(non_camel_case_types)]
 #![allow(non_upper_case_globals)]

crates/objc2-encode/src/encoding.rs

@@ -34,7 +34,8 @@ use crate::EncodingBox;
 /// use objc2_encode::Encoding;
 /// assert!(Encoding::Array(10, &Encoding::FloatComplex).equivalent_to_str("[10jf]"));
 /// ```
-// Not `Copy`, since this may one day contain `Box`
+// Not `Copy`, since this may one day be merged with `EncodingBox`
+#[allow(missing_copy_implementations)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 // See <https://en.cppreference.com/w/c/language/type>
 #[non_exhaustive] // Maybe we're missing some encodings?

crates/objc2-encode/src/encoding_box.rs

@@ -111,6 +111,11 @@ impl EncodingBox {
     /// returned by `method_getTypeEncoding`.
     ///
     /// [`from_str`][Self::from_str] is simpler, use that instead if you can.
+    ///
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the string was an ill-formatted encoding string.
     pub fn from_start_of_str(s: &mut &str) -> Result<Self, ParseError> {
         let mut parser = Parser::new(s);
         parser.strip_leading_qualifiers();

crates/objc2-encode/src/lib.rs

@@ -37,12 +37,16 @@
 
 #![no_std]
 #![warn(elided_lifetimes_in_paths)]
+#![warn(missing_copy_implementations)]
+#![warn(missing_debug_implementations)]
 #![warn(missing_docs)]
 #![deny(non_ascii_idents)]
 #![warn(unreachable_pub)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![warn(clippy::cargo)]
 #![warn(clippy::ptr_as_ptr)]
+#![warn(clippy::missing_errors_doc)]
+#![warn(clippy::missing_panics_doc)]
 // Update in Cargo.toml as well.
 #![doc(html_root_url = "https://docs.rs/objc2-encode/3.0.0")]
 #![cfg_attr(feature = "unstable-c-unwind", feature(c_unwind))]

crates/objc2-proc-macros/src/lib.rs

@@ -5,11 +5,15 @@
 
 #![warn(elided_lifetimes_in_paths)]
 #![warn(missing_docs)]
+#![warn(missing_copy_implementations)]
+#![warn(missing_debug_implementations)]
 #![deny(non_ascii_idents)]
 #![warn(unreachable_pub)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![warn(clippy::cargo)]
 #![warn(clippy::ptr_as_ptr)]
+#![warn(clippy::missing_errors_doc)]
+#![warn(clippy::missing_panics_doc)]
 // Update in Cargo.toml as well.
 #![doc(html_root_url = "https://docs.rs/objc2-proc-macros/0.1.1")]
 

crates/objc2/src/__macro_helpers/cache.rs

@@ -8,6 +8,7 @@ use crate::ffi;
 use crate::runtime::{AnyClass, Sel};
 
 /// Allows storing a [`Sel`] in a static and lazily loading it.
+#[derive(Debug)]
 pub struct CachedSel {
     ptr: AtomicPtr<ffi::objc_selector>,
 }
@@ -52,6 +53,7 @@ impl CachedSel {
 }
 
 /// Allows storing a [`AnyClass`] reference in a static and lazily loading it.
+#[derive(Debug)]
 pub struct CachedClass {
     ptr: AtomicPtr<AnyClass>,
 }

crates/objc2/src/__macro_helpers/mod.rs

@@ -58,6 +58,7 @@ pub use self::declare_class::{
 ///
 /// <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#retainable-object-pointers-as-operands-and-arguments>
 // TODO: Use an enum instead of u8 here when stable
+#[derive(Debug)]
 pub struct RetainSemantics<const INNER: u8> {}
 
 pub type New = RetainSemantics<1>;
@@ -425,6 +426,7 @@ const fn in_selector_family(mut selector: &[u8], mut family: &[u8]) -> bool {
 ///
 /// <https://github.com/llvm/llvm-project/blob/release/13.x/clang/lib/CodeGen/CGObjCMac.cpp#L5211-L5234>
 #[repr(C)]
+#[derive(Debug)]
 pub struct ModuleInfo {
     version: usize,
     size: usize,
@@ -496,6 +498,7 @@ impl ClassBuilder {
 /// - Only methods on the protocol are overriden.
 /// - TODO: The methods have the correct signature.
 /// - All required methods are overridden.
+#[derive(Debug)]
 pub struct ClassProtocolMethodsBuilder<'a, 'b> {
     builder: &'a mut ClassBuilder,
     #[allow(unused)]

crates/objc2/src/declare/ivar_bool.rs

@@ -10,6 +10,8 @@ use super::InnerIvarType;
 /// so using C99 `_Bool`; if you want to use `BOOL` in Objective-C, you should
 /// use `IvarEncode<Bool>`.
 #[repr(transparent)]
+#[allow(missing_copy_implementations)]
+#[allow(missing_debug_implementations)]
 pub struct IvarBool(bool);
 
 unsafe impl Encode for IvarBool {

crates/objc2/src/declare/ivar_drop.rs

@@ -26,6 +26,7 @@ mod private {
 ///
 /// Further may be added when the standard library guarantee their layout.
 #[repr(transparent)]
+#[allow(missing_debug_implementations)]
 pub struct IvarDrop<T: private::IvarDropHelper>(<T as private::IvarDropHelper>::Inner);
 
 impl<T: private::IvarDropHelper> super::ivar::private::Sealed for IvarDrop<T> {}

crates/objc2/src/declare/ivar_encode.rs

@@ -9,6 +9,7 @@ use super::InnerIvarType;
 // Note: We put the inner type in a `MaybeUninit`, since we may need to access
 // this type before the inner type has been properly initialized.
 #[repr(transparent)]
+#[allow(missing_debug_implementations)]
 pub struct IvarEncode<T>(MaybeUninit<T>);
 
 // We intentionally don't implement `Drop`, since that may happen before the

crates/objc2/src/declare/ivar_forwarding_impls.rs

@@ -14,7 +14,7 @@ use core::fmt;
 use core::future::Future;
 use core::hash;
 use core::iter::FusedIterator;
-use core::ops::{Deref, DerefMut};
+use core::ops::Deref;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 use std::error::Error;
@@ -192,25 +192,27 @@ impl<I: IvarType> FusedIterator for Ivar<I> where <Self as Deref>::Target: Fused
 
 // impl<T: IvarType> borrow::Borrow<<Self as Deref>::Target> for Ivar<T> {
 //     fn borrow(&self) -> &<Self as Deref>::Target {
-//         Deref::deref(self)
+//         self
 //     }
 // }
 //
 // impl<T: IvarType> borrow::BorrowMut<<Self as Deref>::Target> for Ivar<T> {
 //     fn borrow_mut(&mut self) -> &mut <Self as Deref>::Target {
-//         DerefMut::deref_mut(self)
+//         self
 //     }
 // }
 
 impl<T: IvarType> AsRef<<Self as Deref>::Target> for Ivar<T> {
     fn as_ref(&self) -> &<Self as Deref>::Target {
-        Deref::deref(self)
+        // Auto-derefs
+        self
     }
 }
 
 impl<T: IvarType> AsMut<<Self as Deref>::Target> for Ivar<T> {
     fn as_mut(&mut self) -> &mut <Self as Deref>::Target {
-        DerefMut::deref_mut(self)
+        // Auto-derefs
+        self
     }
 }