Change float32/float64 to f32/f64 in the C bindings generator. (bytecodealliance#916)

* Change float32/float64 to f32/f64 in the C bindings generator.

Change float32/float64 to f32/f64 in the C bindings generator, in
the `Instruction` enum, and in the tests.

* Update test names in Go.

* Update more tests.

Author: sunfishcode

crates/c/src/lib.rs

@@ -731,8 +731,8 @@ pub fn push_ty_name(resolve: &Resolve, ty: &Type, src: &mut String) {
         Type::S32 => src.push_str("s32"),
         Type::U64 => src.push_str("u64"),
         Type::S64 => src.push_str("s64"),
-        Type::F32 => src.push_str("float32"),
-        Type::F64 => src.push_str("float64"),
+        Type::F32 => src.push_str("f32"),
+        Type::F64 => src.push_str("f64"),
         Type::String => src.push_str("string"),
         Type::Id(id) => {
             let ty = &resolve.types[*id];
@@ -2264,10 +2264,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
             // f32/f64 have the same representation in the import type and in C,
             // so no conversions necessary.
-            Instruction::F32FromFloat32
-            | Instruction::F64FromFloat64
-            | Instruction::Float32FromF32
-            | Instruction::Float64FromF64 => {
+            Instruction::CoreF32FromF32
+            | Instruction::CoreF64FromF64
+            | Instruction::F32FromCoreF32
+            | Instruction::F64FromCoreF64 => {
                 results.push(operands[0].clone());
             }
 

crates/core/src/abi.rs

@@ -174,13 +174,13 @@ def_instruction! {
         /// This may be a noop for some implementations, but it's here in case the
         /// native language representation of `f32` is different than the wasm
         /// representation of `f32`.
-        F32FromFloat32 : [1] => [1],
+        CoreF32FromF32 : [1] => [1],
         /// Conversion an interface type `f64` value to a wasm `f64`.
         ///
         /// This may be a noop for some implementations, but it's here in case the
         /// native language representation of `f64` is different than the wasm
         /// representation of `f64`.
-        F64FromFloat64 : [1] => [1],
+        CoreF64FromF64 : [1] => [1],
 
         /// Converts a native wasm `i32` to an interface type `s8`.
         ///
@@ -211,9 +211,9 @@ def_instruction! {
         /// It's safe to assume that the `i32` is indeed a valid unicode code point.
         CharFromI32 : [1] => [1],
         /// Converts a native wasm `f32` to an interface type `f32`.
-        Float32FromF32 : [1] => [1],
+        F32FromCoreF32 : [1] => [1],
         /// Converts a native wasm `f64` to an interface type `f64`.
-        Float64FromF64 : [1] => [1],
+        F64FromCoreF64 : [1] => [1],
 
         /// Creates a `bool` from an `i32` input, trapping if the `i32` isn't
         /// zero or one.
@@ -1067,8 +1067,8 @@ impl<'a, B: Bindgen> Generator<'a, B> {
             Type::S64 => self.emit(&I64FromS64),
             Type::U64 => self.emit(&I64FromU64),
             Type::Char => self.emit(&I32FromChar),
-            Type::F32 => self.emit(&F32FromFloat32),
-            Type::F64 => self.emit(&F64FromFloat64),
+            Type::F32 => self.emit(&CoreF32FromF32),
+            Type::F64 => self.emit(&CoreF64FromF64),
             Type::String => {
                 let realloc = self.list_realloc();
                 self.emit(&StringLower { realloc });
@@ -1256,8 +1256,8 @@ impl<'a, B: Bindgen> Generator<'a, B> {
             Type::S64 => self.emit(&S64FromI64),
             Type::U64 => self.emit(&U64FromI64),
             Type::Char => self.emit(&CharFromI32),
-            Type::F32 => self.emit(&Float32FromF32),
-            Type::F64 => self.emit(&Float64FromF64),
+            Type::F32 => self.emit(&F32FromCoreF32),
+            Type::F64 => self.emit(&F64FromCoreF64),
             Type::String => self.emit(&StringLift),
             Type::Id(id) => match &self.resolve.types[id].kind {
                 TypeDefKind::Type(t) => self.lift(t),

crates/csharp/src/lib.rs

@@ -1779,10 +1779,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::I32FromU8
             | Instruction::I32FromS8
             | Instruction::I32FromS32
-            | Instruction::Float32FromF32
-            | Instruction::F32FromFloat32
-            | Instruction::F64FromFloat64
-            | Instruction::Float64FromF64
+            | Instruction::F32FromCoreF32
+            | Instruction::CoreF32FromF32
+            | Instruction::CoreF64FromF64
+            | Instruction::F64FromCoreF64
             | Instruction::S32FromI32
             | Instruction::S64FromI64 => results.push(operands[0].clone()),
 

crates/rust/src/bindgen.rs

@@ -345,16 +345,16 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 results.push(format!("{}({s})", self.gen.path_to_as_i32()));
             }
 
-            Instruction::F32FromFloat32 => {
+            Instruction::CoreF32FromF32 => {
                 let s = operands.pop().unwrap();
                 results.push(format!("{}({s})", self.gen.path_to_as_f32()));
             }
-            Instruction::F64FromFloat64 => {
+            Instruction::CoreF64FromF64 => {
                 let s = operands.pop().unwrap();
                 results.push(format!("{}({s})", self.gen.path_to_as_f64()));
             }
-            Instruction::Float32FromF32
-            | Instruction::Float64FromF64
+            Instruction::F32FromCoreF32
+            | Instruction::F64FromCoreF64
             | Instruction::S32FromI32
             | Instruction::S64FromI64 => {
                 results.push(operands.pop().unwrap());

crates/teavm-java/src/lib.rs

@@ -1324,10 +1324,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::I32FromS32
             | Instruction::I64FromS64
             | Instruction::I64FromU64
-            | Instruction::F32FromFloat32
-            | Instruction::F64FromFloat64
-            | Instruction::Float32FromF32
-            | Instruction::Float64FromF64 => results.push(operands[0].clone()),
+            | Instruction::CoreF32FromF32
+            | Instruction::CoreF64FromF64
+            | Instruction::F32FromCoreF32
+            | Instruction::F64FromCoreF64 => results.push(operands[0].clone()),
 
             Instruction::Bitcasts { casts } => results.extend(
                 casts

tests/codegen/floats.wit

@@ -1,10 +1,10 @@
 package foo:foo;
 
 interface floats {
-  float32-param: func(x: float32);
-  float64-param: func(x: float64);
-  float32-result: func() -> float32;
-  float64-result: func() -> float64;
+  f32-param: func(x: f32);
+  f64-param: func(x: f64);
+  f32-result: func() -> f32;
+  f64-result: func() -> f64;
 }
 
 world the-world {

tests/codegen/issue573.wit

@@ -108,7 +108,7 @@ world types-example {
     }
 
     export f-f1: func(typedef: t10) -> t10;
-    export f1: func(f: float32, f-list: list<tuple<char, float64>>) -> (val-p1: s64, val2: string);
+    export f1: func(f: f32, f-list: list<tuple<char, f64>>) -> (val-p1: s64, val2: string);
     /// t2 has been renamed with `use self.types-interface.{t2 as t2-renamed}`
     export re-named: func(perm: option<permissions>, e: option<empty>) -> t2-renamed;
     export re-named2: func(tup: tuple<list<u16>>, e: empty) -> tuple<option<u8>, s8>;

tests/codegen/lists.wit

@@ -9,8 +9,8 @@ interface lists {
   list-s16-param: func(x: list<s16>);
   list-s32-param: func(x: list<s32>);
   list-s64-param: func(x: list<s64>);
-  list-float32-param: func(x: list<float32>);
-  list-float64-param: func(x: list<float64>);
+  list-f32-param: func(x: list<f32>);
+  list-f64-param: func(x: list<f64>);
 
   list-u8-ret: func() -> list<u8>;
   list-u16-ret: func() -> list<u16>;
@@ -20,8 +20,8 @@ interface lists {
   list-s16-ret: func() -> list<s16>;
   list-s32-ret: func() -> list<s32>;
   list-s64-ret: func() -> list<s64>;
-  list-float32-ret: func() -> list<float32>;
-  list-float64-ret: func() -> list<float64>;
+  list-f32-ret: func() -> list<f32>;
+  list-f64-ret: func() -> list<f64>;
 
   tuple-list: func(x: list<tuple<u8, s8>>) -> list<tuple<s64, u32>>;
   string-list-arg: func(a: list<string>);
@@ -72,8 +72,8 @@ interface lists {
     s32,
     u64,
     s64,
-    float32,
-    float64,
+    f32,
+    f64,
     char,
   >>;
   load-store-everything: func(a: load-store-all-sizes) -> load-store-all-sizes;

tests/codegen/multi-return.wit

@@ -5,7 +5,7 @@ interface multi-return {
   mrb: func() -> ();
   mrc: func() -> u32;
   mrd: func() -> (a: u32);
-  mre: func() -> (a: u32, b: float32);
+  mre: func() -> (a: u32, b: f32);
 }
 
 world the-world {

tests/codegen/resources.wit

@@ -2,7 +2,7 @@ package my:resources;
 
 interface types {
   resource z {
-    constructor(a: float64);
+    constructor(a: f64);
   }
 }
 
@@ -38,19 +38,19 @@ world resources {
 
   export exports: interface {
     resource x {
-      constructor(a: float64);
-      get-a: func() -> float64;
-      set-a: func(a: float64);
-      add: static func(x: x, a: float64) -> x;
+      constructor(a: f64);
+      get-a: func() -> f64;
+      set-a: func(a: f64);
+      add: static func(x: x, a: f64) -> x;
     }
   }
 
   import imports: interface {
     resource y {
-      constructor(a: float64);
-      get-a: func() -> float64;
-      set-a: func(a: float64);
-      add: static func(y: y, a: float64) -> y;
+      constructor(a: f64);
+      get-a: func() -> f64;
+      set-a: func(a: f64);
+      add: static func(y: y, a: f64) -> y;
     }
   }
 }