Change the ABI for "join" on variants (#199)

This commit changes the ABI for variants such as `union { f32, f64 }`
which in the prior version of the canonical ABI would look like `i32
f64` but with the current canonical ABI draft it would instead look like
`i32 i64`. The previous `unify` function is updated to the new name used
in the canonical ABI explainer, `join`, the contents are modified, and
one form of bitcast was removed as a result.

Additionally I updated the bless'd output for `wasmlink` to ensure
everything has newlines at the end since I was getting some otherwise
odd changes locally. This is hopefully a one-time change for those
baselines.

Author: alexcrichton

crates/gen-c/src/lib.rs

@@ -1335,7 +1335,6 @@ impl Bindgen for FunctionBindgen<'_> {
                             results
                                 .push(format!("((union {{ float a; int32_t b; }}){{ {} }}).b", op));
                         }
-                        Bitcast::F32ToF64 | Bitcast::F64ToF32 => results.push(op.to_string()),
                         Bitcast::I64ToF64 => {
                             results.push(format!(
                                 "((union {{ int64_t a; double b; }}){{ {} }}).b",

crates/gen-js/src/lib.rs

@@ -1297,7 +1297,6 @@ impl Bindgen for FunctionBindgen<'_> {
                             let cvt = self.gen.intrinsic(Intrinsic::F32ToI32);
                             results.push(format!("{}({})", cvt, op));
                         }
-                        Bitcast::F32ToF64 | Bitcast::F64ToF32 => results.push(op.clone()),
                         Bitcast::I64ToF64 => {
                             let cvt = self.gen.intrinsic(Intrinsic::I64ToF64);
                             results.push(format!("{}({})", cvt, op));

crates/gen-rust/src/lib.rs

@@ -956,11 +956,9 @@ pub fn bitcast(casts: &[Bitcast], operands: &[String], results: &mut Vec<String>
     for (cast, operand) in casts.iter().zip(operands) {
         results.push(match cast {
             Bitcast::None => operand.clone(),
-            Bitcast::F32ToF64 => format!("f64::from({})", operand),
             Bitcast::I32ToI64 => format!("i64::from({})", operand),
             Bitcast::F32ToI32 => format!("({}).to_bits() as i32", operand),
             Bitcast::F64ToI64 => format!("({}).to_bits() as i64", operand),
-            Bitcast::F64ToF32 => format!("{} as f32", operand),
             Bitcast::I64ToI32 => format!("{} as i32", operand),
             Bitcast::I32ToF32 => format!("f32::from_bits({} as u32)", operand),
             Bitcast::I64ToF64 => format!("f64::from_bits({} as u64)", operand),

crates/gen-wasmtime-py/src/lib.rs

@@ -1402,7 +1402,6 @@ impl Bindgen for FunctionBindgen<'_> {
                             self.gen.needs_f32_to_i32 = true;
                             results.push(format!("_f32_to_i32({})", op));
                         }
-                        Bitcast::F32ToF64 | Bitcast::F64ToF32 => results.push(op.clone()),
                         Bitcast::I64ToF64 => {
                             self.gen.needs_i64_to_f64 = true;
                             results.push(format!("_i64_to_f64({})", op));

crates/parser/src/abi.rs

@@ -26,16 +26,15 @@ pub enum WasmType {
     // e.g. externref, so we don't need to define them here.
 }
 
-fn unify(a: WasmType, b: WasmType) -> WasmType {
+fn join(a: WasmType, b: WasmType) -> WasmType {
     use WasmType::*;
 
     match (a, b) {
-        (I64, _) | (_, I64) | (I32, F64) | (F64, I32) => I64,
+        (I32, I32) | (I64, I64) | (F32, F32) | (F64, F64) => a,
 
-        (I32, I32) | (I32, F32) | (F32, I32) => I32,
+        (I32, F32) | (F32, I32) => I32,
 
-        (F32, F32) => F32,
-        (F64, F64) | (F32, F64) | (F64, F32) => F64,
+        (_, I64 | F64) | (I64 | F64, _) => I64,
     }
 }
 
@@ -638,14 +637,12 @@ def_instruction! {
 #[derive(Debug, PartialEq)]
 pub enum Bitcast {
     // Upcasts
-    F32ToF64,
     F32ToI32,
     F64ToI64,
     I32ToI64,
     F32ToI64,
 
     // Downcasts
-    F64ToF32,
     I32ToF32,
     I64ToF64,
     I64ToI32,
@@ -893,7 +890,7 @@ impl Interface {
 
                         for (i, ty) in temp.drain(..).enumerate() {
                             match result.get_mut(start + i) {
-                                Some(prev) => *prev = unify(*prev, ty),
+                                Some(prev) => *prev = join(*prev, ty),
                                 None => result.push(ty),
                             }
                         }
@@ -1846,17 +1843,16 @@ fn cast(from: WasmType, to: WasmType) -> Bitcast {
         (I32, I32) | (I64, I64) | (F32, F32) | (F64, F64) => Bitcast::None,
 
         (I32, I64) => Bitcast::I32ToI64,
-        (F32, F64) => Bitcast::F32ToF64,
         (F32, I32) => Bitcast::F32ToI32,
         (F64, I64) => Bitcast::F64ToI64,
 
         (I64, I32) => Bitcast::I64ToI32,
-        (F64, F32) => Bitcast::F64ToF32,
         (I32, F32) => Bitcast::I32ToF32,
         (I64, F64) => Bitcast::I64ToF64,
 
         (F32, I64) => Bitcast::F32ToI64,
         (I64, F32) => Bitcast::I64ToF32,
-        (F64, I32) | (I32, F64) => unreachable!(),
+
+        (F32, F64) | (F64, F32) | (F64, I32) | (I32, F64) => unreachable!(),
     }
 }

crates/wasmlink/tests/no-interface.baseline

@@ -2,4 +2,4 @@
   (type (;0;) (func (param i32 i64 f32 f64) (result i32)))
   (func (;0;) (type 0) (param i32 i64 f32 f64) (result i32)
     unreachable)
-  (export "f1" (func 0)))
+  (export "f1" (func 0)))

crates/wasmlink/tests/not-adapted.baseline

@@ -2,4 +2,4 @@
   (type (;0;) (func (param i32 i64 f32 f64) (result i32)))
   (func (;0;) (type 0) (param i32 i64 f32 f64) (result i32)
     unreachable)
-  (export "f1" (func 0)))
+  (export "f1" (func 0)))

crates/wasmlink/tests/retptr.baseline

@@ -27,4 +27,4 @@
     i64.load (memory 1) offset=8
     i64.store offset=8)
   (export "memory" (memory 1))
-  (export "f1" (func 1)))
+  (export "f1" (func 1)))

crates/wasmlink/tests/run.rs

@@ -39,13 +39,17 @@ fn wasmlink_file_tests() -> Result<()> {
                 let mut wit_path = path.clone();
                 assert!(wit_path.set_extension("wit"));
 
-                let output = match adapt(stem, &bytes, &wit_path) {
+                let mut output = match adapt(stem, &bytes, &wit_path) {
                     Ok(adapted) => print_bytes(&adapted.finish())?,
                     Err(e) => e.to_string(),
                 };
 
                 let baseline_path = path.with_extension("baseline");
                 if env::var_os("BLESS").is_some() {
+                    if !output.ends_with("\n") {
+                        output.push_str("\n");
+                    }
+
                     fs::write(&baseline_path, output)?;
                 } else {
                     let expected = fs::read_to_string(&baseline_path)

crates/wasmlink/tests/string.baseline

@@ -83,4 +83,4 @@
   (export "memory" (memory 1))
   (export "canonical_abi_realloc" (func 1))
   (export "canonical_abi_free" (func 2))
-  (export "f1" (func 4)))
+  (export "f1" (func 4)))