Remove platforms in favor using CARGO_CFG_TARGET_POINTER_WIDTH (#636)

curve25519-dalek/Cargo.toml

@@ -38,7 +38,6 @@ rand = "0.8"
 rand_core = { version = "0.6", default-features = false, features = ["getrandom"] }
 
 [build-dependencies]
-platforms = "3.0.2"
 rustc_version = "0.4.0"
 
 [[bench]]

curve25519-dalek/build.rs

@@ -9,17 +9,31 @@ enum DalekBits {
     Dalek64,
 }
 
+use std::fmt::Formatter;
+
+impl std::fmt::Display for DalekBits {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let w_bits = match self {
+            DalekBits::Dalek32 => "32",
+            DalekBits::Dalek64 => "64",
+        };
+        write!(f, "{}", w_bits)
+    }
+}
+
 fn main() {
+    let target_arch = match std::env::var("CARGO_CFG_TARGET_ARCH") {
+        Ok(arch) => arch,
+        _ => "".to_string(),
+    };
+
     let curve25519_dalek_bits = match std::env::var("CARGO_CFG_CURVE25519_DALEK_BITS").as_deref() {
         Ok("32") => DalekBits::Dalek32,
         Ok("64") => DalekBits::Dalek64,
-        _ => deterministic::determine_curve25519_dalek_bits(),
+        _ => deterministic::determine_curve25519_dalek_bits(&target_arch),
     };
 
-    match curve25519_dalek_bits {
-        DalekBits::Dalek64 => println!("cargo:rustc-cfg=curve25519_dalek_bits=\"64\""),
-        DalekBits::Dalek32 => println!("cargo:rustc-cfg=curve25519_dalek_bits=\"32\""),
-    }
+    println!("cargo:rustc-cfg=curve25519_dalek_bits=\"{curve25519_dalek_bits}\"");
 
     if rustc_version::version_meta()
         .expect("failed to detect rustc version")
@@ -36,11 +50,6 @@ fn main() {
         println!("cargo:rustc-cfg=allow_unused_unsafe");
     }
 
-    let target_arch = match std::env::var("CARGO_CFG_TARGET_ARCH") {
-        Ok(arch) => arch,
-        _ => "".to_string(),
-    };
-
     // Backend overrides / defaults
     let curve25519_dalek_backend =
         match std::env::var("CARGO_CFG_CURVE25519_DALEK_BACKEND").as_deref() {
@@ -74,53 +83,43 @@ mod deterministic {
 
     use super::*;
 
-    // Standard Cargo TARGET environment variable of triplet is required
-    static ERR_MSG_NO_TARGET: &str = "Standard Cargo TARGET environment variable is not set";
+    // Custom Rust non-cargo build tooling needs to set CARGO_CFG_TARGET_POINTER_WIDTH
+    static ERR_MSG_NO_POINTER_WIDTH: &str =
+        "Standard Cargo TARGET_POINTER_WIDTH environment variable is not set.";
 
-    // Custom Non-Rust standard target platforms require explicit settings.
-    static ERR_MSG_NO_PLATFORM: &str = "Unknown Rust target platform.";
+    // When either non-32 or 64 TARGET_POINTER_WIDTH detected
+    static ERR_MSG_UNKNOWN_POINTER_WIDTH: &str = "Unknown TARGET_POINTER_WIDTH detected.";
 
     // Warning when the curve25519_dalek_bits cannot be determined
     fn determine_curve25519_dalek_bits_warning(cause: &str) {
         println!("cargo:warning=\"Defaulting to curve25519_dalek_bits=32: {cause}\"");
     }
 
     // Determine the curve25519_dalek_bits based on Rust standard TARGET triplet
-    pub(super) fn determine_curve25519_dalek_bits() -> DalekBits {
-        use platforms::target::PointerWidth;
-
-        // TARGET environment is supplied by Cargo
-        // https://doc.rust-lang.org/cargo/reference/environment-variables.html
-        let target_triplet = match std::env::var("TARGET") {
-            Ok(t) => t,
+    pub(super) fn determine_curve25519_dalek_bits(target_arch: &String) -> DalekBits {
+        let target_pointer_width = match std::env::var("CARGO_CFG_TARGET_POINTER_WIDTH") {
+            Ok(pw) => pw,
             Err(_) => {
-                determine_curve25519_dalek_bits_warning(ERR_MSG_NO_TARGET);
-                return DalekBits::Dalek32;
-            }
-        };
-
-        // platforms crate is the source of truth used to determine the platform
-        let platform = match platforms::Platform::find(&target_triplet) {
-            Some(p) => p,
-            None => {
-                determine_curve25519_dalek_bits_warning(ERR_MSG_NO_PLATFORM);
+                determine_curve25519_dalek_bits_warning(ERR_MSG_NO_POINTER_WIDTH);
                 return DalekBits::Dalek32;
             }
         };
 
         #[allow(clippy::match_single_binding)]
-        match platform.target_arch {
+        match &target_arch {
             //Issues: 449 and 456
+            //TODO: When adding arch defaults use proper types not String match
             //TODO(Arm): Needs tests + benchmarks to back this up
-            //platforms::target::Arch::Arm => DalekBits::Dalek64,
             //TODO(Wasm32): Needs tests + benchmarks to back this up
-            //platforms::target::Arch::Wasm32 => DalekBits::Dalek64,
-            _ => match platform.target_pointer_width {
-                PointerWidth::U64 => DalekBits::Dalek64,
-                PointerWidth::U32 => DalekBits::Dalek32,
+            _ => match target_pointer_width.as_ref() {
+                "64" => DalekBits::Dalek64,
+                "32" => DalekBits::Dalek32,
                 // Intended default solely for non-32/64 target pointer widths
                 // Otherwise known target platforms only.
-                _ => DalekBits::Dalek32,
+                _ => {
+                    determine_curve25519_dalek_bits_warning(ERR_MSG_UNKNOWN_POINTER_WIDTH);
+                    DalekBits::Dalek32
+                }
             },
         }
     }