github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

[wgsl-in] Store expression position in context

Browse Source
This commit is contained in:
João Capucho
2021-08-18 21:24:01 +01:00
committed by Dzmitry Malyshau
parent 02142d0980
commit f14817e8a0
1 changed files with 78 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
src/front/wgsl/mod.rs
View File

@@ -668,6 +668,7 @@ impl<'a, 'temp> StatementContext<'a, 'temp, '_> {
arguments: self.arguments,
block,
emitter,
rhs: true,
}
}
}
@@ -689,6 +690,9 @@ struct ExpressionContext<'input, 'temp, 'out> {
functions: &'out Arena<crate::Function>,
block: &'temp mut crate::Block,
emitter: &'temp mut super::Emitter,
/// Wether or not the current expression is in the right hand side of an
/// assignemnt statement or equivalent
rhs: bool,
}
impl<'a> ExpressionContext<'a, '_, '_> {
@@ -705,9 +709,22 @@ impl<'a> ExpressionContext<'a, '_, '_> {
arguments: self.arguments,
block: self.block,
emitter: self.emitter,
rhs: self.rhs,
}
}
fn reborrow_rhs(&mut self) -> ExpressionContext<'a, '_, '_> {
let mut reborrow = self.reborrow();
reborrow.rhs = true;
reborrow
}
fn reborrow_lhs(&mut self) -> ExpressionContext<'a, '_, '_> {
let mut reborrow = self.reborrow();
reborrow.rhs = false;
reborrow
}
fn resolve_type(
&mut self,
handle: Handle<crate::Expression>,
@@ -1055,15 +1072,6 @@ impl std::error::Error for ParseError {
}
}
/// The expression position in a assignment statement
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum ExprPosition {
/// The expression is in the left hand side of the assignment
Lhs,
/// The expression is in the right hand side of the assignment
Rhs,
}
pub struct Parser {
scopes: Vec<(Scope, usize)>,
lookup_type: FastHashMap<String, Handle<crate::Type>>,
@@ -1133,9 +1141,8 @@ impl Parser {
lexer: &mut Lexer<'a>,
mut ctx: ExpressionContext<'a, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'a>> {
let (pointer, pointer_span) = lexer.capture_span(|lexer| {
self.parse_singular_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)
})?;
let (pointer, pointer_span) =
lexer.capture_span(|lexer| self.parse_singular_expression(lexer, ctx.reborrow()))?;
// Check if the pointer expression is to an atomic.
// The IR uses regular `Expression::Load` and `Statement::Store` for atomic load/stores,
// and it will not catch the use of a non-atomic variable here.
@@ -1177,7 +1184,7 @@ impl Parser {
if !arguments.is_empty() {
lexer.expect(Token::Separator(','))?;
}
let arg = self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let arg = self.parse_general_expression(lexer, ctx.reborrow())?;
arguments.push(arg);
}
lexer.close_arguments()?;
@@ -1191,12 +1198,11 @@ impl Parser {
mut ctx: ExpressionContext<'a, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'a>> {
lexer.open_arguments()?;
let pointer = self.parse_singular_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let pointer = self.parse_singular_expression(lexer, ctx.reborrow())?;
lexer.expect(Token::Separator(','))?;
let ctx_span = ctx.reborrow();
let (value, value_span) = lexer.capture_span(|lexer| {
self.parse_singular_expression(lexer, ctx_span, ExprPosition::Rhs)
})?;
let (value, value_span) =
lexer.capture_span(|lexer| self.parse_singular_expression(lexer, ctx_span))?;
lexer.close_arguments()?;
let expression = match *ctx.resolve_type(value)? {
@@ -1233,30 +1239,29 @@ impl Parser {
let expr = if let Some(fun) = conv::map_relational_fun(name) {
let _ = lexer.next();
lexer.open_arguments()?;
let argument =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let argument = self.parse_general_expression(lexer, ctx.reborrow())?;
lexer.close_arguments()?;
crate::Expression::Relational { fun, argument }
} else if let Some(axis) = conv::map_derivative_axis(name) {
let _ = lexer.next();
lexer.open_arguments()?;
let expr = self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let expr = self.parse_general_expression(lexer, ctx.reborrow())?;
lexer.close_arguments()?;
crate::Expression::Derivative { axis, expr }
} else if let Some(fun) = conv::map_standard_fun(name) {
let _ = lexer.next();
lexer.open_arguments()?;
let arg_count = fun.argument_count();
let arg = self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let arg = self.parse_general_expression(lexer, ctx.reborrow())?;
let arg1 = if arg_count > 1 {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
let arg2 = if arg_count > 2 {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
@@ -1272,14 +1277,11 @@ impl Parser {
"select" => {
let _ = lexer.next();
lexer.open_arguments()?;
let reject =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let reject = self.parse_general_expression(lexer, ctx.reborrow())?;
lexer.expect(Token::Separator(','))?;
let accept =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let accept = self.parse_general_expression(lexer, ctx.reborrow())?;
lexer.expect(Token::Separator(','))?;
let condition =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let condition = self.parse_general_expression(lexer, ctx.reborrow())?;
lexer.close_arguments()?;
crate::Expression::Select {
condition,
@@ -1290,8 +1292,7 @@ impl Parser {
"arrayLength" => {
let _ = lexer.next();
lexer.open_arguments()?;
let array =
self.parse_singular_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let array = self.parse_singular_expression(lexer, ctx.reborrow())?;
lexer.close_arguments()?;
crate::Expression::ArrayLength(array)
}
@@ -1363,14 +1364,12 @@ impl Parser {
"atomicCompareExchangeWeak" => {
let _ = lexer.next();
lexer.open_arguments()?;
let pointer =
self.parse_singular_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let pointer = self.parse_singular_expression(lexer, ctx.reborrow())?;
lexer.expect(Token::Separator(','))?;
let cmp =
self.parse_singular_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let cmp = self.parse_singular_expression(lexer, ctx.reborrow())?;
lexer.expect(Token::Separator(','))?;
let (value, value_span) = lexer.capture_span(|lexer| {
self.parse_singular_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)
self.parse_singular_expression(lexer, ctx.reborrow())
})?;
lexer.close_arguments()?;
@@ -1407,16 +1406,11 @@ impl Parser {
lexer.expect(Token::Separator(','))?;
let (sampler_name, sampler_span) = lexer.next_ident_with_span()?;
lexer.expect(Token::Separator(','))?;
let coordinate =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, ctx.reborrow())?;
let sc = ctx.prepare_sampling(image_name, image_span)?;
let array_index = if sc.arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
@@ -1443,22 +1437,16 @@ impl Parser {
lexer.expect(Token::Separator(','))?;
let (sampler_name, sampler_span) = lexer.next_ident_with_span()?;
lexer.expect(Token::Separator(','))?;
let coordinate =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, ctx.reborrow())?;
let sc = ctx.prepare_sampling(image_name, image_span)?;
let array_index = if sc.arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
lexer.expect(Token::Separator(','))?;
let level =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let level = self.parse_general_expression(lexer, ctx.reborrow())?;
let offset = if lexer.skip(Token::Separator(',')) {
Some(self.parse_const_expression(lexer, ctx.types, ctx.constants)?)
} else {
@@ -1482,22 +1470,16 @@ impl Parser {
lexer.expect(Token::Separator(','))?;
let (sampler_name, sampler_span) = lexer.next_ident_with_span()?;
lexer.expect(Token::Separator(','))?;
let coordinate =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, ctx.reborrow())?;
let sc = ctx.prepare_sampling(image_name, image_span)?;
let array_index = if sc.arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
lexer.expect(Token::Separator(','))?;
let bias =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let bias = self.parse_general_expression(lexer, ctx.reborrow())?;
let offset = if lexer.skip(Token::Separator(',')) {
Some(self.parse_const_expression(lexer, ctx.types, ctx.constants)?)
} else {
@@ -1521,25 +1503,18 @@ impl Parser {
lexer.expect(Token::Separator(','))?;
let (sampler_name, sampler_span) = lexer.next_ident_with_span()?;
lexer.expect(Token::Separator(','))?;
let coordinate =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, ctx.reborrow())?;
let sc = ctx.prepare_sampling(image_name, image_span)?;
let array_index = if sc.arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
lexer.expect(Token::Separator(','))?;
let x =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let x = self.parse_general_expression(lexer, ctx.reborrow())?;
lexer.expect(Token::Separator(','))?;
let y =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let y = self.parse_general_expression(lexer, ctx.reborrow())?;
let offset = if lexer.skip(Token::Separator(',')) {
Some(self.parse_const_expression(lexer, ctx.types, ctx.constants)?)
} else {
@@ -1563,22 +1538,16 @@ impl Parser {
lexer.expect(Token::Separator(','))?;
let (sampler_name, sampler_span) = lexer.next_ident_with_span()?;
lexer.expect(Token::Separator(','))?;
let coordinate =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, ctx.reborrow())?;
let sc = ctx.prepare_sampling(image_name, image_span)?;
let array_index = if sc.arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
lexer.expect(Token::Separator(','))?;
let reference =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let reference = self.parse_general_expression(lexer, ctx.reborrow())?;
let offset = if lexer.skip(Token::Separator(',')) {
Some(self.parse_const_expression(lexer, ctx.types, ctx.constants)?)
} else {
@@ -1602,22 +1571,16 @@ impl Parser {
lexer.expect(Token::Separator(','))?;
let (sampler_name, sampler_span) = lexer.next_ident_with_span()?;
lexer.expect(Token::Separator(','))?;
let coordinate =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, ctx.reborrow())?;
let sc = ctx.prepare_sampling(image_name, image_span)?;
let array_index = if sc.arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
lexer.expect(Token::Separator(','))?;
let reference =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let reference = self.parse_general_expression(lexer, ctx.reborrow())?;
let offset = if lexer.skip(Token::Separator(',')) {
Some(self.parse_const_expression(lexer, ctx.types, ctx.constants)?)
} else {
@@ -1640,19 +1603,14 @@ impl Parser {
let (image_name, image_span) = lexer.next_ident_with_span()?;
let image = ctx.lookup_ident.lookup(image_name, image_span.clone())?;
lexer.expect(Token::Separator(','))?;
let coordinate =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, ctx.reborrow())?;
let (class, arrayed) = match *ctx.resolve_type(image)? {
crate::TypeInner::Image { class, arrayed, .. } => (class, arrayed),
_ => return Err(Error::BadTexture(image_span)),
};
let array_index = if arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
} else {
None
};
@@ -1661,11 +1619,7 @@ impl Parser {
// it's the MSAA index for multi-sampled, and LOD for the others
crate::ImageClass::Sampled { .. } | crate::ImageClass::Depth { .. } => {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?)
Some(self.parse_general_expression(lexer, ctx.reborrow())?)
}
};
lexer.close_arguments()?;
@@ -1682,11 +1636,7 @@ impl Parser {
let (image_name, image_span) = lexer.next_ident_with_span()?;
let image = ctx.lookup_ident.lookup(image_name, image_span)?;
let level = if lexer.skip(Token::Separator(',')) {
let expr = self.parse_general_expression(
lexer,
ctx.reborrow(),
ExprPosition::Rhs,
)?;
let expr = self.parse_general_expression(lexer, ctx.reborrow())?;
Some(expr)
} else {
None
@@ -1790,13 +1740,11 @@ impl Parser {
let mut components = Vec::new();
let (last_component, arguments_span) = lexer.capture_span(|lexer| {
lexer.open_arguments()?;
let mut last_component =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let mut last_component = self.parse_general_expression(lexer, ctx.reborrow())?;
while lexer.next_argument()? {
components.push(last_component);
last_component =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
last_component = self.parse_general_expression(lexer, ctx.reborrow())?;
}
Ok(last_component)
@@ -1962,14 +1910,13 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
mut ctx: ExpressionContext<'a, '_, '_>,
pos: ExprPosition,
) -> Result<Handle<crate::Expression>, Error<'a>> {
// Will be popped inside match, possibly inside parse_function_call_inner or parse_construction
self.push_scope(Scope::PrimaryExpr, lexer);
let handle = match lexer.peek() {
(Token::Paren('('), _) => {
let _ = lexer.next();
let expr = self.parse_general_expression(lexer, ctx.reborrow(), pos)?;
let expr = self.parse_general_expression(lexer, ctx.reborrow())?;
lexer.expect(Token::Paren(')'))?;
self.pop_scope(lexer);
expr
@@ -1992,14 +1939,14 @@ impl Parser {
self.pop_scope(lexer);
expr
} else if let Some(expr) =
self.parse_function_call_inner(lexer, word, ctx.reborrow())?
self.parse_function_call_inner(lexer, word, ctx.reborrow_rhs())?
{
//TODO: resolve the duplicate call in `parse_singular_expression`
self.pop_scope(lexer);
expr
} else {
let _ = lexer.next();
if let Some(expr) = self.parse_construction(lexer, word, ctx.reborrow())? {
if let Some(expr) = self.parse_construction(lexer, word, ctx.reborrow_rhs())? {
expr
} else {
return Err(Error::UnknownIdent(span, word));
@@ -2100,8 +2047,7 @@ impl Parser {
}
Token::Paren('[') => {
let (_, open_brace_span) = lexer.next();
let index =
self.parse_general_expression(lexer, ctx.reborrow(), ExprPosition::Rhs)?;
let index = self.parse_general_expression(lexer, ctx.reborrow_rhs())?;
let close_brace_span = lexer.expect_span(Token::Paren(']'))?;
if let crate::Expression::Constant(constant) = ctx.expressions[index] {
@@ -2152,7 +2098,6 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
mut ctx: ExpressionContext<'a, '_, '_>,
pos: ExprPosition,
) -> Result<Handle<crate::Expression>, Error<'a>> {
let start = lexer.current_byte_offset();
self.push_scope(Scope::SingularExpr, lexer);
@@ -2162,7 +2107,7 @@ impl Parser {
let _ = lexer.next();
let expr = crate::Expression::Unary {
op: crate::UnaryOperator::Negate,
expr: self.parse_singular_expression(lexer, ctx.reborrow(), pos)?,
expr: self.parse_singular_expression(lexer, ctx.reborrow())?,
};
let span = self.peek_scope(lexer);
(
@@ -2174,7 +2119,7 @@ impl Parser {
let _ = lexer.next();
let expr = crate::Expression::Unary {
op: crate::UnaryOperator::Not,
expr: self.parse_singular_expression(lexer, ctx.reborrow(), pos)?,
expr: self.parse_singular_expression(lexer, ctx.reborrow())?,
};
let span = self.peek_scope(lexer);
(
@@ -2184,27 +2129,27 @@ impl Parser {
}
Token::Operation('*') => {
let _ = lexer.next();
let pointer = self.parse_singular_expression(lexer, ctx.reborrow(), pos)?;
let pointer = self.parse_primary_expression(lexer, ctx.reborrow())?;
let span = self.peek_scope(lexer);
(
false,
match pos {
ExprPosition::Rhs => ctx.expressions.append(
match ctx.rhs {
true => ctx.expressions.append(
crate::Expression::Load { pointer },
NagaSpan::ByteRange(span),
),
ExprPosition::Lhs => pointer,
false => pointer,
},
)
}
Token::Operation('&') => {
let _ = lexer.next();
let handle = self.parse_primary_expression(lexer, ctx.reborrow(), pos)?;
let handle = self.parse_primary_expression(lexer, ctx.reborrow())?;
(false, handle)
}
_ => {
let handle = self.parse_primary_expression(lexer, ctx.reborrow(), pos)?;
(ExprPosition::Rhs == pos, handle)
let handle = self.parse_primary_expression(lexer, ctx.reborrow())?;
(ctx.rhs, handle)
}
};
@@ -2217,7 +2162,6 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
mut context: ExpressionContext<'a, '_, '_>,
pos: ExprPosition,
) -> Result<Handle<crate::Expression>, Error<'a>> {
// equality_expression
context.parse_binary_op(
@@ -2279,7 +2223,7 @@ impl Parser {
_ => None,
},
|lexer, context| {
self.parse_singular_expression(lexer, context, pos)
self.parse_singular_expression(lexer, context)
},
)
},
@@ -2296,7 +2240,6 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
mut context: ExpressionContext<'a, '_, '_>,
pos: ExprPosition,
) -> Result<Handle<crate::Expression>, Error<'a>> {
self.push_scope(Scope::GeneralExpr, lexer);
// logical_or_expression
@@ -2343,7 +2286,7 @@ impl Parser {
_ => None,
},
|lexer, context| {
self.parse_equality_expression(lexer, context, pos)
self.parse_equality_expression(lexer, context)
},
)
},
@@ -2906,10 +2849,9 @@ impl Parser {
) -> Result<(), Error<'a>> {
let span_start = lexer.current_byte_offset();
context.emitter.start(context.expressions);
let pointer =
self.parse_singular_expression(lexer, context.reborrow(), ExprPosition::Lhs)?;
let pointer = self.parse_singular_expression(lexer, context.reborrow_lhs())?;
lexer.expect(Token::Operation('='))?;
let value = self.parse_general_expression(lexer, context.reborrow(), ExprPosition::Rhs)?;
let value = self.parse_general_expression(lexer, context.reborrow())?;
let span_end = lexer.current_byte_offset();
context
.block
@@ -3005,7 +2947,6 @@ impl Parser {
let expr_id = self.parse_general_expression(
lexer,
context.as_expression(block, &mut emitter),
ExprPosition::Rhs,
)?;
lexer.expect(Token::Separator(';'))?;
if let Some(ty) = given_ty {
@@ -3057,7 +2998,6 @@ impl Parser {
let value = self.parse_general_expression(
lexer,
context.as_expression(block, &mut emitter),
ExprPosition::Rhs,
)?;
block.extend(emitter.finish(context.expressions));
@@ -3152,7 +3092,6 @@ impl Parser {
let handle = self.parse_general_expression(
lexer,
context.as_expression(block, &mut emitter),
ExprPosition::Rhs,
)?;
block.extend(emitter.finish(context.expressions));
Some(handle)
@@ -3169,7 +3108,6 @@ impl Parser {
let condition = self.parse_general_expression(
lexer,
context.as_expression(block, &mut emitter),
ExprPosition::Rhs,
)?;
block.extend(emitter.finish(context.expressions));
lexer.expect(Token::Paren(')'))?;
@@ -3185,7 +3123,6 @@ impl Parser {
let other_condition = self.parse_general_expression(
lexer,
context.as_expression(block, &mut sub_emitter),
ExprPosition::Rhs,
)?;
let other_emit = sub_emitter.finish(context.expressions);
lexer.expect(Token::Paren(')'))?;
@@ -3232,7 +3169,6 @@ impl Parser {
let selector = self.parse_general_expression(
lexer,
context.as_expression(block, &mut emitter),
ExprPosition::Rhs,
)?;
lexer.expect(Token::Paren(')'))?;
block.extend(emitter.finish(context.expressions));
@@ -3355,7 +3291,6 @@ impl Parser {
let condition = self.parse_general_expression(
lexer,
context.as_expression(&mut body, &mut emitter),
ExprPosition::Rhs,
)?;
lexer.expect(Token::Separator(';'))?;
body.extend(emitter.finish(context.expressions));
@@ -3432,11 +3367,7 @@ impl Parser {
let pointer =
self.parse_atomic_pointer(lexer, expression_ctx.reborrow())?;
lexer.expect(Token::Separator(','))?;
let value = self.parse_general_expression(
lexer,
expression_ctx,
ExprPosition::Rhs,
)?;
let value = self.parse_general_expression(lexer, expression_ctx)?;
lexer.close_arguments()?;
block.extend(emitter.finish(context.expressions));
Some(crate::Statement::Store { pointer, value })
@@ -3455,14 +3386,12 @@ impl Parser {
crate::TypeInner::Image { arrayed, .. } => arrayed,
_ => return Err(Error::BadTexture(image_span)),
};
let coordinate =
self.parse_general_expression(lexer, expr_context, ExprPosition::Rhs)?;
let coordinate = self.parse_general_expression(lexer, expr_context)?;
let array_index = if arrayed {
lexer.expect(Token::Separator(','))?;
Some(self.parse_general_expression(
lexer,
context.as_expression(block, &mut emitter),
ExprPosition::Rhs,
)?)
} else {
None
@@ -3471,7 +3400,6 @@ impl Parser {
let value = self.parse_general_expression(
lexer,
context.as_expression(block, &mut emitter),
ExprPosition::Rhs,
)?;
lexer.close_arguments()?;
block.extend(emitter.finish(context.expressions));