[help] Get return types?

[pfortini]

I have the following functions on index.ts file:

export function str(): string {
  return "string";
}

export function n32(): i32 {
  return 1
}


export function r32(): f32 {
  return 1.2;
}

export function aStr(): Array<String> {
  return ["a", "b"];
}

export function aN(): Array<i32> {
  return [1, 2];
}

export function aR(): Array<f32> {
  return [1.1, 2.2];
}

export function truth(): bool {
  return true;
}

and I'd like to be able to tell, from my code on Go, what is the return type of the called function. My function on Go looks like this:

func runCode(funcName string) {
	raw, err := ioutil.ReadFile("optimized.wasm")
	if err != nil {
		fmt.Println(err)
	}

	r := new(Resolver)
	vm, err := exec.NewVirtualMachine(raw, exec.VMConfig{}, r, nil)
	if err != nil {
		return
	}

	entryID, ok := vm.GetFunctionExport(funcName)
	if !ok {
		fmt.Println("function not found")
	}

	ret, err := vm.Run(entryID)
	if err != nil {
		vm.PrintStackTrace()
		fmt.Println(err)
	}

	fmt.Println("return:", ret)
}

The problem I'm facing is that ret is sometimes a memory position, sometimes an int32, sometimes a big number (float on IEEE 754 representation). Is there any way to dynamically tell what am I going to receive, so I can properly read it from memory?

[willemneal]

I found a similar problem when passing references around in Javascript. The issue is that from the wasm side of things there are no Reference types so everything is just an int or a float. One way to solve this is to use the function to encode the type, which it seems you already are. I had an edited version of the compiler that did this automatically and edited the loader to wrap and unwrap values passed back and forth.

Now, however, each instance of a class get's a classID, which you read at runtime to dynamically determine what type it is. The hard part is that this only really works well on the AssemblyScript side as you would need to know what the classID's are, which again could be encoded in the binary.

Might I ask, what your use case is with Go?

[pfortini]

I'm running a server-side application that allows the user to run its own code compiled to wasm on a virtual machine, and the results of each execution are stored within the server's database. So it is important to correctly read the result from the memory.

[willemneal]

In as-pect, we use a generic printing function, which determines the type of the value being exported and then calls the appropriate

function log<T>(value: T): void {
  if (ignoreLogs) return;
  if (isReference<T>()) {
    if (value == null) {
      logNull();
    } else if (value instanceof ArrayBufferView) {
      logArray(value);
    } else if (value instanceof String) {
      // @ts-ignore: this cast is valid because it's already a string
      logString(<string>value);
    } else if (value instanceof ArrayBuffer) {
      let buff = changetype<ArrayBuffer>(changetype<usize>(value));
      logReference(buff, buff.byteLength);
    } else {
      logReference(value, offsetof<T>());
    }
  } else {
    if (isFloat<T>()) {
      // @ts-ignore: this cast is valid because it's already a float
      logFloat(<f64>value, true);
    } else if (value instanceof bool) {
      logBool(i32(value));
    } else if (value instanceof i64 || value instanceof u64) {
      let box = new Box<T>(value);
      logLong(changetype<usize>(box), value instanceof i64);
    } else {
      logInteger(
        // @ts-ignore: this cast is valid because it's already an integer
        <i32>value,
        value instanceof i32 // determine if the value is unsigned
        || value instanceof i16
        || value instanceof i8,
      );
    }
  }
}

Here each specialized log function is a imported function:
e.g. declare function logBool(b: bool): void;

In your use case, however, you can use something similar to signal to the outside runtime, what the type of the thing being returned is, e.g.

function ret<T>(value: T): T {
  if (isReference<T>()) {
      returningReference();
....
 return value;
}

Then users must add ret to what they return.

export function str(): string {
  return ret("string");
}

This is certainly not the best solution, but I hope it helps. The root of this issue is that wasm only has integer and floats that can be passed back and forth. Soon WebAssembly will have reference types, which will help in situations like this.

Also one thing to note about references passed by assemblyscript, the memory internally is addressed by bytes, so if you want to read values from an Uint32 view of the instance's memory, you need to shift right 2.

[pfortini]

Thanks! this gave me some nice ideas I think will work nicely. Closing issue for now

[jtenner]

@pfortini I was throwing around the idea (in my head) of a macro that obtained the return type of a function.

if (isFunction<T>()) {
  let result: returnof<T> = call_indirect(func, ...params); // rest is obviously not supported
}

I doubt this kind of thing would fly by @dcodeIO since we want to reduce the number of builtins that come baked into the compiler, but I think I could have uses for it in my testing framework.

We might also like to implement isVoid<returnof<T>>() which might be helpful too.

Does anyone here have any thoughts/objections to this idea?

[jtenner]

Ah. Even better. There's already a TypeScript macro that does this.

See: microsoft/TypeScript#21847

type A = ReturnType<T>;