[naga wgsl-in] Allow abstract literals to be used as return values

[jamienicol]

Description

Currently we concretize() return values via calling expression(), meaning this works fine:

fn foo() -> i32 {
    return 1;
}

as we concretize the 1 to an i32, which is the function return type. But this does not:

fn foo() -> f32 {
    return 1;
}

as we concretize the 1 to an i32, which does not match the f32 return type.

We can fix this by calling expression_for_abstract() which does not concretize, then calling try_automatic_conversions() to attempt to convert the abstract type to the return type.

Testing
Added some snapshot tests

Checklist

• Run cargo fmt.
• Run cargo clippy. If applicable, add:
• Run cargo xtask test to run tests.
• Add change to CHANGELOG.md. See simple instructions inside file.

[jamienicol]

@jimblandy I'm avoiding calling try_automatic_conversions() here for non-abstract types, as otherwise I saw in one of the tests that this code:

@group(0) @binding(0)
var<storage> atom: atomic<u32>;

fn return_atomic() -> atomic<u32> {
  return atom;
}

used to fail with this error:

  ┌─ in.wgsl:4:1
  │
4 │ ╭ fn return_atomic() -> atomic<u32> {
5 │ │   return atom;
  │ ╰──────────────^ naga::Function [0]
  │
  = The function's given return type cannot be returned from functions

but would now fail with:

Could not parse WGSL:
error: automatic conversions cannot convert `u32` to `atomic<u32>`
  ┌─ in.wgsl:4:10
  │
4 │   return atom;
  │          ^^^^ this expression has type u32

which is less clear.

Would it make sense to have this check as part of try_automatic_conversions()? Do we ever convert from things that are not abstract?