Redo linking logic

madsmtm · madsmtm · commit 308af656d209 · 2021-10-28T13:24:50.000+02:00
- Use X_DEPLOYMENT_TARGET to figure out apple versions
- Use RUNTIME_VERSION to figure out GNUStep versions
- More detailed README instructions
diff --git a/objc2_sys/README.md b/objc2_sys/README.md
@@ -10,56 +10,76 @@ Raw Rust bindings to core Objective-C runtimes and ABIs.
 
 ## Runtime Support
 
-`objc2_sys` currently supports three runtimes (support for [`ObjFW`] may be
-added):
-- Apple's [`objc4`] \(default on `target_vendor = "apple"`\).
-- GNUStep's [`libobjc2`] \(default on other systems\).
-- Window's [`WinObjC`] uses [a fork][ms-libobjc2] of GNUStep's `libobjc2`
-  based on version 1.8 with very few user-facing changes \(default on
-  `target_os = "windows"`\).
-
-A default is chosen automatically from the compilation target as seen above,
-but it is recommended to set the `OBJC_RUNTIME` environment variable to the
-desired runtime when building (see below).
+### Apple's [`objc4`](https://opensource.apple.com/source/objc4/)
+
+This is the default on Apple platforms:
+```rust , ignore
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "tvos",
+    target_os = "watchos",
+))]
+```
+
+The supported runtime version (higher versions lets the compiler enable newer
+optimizations, at the cost of not supporting older operating systems) can be
+chosen using the standard `X_DEPLOYMENT_TARGET` environment variables:
+- macOS: `MACOSX_DEPLOYMENT_TARGET`
+  - Default: `10.7` ([same as Rust](https://github.com/rust-lang/rust/blob/1.56.0/compiler/rustc_target/src/spec/apple_base.rs#L67))
+  - Minimum: `10.7`
+- iOS: `IPHONEOS_DEPLOYMENT_TARGET`
+  - Default: `7.0` ([same as Rust](https://github.com/rust-lang/rust/blob/1.56.0/compiler/rustc_target/src/spec/apple_base.rs#L92))
+  - Minimum: `5.0` (theoretically)
+- tvOS: `TVOS_DEPLOYMENT_TARGET`
+  - Default: TODO
+  - Minimum: `9.0` (theoretically)
+- watchOS: `WATCHOS_DEPLOYMENT_TARGET`
+  - Default: TODO
+  - Minimum: `1.0` (theoretically)
+
+
+### Window's [`WinObjC`](https://github.com/microsoft/WinObjC)
+
+This is the default on `#[cfg(target_os = "windows")]`.
+
+This is essentially just [a fork](https://github.com/microsoft/libobjc2) based
+on GNUStep's `libobjc2` version 1.8, with very few user-facing changes.
+
+
+### GNUStep's [`libobjc2`](https://github.com/gnustep/libobjc2)
+
+This is the default on all other systems.
+
+The version can be chosen by setting the standard (used by GNUStep already)
+`RUNTIME_VERSION` environment variable to one of the following:
+- `gnustep-1.7`
+- `gnustep-1.8` (default)
+- `gnustep-1.9`
+- `gnustep-2.0`
+- `gnustep-2.1`
+
+If you wish to force using the GNUStep runtime on Apple or Windows systems,
+set the `RUNTIME_VERSION` environment variable to one of the values above.
+
+
+### Other runtimes
 
 This library will probably only ever support ["Modern"][modern] Objective-C
 runtimes, since support for reference-counting primitives like `objc_retain`
 and `objc_autoreleasePoolPop` is a vital requirement for most applications.
 
 Just so we're being clear, this rules out the GCC [`libobjc`][gcc-libobjc]
-runtime (see [this][gcc-objc-support]), and the [`mulle-objc`] runtime. More
-information on different runtimes can be found in GNUStep's [Objective-C
-Compiler and Runtime FAQ][gnustep-faq].
+runtime (see [this][gcc-objc-support]), and the [`mulle-objc`] runtime. (But
+support for [`ObjFW`] may be added). More information on different runtimes
+can be found in GNUStep's [Objective-C Compiler and Runtime FAQ][gnustep-faq].
 
-[`ObjFW`]: https://github.com/ObjFW/ObjFW
-[`objc4`]: https://opensource.apple.com/source/objc4/
-[`libobjc2`]: https://github.com/gnustep/libobjc2
-[gnustep-faq]: http://wiki.gnustep.org/index.php/Objective-C_Compiler_and_Runtime_FAQ
-[`WinObjC`]: https://github.com/microsoft/WinObjC
-[ms-libobjc2]: https://github.com/microsoft/libobjc2
 [modern]: https://en.wikipedia.org/wiki/Objective-C#Modern_Objective-C
 [gcc-libobjc]: https://github.com/gcc-mirror/gcc/tree/master/libobjc
 [gcc-objc-support]: https://gcc.gnu.org/onlinedocs/gcc/Standards.html#Objective-C-and-Objective-C_002b_002b-Languages
 [`mulle-objc`]: https://github.com/mulle-objc/mulle-objc-runtime
-
-
-## Required Versions
-
-At least `libobjc2` [version 1.7][libobjc2-1.7] or `objc4`
-[version 493.9][objc4-493.9] is required.
-
-`objc4` version 493.9 is available with:
-- **macOS 10.7**
-- **iOS 5.0**
-- **tvOS 9.0**
-- **watchOS 1.0**
-- **bridgeOS 2.0**
-
-So those are the **minimum supported Apple versions**. Functionality that was
-added after these versions are not (yet?) available in `objc2_sys`.
-
-[libobjc2-1.7]: https://github.com/gnustep/libobjc2/tree/1.7
-[objc4-493.9]: https://opensource.apple.com/source/objc4/
+[`ObjFW`]: https://github.com/ObjFW/ObjFW
+[gnustep-faq]: http://wiki.gnustep.org/index.php/Objective-C_Compiler_and_Runtime_FAQ
 
 
 ## Configuring linking
diff --git a/objc2_sys/build.rs b/objc2_sys/build.rs
@@ -21,10 +21,8 @@ use std::env;
 /// clang version 13's source code:
 /// https://github.com/llvm/llvm-project/blob/llvmorg-13.0.0/clang/include/clang/Basic/ObjCRuntime.h
 ///
-/// Anyhow, it's not ultra important, but enables some optimizations if this
-/// is specified. In the future, Rust will hopefully get something similar to
-/// clang's `-mmacosx-version-min`, and then we won't need this for the
-/// Apple runtimes.
+/// In short, it's not ultra important, but enables some optimizations if this
+/// is specified.
 type Version = Option<String>;
 
 // For clang "-fobjc-runtime" support
@@ -37,32 +35,28 @@ enum AppleRuntime {
 }
 use AppleRuntime::*;
 
-impl AppleRuntime {
-    fn get_default(target_os: &str) -> Option<Self> {
-        match target_os {
-            "macos" => Some(Self::MacOS(None)),
-            "ios" => Some(Self::IOS(None)),
-            "watchos" => Some(Self::WatchOS(None)),
-            "tvos" => Some(Self::TvOS(None)),
-            _ => None,
-        }
-    }
-}
-
 enum Runtime {
     Apple(AppleRuntime),
-    GNUStep(Version),
-    WinObjc(Version),
-    ObjFW(Version),
+    GNUStep(u8, u8),
+    WinObjc,
+    #[allow(dead_code)]
+    ObjFW(Option<String>),
 }
 use Runtime::*;
 
+fn get_env(env: &str) -> Option<String> {
+    println!("cargo:rerun-if-env-changed={}", env);
+    match env::var(env) {
+        Ok(var) => Some(var),
+        Err(env::VarError::NotPresent) => None,
+        Err(env::VarError::NotUnicode(var)) => panic!("Invalid unicode for {}: {:?}", env, var),
+    }
+}
+
 fn main() {
     // The script doesn't depend on our code
     println!("cargo:rerun-if-changed=build.rs");
 
-    println!("cargo:rerun-if-env-changed=OBJC_RUNTIME");
-
     // Used to figure out when BOOL should be i8 vs. bool
     if env::var("TARGET").unwrap().ends_with("macabi") {
         println!("cargo:rustc-cfg=target_abi_macabi");
@@ -71,51 +65,36 @@ fn main() {
     // TODO: Figure out when to enable this
     // println!("cargo:rustc-cfg=libobjc2_strict_apple_compat");
 
-    let target_vendor = env::var("CARGO_CFG_TARGET_VENDOR").unwrap();
-    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
-
-    // OBJC_RUNTIME syntax: `RUNTIME ("-" VERSION)?`
-    let runtime = if let Ok(runtime) = env::var("OBJC_RUNTIME") {
-        let (runtime, version) = if let Some((runtime, version)) = runtime.split_once('-') {
-            (runtime, Some(version.into()))
-        } else {
-            (&*runtime, None)
-        };
-
-        match runtime {
-            "apple" => {
-                if version.is_some() {
-                    panic!("Invalid OBJC_RUNTIME: Version doesn't make sense for the `apple` runtime; use `macos`, `ios`, `tvos` or `watchos`");
-                }
-                Apple(AppleRuntime::get_default(&target_os).expect("Invalid OBJC_RUNTIME: Target OS invalid for the `apple` runtime; specify manually with `macos`, `ios`, `tvos` or `watchos`"))
-            }
-            "gnustep" => GNUStep(version),
-            "winobjc" => WinObjc(version),
-            "objfw" => ObjFW(version),
-            // Support clang "syntax" (`macosx`)
-            "macos" | "macosx" => Apple(MacOS(version)),
-            "ios" => Apple(IOS(version)),
-            "tvos" => Apple(TvOS(version)),
-            "watchos" => Apple(WatchOS(version)),
-            _ => {
-                panic!("Invalid OBJC_RUNTIME: {}", runtime)
-            }
-        }
-    } else {
-        if target_vendor == "apple" {
-            Apple(AppleRuntime::get_default(&target_os).unwrap())
-        } else if target_os == "windows" {
-            WinObjc(None)
-        } else {
-            GNUStep(None)
-        }
+    let runtime = match get_env("RUNTIME_VERSION").as_deref() {
+        // Force using GNUStep on all platforms
+        Some("gnustep-1.7") => GNUStep(1, 7),
+        Some("gnustep-1.8") => GNUStep(1, 8),
+        Some("gnustep-1.9") => GNUStep(1, 9),
+        Some("gnustep-2.0") => GNUStep(2, 0),
+        Some("gnustep-2.1") => GNUStep(2, 1),
+
+        // Pick the relevant runtime to use, and find target versions
+        None => match &*env::var("CARGO_CFG_TARGET_OS").unwrap() {
+            "macos" => Apple(MacOS(Some(
+                get_env("MACOSX_DEPLOYMENT_TARGET").unwrap_or_else(|| "10.7".into()),
+            ))),
+            "ios" => Apple(IOS(Some(
+                get_env("IPHONEOS_DEPLOYMENT_TARGET").unwrap_or_else(|| "7.0".into()),
+            ))),
+            "tvos" => Apple(TvOS(get_env("TVOS_DEPLOYMENT_TARGET"))),
+            "watchos" => Apple(WatchOS(get_env("WATCHOS_DEPLOYMENT_TARGET"))),
+            "windows" => WinObjc,
+            _ => GNUStep(1, 8), // GNUStep's own default
+        },
+
+        Some(runtime) => panic!("Invalid RUNTIME_VERSION: {}", runtime),
     };
 
     // Add `#[cfg(RUNTIME)]` directive
     let runtime_cfg = match runtime {
         Apple(_) => "apple",
-        GNUStep(_) => "gnustep",
-        WinObjc(_) => "winobjc",
+        GNUStep(_, _) => "gnustep",
+        WinObjc => "winobjc",
         ObjFW(_) => "objfw",
     };
     println!("cargo:rustc-cfg={}", runtime_cfg);
@@ -140,17 +119,10 @@ fn main() {
                 }
             }
         }
-        GNUStep(version) => {
-            // GNUStep default in clang is 1.6; we require at least 1.7
-            let version = version.as_deref().unwrap_or("1.7");
-            format!("gnustep-{}", version)
-        }
-        WinObjc(version) => {
-            // WinObjc use a small fork of GNUStep version 1.8; so lower
-            // versions doesn't make sense.
-            let version = version.as_deref().unwrap_or("1.8");
-            format!("gnustep-{}", version)
-        }
+        // Default in clang is 1.6
+        GNUStep(major, minor) => format!("gnustep-{}.{}", major, minor),
+        // WinObjC's libobjc2 is just a fork of gnustep's from version 1.8
+        WinObjc => "gnustep-1.8".into(),
         ObjFW(version) => {
             // Default in clang
             let _version = version.as_deref().unwrap_or("0.8");
@@ -160,7 +132,7 @@ fn main() {
 
     // Add clang arguments
     println!(
-        "cargo:clang_args=-fobjc-link-runtime -fobjc-arc -fobjc-arc-exceptions -fobjc-exceptions -fobjc-runtime={}",
+        "cargo:clang_args=-fobjc-arc -fobjc-arc-exceptions -fobjc-exceptions -fobjc-runtime={}",
         // `-fobjc-link-runtime` -> people don't need to specify `-lobjc`.
 
         // -fobjc-weak ?
