Add more codegen UI tests; update existing ones

Author: sd2k

cmd/gravity/tests/cmd/basic.stdout

@@ -36,22 +36,29 @@ func NewExampleFactory(
 ) (*ExampleFactory, error) {
 	wazeroRuntime := wazero.NewRuntime(ctx)
 
+	// Instantiate import host modules
 	_, err0 := wazeroRuntime.NewHostModuleBuilder("arcjet:example/runtime").
 	NewFunctionBuilder().
 	WithFunc(func(
 		ctx context.Context,
 		mod api.Module,
 		arg0 uint32,
 	) {
+		// CallInterface { func: Function { name: "os", kind: Freestanding, params: [], result: Some(String), docs: Docs { contents: None }, stability: Unknown }, async_: false }
 		value0 := runtime.Os(ctx, )
+		// GetArg { nth: 0 }
+		// StringLower { realloc: Some("cabi_realloc") }
 		memory1 := mod.Memory()
 		realloc1 := mod.ExportedFunction("cabi_realloc")
 		ptr1, len1, err1 := writeString(ctx, value0, memory1, realloc1)
 		if err1 != nil {
 			panic(err1)
 		}
-		mod.Memory().WriteUint32Le(arg0+4, uint32(len1))
-		mod.Memory().WriteUint32Le(arg0+0, uint32(ptr1))
+		// LengthStore { offset: ptrsz }
+		mod.Memory().WriteUint32Le(uint32(arg0+4), uint32(len1))
+		// PointerStore { offset: 0 }
+		mod.Memory().WriteUint32Le(uint32(arg0+0), uint32(ptr1))
+		// Return { amt: 0, func: Function { name: "os", kind: Freestanding, params: [], result: Some(String), docs: Docs { contents: None }, stability: Unknown } }
 	}).
 	Export("os").
 	NewFunctionBuilder().
@@ -60,15 +67,21 @@ func NewExampleFactory(
 		mod api.Module,
 		arg0 uint32,
 	) {
+		// CallInterface { func: Function { name: "arch", kind: Freestanding, params: [], result: Some(String), docs: Docs { contents: None }, stability: Unknown }, async_: false }
 		value0 := runtime.Arch(ctx, )
+		// GetArg { nth: 0 }
+		// StringLower { realloc: Some("cabi_realloc") }
 		memory1 := mod.Memory()
 		realloc1 := mod.ExportedFunction("cabi_realloc")
 		ptr1, len1, err1 := writeString(ctx, value0, memory1, realloc1)
 		if err1 != nil {
 			panic(err1)
 		}
-		mod.Memory().WriteUint32Le(arg0+4, uint32(len1))
-		mod.Memory().WriteUint32Le(arg0+0, uint32(ptr1))
+		// LengthStore { offset: ptrsz }
+		mod.Memory().WriteUint32Le(uint32(arg0+4), uint32(len1))
+		// PointerStore { offset: 0 }
+		mod.Memory().WriteUint32Le(uint32(arg0+0), uint32(ptr1))
+		// Return { amt: 0, func: Function { name: "arch", kind: Freestanding, params: [], result: Some(String), docs: Docs { contents: None }, stability: Unknown } }
 	}).
 	Export("arch").
 	NewFunctionBuilder().
@@ -78,12 +91,17 @@ func NewExampleFactory(
 		arg0 uint32,
 		arg1 uint32,
 	) {
+		// GetArg { nth: 0 }
+		// GetArg { nth: 1 }
+		// StringLift
 		buf0, ok0 := mod.Memory().Read(arg0, arg1)
 		if !ok0 {
 			panic(errors.New("failed to read bytes from memory"))
 		}
 		str0 := string(buf0)
+		// CallInterface { func: Function { name: "puts", kind: Freestanding, params: [("msg", String)], result: None, docs: Docs { contents: None }, stability: Unknown }, async_: false }
 		runtime.Puts(ctx, str0)
+		// Return { amt: 0, func: Function { name: "puts", kind: Freestanding, params: [("msg", String)], result: None, docs: Docs { contents: None }, stability: Unknown } }
 	}).
 	Export("puts").
 	Instantiate(ctx)
@@ -154,6 +172,7 @@ func writeString(
 func (i *ExampleInstance) Hello(
 	ctx context.Context,
 ) (string, error) {
+	// CallWasm { name: "hello", sig: WasmSignature { params: [], results: [Pointer], indirect_params: false, retptr: true } }
 	raw0, err0 := i.module.ExportedFunction("hello").Call(ctx, )
 	if err0 != nil {
 		var default0 string
@@ -173,25 +192,30 @@ func (i *ExampleInstance) Hello(
 	}()
 
 	results0 := raw0[0]
+	// I32Load8U { offset: 0 }
 	value1, ok1 := i.module.Memory().ReadByte(uint32(results0 + 0))
 	if !ok1 {
 		var default1 string
 		return default1, errors.New("failed to read byte from memory")
 	}
+	// ResultLift { result: Result_ { ok: Some(String), err: Some(String) }, ty: Id { idx: 0 } }
 	var value8 string
 	var err8 error
 	switch value1 {
 	case 0:
+		// PointerLoad { offset: ptrsz }
 		ptr2, ok2 := i.module.Memory().ReadUint32Le(uint32(results0 + 4))
 		if !ok2 {
 			var default2 string
 			return default2, errors.New("failed to read pointer from memory")
 		}
+		// LengthLoad { offset: (2*ptrsz) }
 		len3, ok3 := i.module.Memory().ReadUint32Le(uint32(results0 + 8))
 		if !ok3 {
 			var default3 string
 			return default3, errors.New("failed to read length from memory")
 		}
+		// StringLift
 		buf4, ok4 := i.module.Memory().Read(ptr2, len3)
 		if !ok4 {
 			var default4 string
@@ -200,16 +224,19 @@ func (i *ExampleInstance) Hello(
 		str4 := string(buf4)
 		value8 = str4
 	case 1:
+		// PointerLoad { offset: ptrsz }
 		ptr5, ok5 := i.module.Memory().ReadUint32Le(uint32(results0 + 4))
 		if !ok5 {
 			var default5 string
 			return default5, errors.New("failed to read pointer from memory")
 		}
+		// LengthLoad { offset: (2*ptrsz) }
 		len6, ok6 := i.module.Memory().ReadUint32Le(uint32(results0 + 8))
 		if !ok6 {
 			var default6 string
 			return default6, errors.New("failed to read length from memory")
 		}
+		// StringLift
 		buf7, ok7 := i.module.Memory().Read(ptr5, len6)
 		if !ok7 {
 			var default7 string
@@ -220,6 +247,8 @@ func (i *ExampleInstance) Hello(
 	default:
 		err8 = errors.New("invalid variant discriminant for expected")
 	}
+	// Flush { amt: 1 }
+	// Return { amt: 1, func: Function { name: "hello", kind: Freestanding, params: [], result: Some(Id(Id { idx: 0 })), docs: Docs { contents: None }, stability: Unknown } }
 	return value8, err8
 }
 

cmd/gravity/tests/cmd/iface-method-returns-string.stdout

@@ -22,6 +22,8 @@ func NewInstructionsFactory(
 ) (*InstructionsFactory, error) {
 	wazeroRuntime := wazero.NewRuntime(ctx)
 
+	// Instantiate import host modules
+
 	// Compiling the module takes a LONG time, so we want to do it once and hold
 	// onto it with the Runtime
 	module, err := wazeroRuntime.CompileModule(ctx, wasmFileInstructions)
@@ -87,15 +89,20 @@ func (i *InstructionsInstance) S8Roundtrip(
 	val int8,
 ) int8 {
 	arg0 := val
+	// GetArg { nth: 0 }
+	// I32FromS8
 	value0 := api.EncodeI32(int32(arg0))
+	// CallWasm { name: "s8-roundtrip", sig: WasmSignature { params: [I32], results: [I32], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("s8-roundtrip").Call(ctx, uint64(value0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
+	// S8FromI32
 	result2 := int8(api.DecodeI32(results1))
+	// Return { amt: 1, func: Function { name: "s8-roundtrip", kind: Freestanding, params: [("val", S8)], result: Some(S8), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }
 
@@ -104,15 +111,20 @@ func (i *InstructionsInstance) U8Roundtrip(
 	val uint8,
 ) uint8 {
 	arg0 := val
+	// GetArg { nth: 0 }
+	// I32FromU8
 	value0 := api.EncodeI32(int32(arg0))
+	// CallWasm { name: "u8-roundtrip", sig: WasmSignature { params: [I32], results: [I32], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("u8-roundtrip").Call(ctx, uint64(value0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
+	// U8FromI32
 	result2 := uint8(api.DecodeU32(results1))
+	// Return { amt: 1, func: Function { name: "u8-roundtrip", kind: Freestanding, params: [("val", U8)], result: Some(U8), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }
 
@@ -121,15 +133,20 @@ func (i *InstructionsInstance) S16Roundtrip(
 	val int16,
 ) int16 {
 	arg0 := val
+	// GetArg { nth: 0 }
+	// I32FromS16
 	value0 := api.EncodeI32(int32(arg0))
+	// CallWasm { name: "s16-roundtrip", sig: WasmSignature { params: [I32], results: [I32], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("s16-roundtrip").Call(ctx, uint64(value0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
+	// S16FromI32
 	result2 := int16(api.DecodeI32(results1))
+	// Return { amt: 1, func: Function { name: "s16-roundtrip", kind: Freestanding, params: [("val", S16)], result: Some(S16), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }
 
@@ -138,15 +155,20 @@ func (i *InstructionsInstance) U16Roundtrip(
 	val uint16,
 ) uint16 {
 	arg0 := val
+	// GetArg { nth: 0 }
+	// I32FromU16
 	value0 := api.EncodeI32(int32(arg0))
+	// CallWasm { name: "u16-roundtrip", sig: WasmSignature { params: [I32], results: [I32], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("u16-roundtrip").Call(ctx, uint64(value0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
+	// U16FromI32
 	result2 := uint16(api.DecodeU32(results1))
+	// Return { amt: 1, func: Function { name: "u16-roundtrip", kind: Freestanding, params: [("val", U16)], result: Some(U16), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }
 
@@ -155,15 +177,20 @@ func (i *InstructionsInstance) S32Roundtrip(
 	val int32,
 ) int32 {
 	arg0 := val
+	// GetArg { nth: 0 }
+	// I32FromS32
 	value0 := api.EncodeI32(arg0)
+	// CallWasm { name: "s32-roundtrip", sig: WasmSignature { params: [I32], results: [I32], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("s32-roundtrip").Call(ctx, uint64(value0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
+	// S32FromI32
 	result2 := api.DecodeI32(results1)
+	// Return { amt: 1, func: Function { name: "s32-roundtrip", kind: Freestanding, params: [("val", S32)], result: Some(S32), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }
 
@@ -172,15 +199,20 @@ func (i *InstructionsInstance) U32Roundtrip(
 	val uint32,
 ) uint32 {
 	arg0 := val
+	// GetArg { nth: 0 }
+	// I32FromU32
 	result0 := api.EncodeU32(arg0)
+	// CallWasm { name: "u32-roundtrip", sig: WasmSignature { params: [I32], results: [I32], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("u32-roundtrip").Call(ctx, uint64(result0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
-	result2 := api.DecodeU32(results1)
+	// U32FromI32
+	result2 := api.DecodeU32(uint64(results1))
+	// Return { amt: 1, func: Function { name: "u32-roundtrip", kind: Freestanding, params: [("val", U32)], result: Some(U32), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }
 
@@ -189,15 +221,20 @@ func (i *InstructionsInstance) F32Roundtrip(
 	val float32,
 ) float32 {
 	arg0 := val
-	result0 := api.EncodeF32(arg0)
+	// GetArg { nth: 0 }
+	// CoreF32FromF32
+	result0 := api.EncodeF32(float32(arg0))
+	// CallWasm { name: "f32-roundtrip", sig: WasmSignature { params: [F32], results: [F32], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("f32-roundtrip").Call(ctx, uint64(result0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
+	// F32FromCoreF32
 	result2 := api.DecodeF32(results1)
+	// Return { amt: 1, func: Function { name: "f32-roundtrip", kind: Freestanding, params: [("val", F32)], result: Some(F32), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }
 
@@ -206,15 +243,20 @@ func (i *InstructionsInstance) F64Roundtrip(
 	val float64,
 ) float64 {
 	arg0 := val
-	result0 := api.EncodeF64(arg0)
+	// GetArg { nth: 0 }
+	// CoreF64FromF64
+	result0 := api.EncodeF64(float64(arg0))
+	// CallWasm { name: "f64-roundtrip", sig: WasmSignature { params: [F64], results: [F64], indirect_params: false, retptr: false } }
 	raw1, err1 := i.module.ExportedFunction("f64-roundtrip").Call(ctx, uint64(result0))
 	// The return type doesn't contain an error so we panic if one is encountered
 	if err1 != nil {
 		panic(err1)
 	}
 
 	results1 := raw1[0]
+	// F64FromCoreF64
 	result2 := api.DecodeF64(results1)
+	// Return { amt: 1, func: Function { name: "f64-roundtrip", kind: Freestanding, params: [("val", F64)], result: Some(F64), docs: Docs { contents: None }, stability: Unknown } }
 	return result2
 }