Merge pull request #108 from madsmtm/encoding-integration-test

Properly test that encodings match the Objective-C `@encode` output

Author: madsmtm

objc2-encode/CHANGELOG.md

@@ -6,6 +6,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## Unreleased - YYYY-MM-DD
 
+### Added
+* Added `Encoding::LONG` and `Encoding::U_LONG` to help with platform
+  compatibility; use these instead of `c_long::ENCODING` and
+  `c_ulong::ENCODING`.
+
 
 ## 2.0.0-beta.2 - 2022-01-03
 

objc2-encode/src/encoding.rs

@@ -134,6 +134,40 @@ pub enum Encoding<'a> {
 }
 
 impl Encoding<'_> {
+    /// The encoding of [`c_long`](`std::os::raw::c_long`).
+    ///
+    /// Ideally the encoding of `long` would just be the same as `int` when
+    /// it's 32 bits wide and the same as `long long` when it is 64 bits wide;
+    /// then `c_long::ENCODING` would just work.
+    ///
+    /// Unfortunately, `long` have a different encoding than `int` when it is
+    /// 32 bits wide; the 'l'/'L' encoding.
+    pub const LONG: Self = {
+        // Alternative: `mem::size_of::<c_long>() == 4`
+        // That would exactly match what `clang` does:
+        // https://github.com/llvm/llvm-project/blob/release/13.x/clang/lib/AST/ASTContext.cpp#L7245
+        if cfg!(any(target_pointer_width = "32", windows)) {
+            // @encode(long) = 'l'
+            Self::Long
+        } else {
+            // @encode(long) = 'q'
+            Self::LongLong
+        }
+    };
+
+    /// The encoding of [`c_ulong`](`std::os::raw::c_ulong`).
+    ///
+    /// See [`Encoding::LONG`] for explanation.
+    pub const U_LONG: Self = {
+        if cfg!(any(target_pointer_width = "32", windows)) {
+            // @encode(unsigned long) = 'L'
+            Encoding::ULong
+        } else {
+            // @encode(unsigned long) = 'Q'
+            Encoding::ULongLong
+        }
+    };
+
     /// Check if one encoding is equivalent to another.
     pub fn equivalent_to(&self, other: &Self) -> bool {
         // For now, because we don't allow representing qualifiers

objc2-encode/src/lib.rs

@@ -78,6 +78,9 @@
 #[doc = include_str!("../README.md")]
 extern "C" {}
 
+#[cfg(doc)]
+extern crate std;
+
 #[cfg(any(test, doc))]
 extern crate alloc;
 

objc2-foundation/src/enumerator.rs

@@ -1,6 +1,5 @@
 use core::marker::PhantomData;
 use core::mem;
-use core::mem::size_of;
 use core::ptr;
 use core::ptr::NonNull;
 use core::slice;
@@ -57,35 +56,14 @@ struct NSFastEnumerationState<T: INSObject> {
     extra: [c_ulong; 5],
 }
 
-/// Ideally the encoding of `long` would just be the same as `int` when it's
-/// 32 bits wide and the same as `long long` when it's 64 bits wide; then
-/// `c_long::ENCODING` would just work.
-///
-/// Unfortunately, `long` and `unsigned long` have a different encoding than
-/// `int` when it's 32 bits wide; the 'l'/'L' encoding.
-const U_LONG_ENCODING: Encoding<'static> = {
-    // We could also just have used:
-    // #[cfg(any(target_pointer_width = "32", windows))]
-    //
-    // But this way we exactly match what `clang` does:
-    // https://github.com/llvm/llvm-project/blob/release/13.x/clang/lib/AST/ASTContext.cpp#L7245
-    if size_of::<c_ulong>() == 4 {
-        // @encode(unsigned long) = 'L'
-        Encoding::ULong
-    } else {
-        // @encode(unsigned long) = 'Q'
-        Encoding::ULongLong
-    }
-};
-
 unsafe impl<T: INSObject> Encode for NSFastEnumerationState<T> {
     const ENCODING: Encoding<'static> = Encoding::Struct(
         "?",
         &[
-            U_LONG_ENCODING,
+            Encoding::U_LONG,
             Encoding::Pointer(&Encoding::Object), // <*const *const T>::ENCODING
-            Encoding::Pointer(&U_LONG_ENCODING),
-            Encoding::Array(5, &U_LONG_ENCODING),
+            Encoding::Pointer(&Encoding::U_LONG),
+            Encoding::Array(5, &Encoding::U_LONG),
         ],
     );
 }

tests/Cargo.toml

@@ -12,7 +12,12 @@ build = "build.rs"
 [dependencies]
 block2 = { path = "../block2" }
 block-sys = { path = "../block-sys" }
+objc-sys = { path = "../objc-sys" }
+objc2 = { path = "../objc2" }
 objc2-encode = { path = "../objc2-encode" }
 
 [build-dependencies]
 cc = "1.0"
+
+[dev-dependencies]
+paste = "1.0"

tests/build.rs

@@ -2,6 +2,7 @@ use std::env;
 
 fn main() {
     println!("cargo:rerun-if-changed=extern/block_utils.c");
+    println!("cargo:rerun-if-changed=extern/encode_utils.m");
 
     let mut builder = cc::Build::new();
     builder.compiler("clang");
@@ -12,4 +13,14 @@ fn main() {
     }
 
     builder.compile("libblock_utils.a");
+
+    let mut builder = cc::Build::new();
+    builder.compiler("clang");
+    builder.file("extern/encode_utils.m");
+
+    for flag in env::var("DEP_OBJC_CC_ARGS").unwrap().split(' ') {
+        builder.flag(flag);
+    }
+
+    builder.compile("libencode_utils.a");
 }

tests/extern/encode_utils.m

@@ -0,0 +1,89 @@
+#include <objc/objc.h>
+#include <stdint.h>
+#include <stddef.h>
+// For NSInteger / NSUInteger. Linking is not required.
+#include <Foundation/NSObject.h>
+
+#define ENCODING_INNER(name, type) char* ENCODING_ ## name = @encode(type);
+
+#define ENCODING(name, type) \
+    ENCODING_INNER(name, type); \
+    ENCODING_INNER(name ## _POINTER, type*); \
+    ENCODING_INNER(name ## _ATOMIC, _Atomic type);
+
+// C types
+
+ENCODING(C99_BOOL, _Bool);
+ENCODING(CHAR, char);
+ENCODING(SIGNED_CHAR, signed char);
+ENCODING(UNSIGNED_CHAR, unsigned char);
+ENCODING(SHORT, short);
+ENCODING(UNSIGNED_SHORT, unsigned short);
+ENCODING(INT, int);
+ENCODING(UNSIGNED_INT, unsigned int);
+ENCODING(LONG, long);
+ENCODING(UNSIGNED_LONG, unsigned long);
+ENCODING(LONG_LONG, long long);
+ENCODING(UNSIGNED_LONG_LONG, unsigned long long);
+ENCODING(FLOAT, float);
+ENCODING(DOUBLE, double);
+ENCODING(LONG_DOUBLE, long double);
+
+ENCODING(FLOAT_COMPLEX, float _Complex);
+ENCODING(DOUBLE_COMPLEX, double _Complex);
+ENCODING(LONG_DOUBLE_COMPLEX, long double _Complex);
+// TODO: Enable these:
+// ENCODING(FLOAT_IMAGINARY, float _Imaginary);
+// ENCODING(DOUBLE_IMAGINARY, double _Imaginary);
+// ENCODING(LONG_DOUBLE_IMAGINARY, long double _Imaginary);
+
+ENCODING_INNER(VOID, void);
+ENCODING_INNER(VOID_POINTER, void*);
+ENCODING_INNER(VOID_POINTER_CONST, const void*);
+ENCODING_INNER(VOID_POINTER_POINTER, void**);
+
+// Array
+
+ENCODING_INNER(INT_ARRAY, int[10]);
+ENCODING_INNER(INT_ARRAY_POINTER, int*[10]);
+ENCODING_INNER(INT_ARRAY_ATOMIC, _Atomic int[10]);
+
+// Struct
+
+// TODO: Structs and such
+
+// Objective-C
+
+ENCODING(OBJC_BOOL, BOOL);
+ENCODING_INNER(ID, id);
+ENCODING_INNER(ID_POINTER, const id*);
+ENCODING_INNER(ID_ATOMIC, _Atomic id);
+ENCODING(CLASS, Class);
+ENCODING(SEL, SEL);
+ENCODING(NS_INTEGER, NSInteger);
+ENCODING(NS_UINTEGER, NSUInteger);
+
+// stdint.h
+
+ENCODING(INT8, int8_t);
+ENCODING(INT16, int16_t);
+ENCODING(INT32, int32_t);
+ENCODING(INT64, int64_t);
+ENCODING(INTPTR, intptr_t);
+ENCODING(UINT8, uint8_t);
+ENCODING(UINT16, uint16_t);
+ENCODING(UINT32, uint32_t);
+ENCODING(UINT64, uint64_t);
+ENCODING(UINTPTR, uintptr_t);
+
+// stddef.h
+
+ENCODING(SIZE_T, size_t);
+ENCODING(PTRDIFF_T, ptrdiff_t);
+
+// Possible extras
+
+#if __has_builtin(__int128_t)
+ENCODING(SIGNED_INT_128, __int128_t);
+ENCODING(UNSIGNED_INT_128, __uint128_t);
+#endif

tests/src/lib.rs

@@ -4,10 +4,12 @@
 #![no_std]
 use block2::{Block, RcBlock};
 
-#[cfg(test)]
 extern crate alloc;
+extern crate std;
 
 pub mod ffi;
+#[cfg(test)]
+mod test_encode_utils;
 use crate::ffi::LargeStruct;
 
 pub fn get_int_block_with(i: i32) -> RcBlock<(), i32> {