implement phony assignment

src/front/wgsl/lexer.rs

@@ -544,6 +544,9 @@ impl<'a> Lexer<'a> {
 
  pub(super) fn next_ident_with_span(&mut self) -> Result<(&'a str, Span), Error<'a>> {
  match self.next() {
+ (Token::Word(word), span) if word == "_" => {
+ Err(Error::InvalidIdentifierUnderscore(span))
+ }
  (Token::Word(word), span) if word.starts_with("__") => {
  Err(Error::ReservedIdentifierPrefix(span))
  }

src/front/wgsl/mod.rs

@@ -147,6 +147,7 @@ pub enum Error<'a> {
  InvalidForInitializer(Span),
  InvalidGatherComponent(Span, i32),
  InvalidConstructorComponentType(Span, i32),
+ InvalidIdentifierUnderscore(Span),
  ReservedIdentifierPrefix(Span),
  UnknownAddressSpace(Span),
  UnknownAttribute(Span),
@@ -362,6 +363,11 @@ impl<'a> Error<'a> {
  labels: vec![(bad_span.clone(), "invalid component type".into())],
  notes: vec![],
  },
+ Error::InvalidIdentifierUnderscore(ref bad_span) => ParseError {
+ message: "Identifier can't be '_'".to_string(),
+ labels: vec![(bad_span.clone(), "invalid identifier".into())],
+ notes: vec!["Use phony assignment instead ('_ =' notice the absence of 'let' or 'var')".to_string()],
+ },
  Error::ReservedIdentifierPrefix(ref bad_span) => ParseError {
  message: format!("Identifier starts with a reserved prefix: '{}'", &source[bad_span.clone()]),
  labels: vec![(bad_span.clone(), "invalid identifier".into())],
@@ -3489,6 +3495,21 @@ impl Parser {
  (Token::Word(word), _) => {
  let mut emitter = super::Emitter::default();
  let statement = match word {
+ "_" => {
+ let _ = lexer.next();
+ emitter.start(context.expressions);
+ lexer.expect(Token::Operation('='))?;
+ let expr_id = self.parse_general_expression(
+ lexer,
+ context.as_expression(block, &mut emitter),
+ )?;
+ lexer.expect(Token::Separator(';'))?;
+ block.extend(emitter.finish(context.expressions));
+ // TODO: the situation here could be improved but
+ // for now this is necessary to get the expressions emitted
+ context.named_expressions.insert(expr_id, "_".to_string());
+ None
+ }
  "let" => {
  let _ = lexer.next();
  emitter.start(context.expressions);

tests/in/access.wgsl

@@ -28,13 +28,13 @@ fn test_matrix_within_struct_accesses() {
  idx--;
 
  // loads
- var _ = baz.m;
- var _ = baz.m[0];
- var _ = baz.m[idx];
- var _ = baz.m[0][1];
- var _ = baz.m[0][idx];
- var _ = baz.m[idx][1];
- var _ = baz.m[idx][idx];
+ _ = baz.m;
+ _ = baz.m[0];
+ _ = baz.m[idx];
+ _ = baz.m[0][1];
+ _ = baz.m[0][idx];
+ _ = baz.m[idx][1];
+ _ = baz.m[idx][idx];
 
  var t = Baz(mat3x2<f32>(vec2<f32>(1.0), vec2<f32>(2.0), vec2<f32>(3.0)));
 
@@ -83,7 +83,7 @@ fn foo_vert(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4<f32> {
  c[vi + 1u] = 42;
  let value = c[vi];
 
- var _ = test_arr_as_arg(array<array<f32, 10>, 5>());
+ _ = test_arr_as_arg(array<array<f32, 10>, 5>());
 
  return vec4<f32>(_matrix * vec4<f32>(vec4<i32>(value)), 2.0);
 }

tests/in/globals.wgsl

@@ -39,17 +39,17 @@ fn test_msl_packed_vec3() {
  let data = alignment;
 
  // loads
- let _ = data.v3;
- let _ = data.v3.zx;
+ _ = data.v3;
+ _ = data.v3.zx;
  test_msl_packed_vec3_as_arg(data.v3);
 
  // matrix vector multiplication
- let _ = data.v3 * mat3x3<f32>();
- let _ = mat3x3<f32>() * data.v3;
+ _ = data.v3 * mat3x3<f32>();
+ _ = mat3x3<f32>() * data.v3;
 
  // scalar vector multiplication
- let _ = data.v3 * 2.0;
- let _ = 2.0 * data.v3;
+ _ = data.v3 * 2.0;
+ _ = 2.0 * data.v3;
 }
 
 @compute @workgroup_size(1)