Simplifications and improvements to WGSL syntax

[lain-dono]

0. Remove trailing ; for struct declaration. Current syntax is awful.

struct Data {
    a: i32;
    b: vec<f32>;
}                  🠔 no semicolon here!

1. Remove parentheses from if, switch, etc. Example:

if alpha < 0.5 {
    discard;
}

2. Use separate syntax for struct, block, uniform, etc. Examples:

struct Data {
    a: i32;
    b: vec<f32>;
}

block Data {
    a: i32;
    b: vec<f32>;
}

uniform viewport: Viewport {
    size: vec2<f32>;
    ivn_size: vec2<f32>;
}

3. Remove : from variable, struct members and function arguments declaration. Examples:

var foo f32 = 1.234;

struct Data {
    a i32            🠔 makes sense without semicolon here
    a vec<f32>       after all, there is an end-of-line character
}

fn foo(a f32, b f32) -> bool { .. }
fn foo(a, b f32) -> bool { .. }        🠔 optional variant

4. Remove -> from function declaration (between args and body): fn foo(a: f32, b: f32) bool { .. }.
5. In addition to simd-types from vec4<f32> is too hard to type on the keyboard #736. New syntax for arrays and pointers:

[f32]         🠔 array without size
[f32; 4]      🠔 array with size
[[f32; 3]; 4] 🠔 nested array

*f32          🠔 without storage class
*private f32  🠔 with storage class

6. To eliminate ambiguity with (5) a new syntax for attributes:

#[location(0), input, read_only] var position f32x4;    🠔 use attributes instead of pseudo-generics

#[group(2), binding(0)]
uniform viewport Viewport {
    size     f32x2
    ivn_size f32x2
}

7. In addition to (3) it is possible to make ; optional.

var foo i32 = 42
foo = 3 * 7

[kvark]

There is a number of suggestions mixed up here. Please separate them carefully, so that we can avoid mixing them.
Note that at this point we are hesitant to change the language too much, so a strong motivation is needed.

[kvark]

Thank you!
I find (0) and (1) worth discussing, but maybe not the rest.

[dj2]

For both 0 and 1, they can be done after MVP so don't think they need time discussing now. In both cases, either way is valid so it's just a subjective choice of which you prefer.

[kainino0x]

Agree 0 and 1 could be worth consideration, but could also wait.

5.1. is #854 which is still under discussion, but I support the rust-like syntax IF we introduce a bracket syntax.

5.2. I don't particularly like because pointer type syntax can be VERY confusing (like in C) - though since we (currently) can't have double-pointers the problem is mitigated. I don't think pointers will be so common that ptr<> is a big pain point.

7. makes the language newline-sensitive. Pretty sure it currently is not. (except for //)

The rest I personally wouldn't change.

[RobinMorisset]

I like 0 and 1, and dislike 7 (as it makes the language newline-sensitive while it is not currently). I don't have a strong opinion on the rest currently.

[kdashg]

Thanks for the feedback!
Please file new issues for any part where you'd like more discussion!