diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs index a764191e0..f8e2744de 100644 --- a/naga/src/front/wgsl/lower/mod.rs +++ b/naga/src/front/wgsl/lower/mod.rs @@ -912,6 +912,45 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> { fn ensure_type_exists(&mut self, inner: ir::TypeInner) -> Handle { self.as_global().ensure_type_exists(None, inner) } + + fn enumerant( + &self, + expr: Handle>, + ) -> Result<'source, (&'source str, Span)> { + let span = self.ast_expressions.get_span(expr); + let expr = &self.ast_expressions[expr]; + + match *expr { + ast::Expression::Ident(ast::TemplateElaboratedIdent { + ident: ast::IdentExpr::Local(_), + .. + }) => Err(Box::new(Error::UnexpectedIdentForEnumerant(span))), + ast::Expression::Ident(ast::TemplateElaboratedIdent { + ident: ast::IdentExpr::Unresolved(name), + .. + }) => { + if self.globals.get(name).is_some() { + Err(Box::new(Error::UnexpectedIdentForEnumerant(span))) + } else { + Ok((name, span)) + } + } + _ => Err(Box::new(Error::UnexpectedExprForEnumerant(span))), + } + } + + fn var_address_space( + &self, + template_list: &[Handle>], + ) -> Result<'source, ir::AddressSpace> { + let mut tl = TemplateListIter::new(Span::UNDEFINED, template_list); + let mut address_space = tl.maybe_address_space(self)?; + if let Some(ref mut address_space) = address_space { + tl.maybe_access_mode(address_space, self)?; + } + tl.finish(self)?; + Ok(address_space.unwrap_or(ir::AddressSpace::Handle)) + } } struct ArgumentContext<'ctx, 'source> { @@ -1268,7 +1307,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { None }; - let space = Self::var_address_space(&v.template_list, &ctx.as_const())?; + let space = ctx.as_const().var_address_space(&v.template_list)?; let handle = ctx.module.global_variables.append( ir::GlobalVariable { @@ -2556,45 +2595,6 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { } } - fn enumerant( - expr: Handle>, - ctx: &ExpressionContext<'source, '_, '_>, - ) -> Result<'source, (&'source str, Span)> { - let span = ctx.ast_expressions.get_span(expr); - let expr = &ctx.ast_expressions[expr]; - - match *expr { - ast::Expression::Ident(ast::TemplateElaboratedIdent { - ident: ast::IdentExpr::Local(_), - .. - }) => Err(Box::new(Error::UnexpectedIdentForEnumerant(span))), - ast::Expression::Ident(ast::TemplateElaboratedIdent { - ident: ast::IdentExpr::Unresolved(name), - .. - }) => { - if ctx.globals.get(name).is_some() { - Err(Box::new(Error::UnexpectedIdentForEnumerant(span))) - } else { - Ok((name, span)) - } - } - _ => Err(Box::new(Error::UnexpectedExprForEnumerant(span))), - } - } - - fn var_address_space( - template_list: &[Handle>], - ctx: &ExpressionContext<'source, '_, '_>, - ) -> Result<'source, ir::AddressSpace> { - let mut tl = TemplateListIter::new(Span::UNDEFINED, template_list); - let mut address_space = tl.maybe_address_space(ctx)?; - if let Some(ref mut address_space) = address_space { - tl.maybe_access_mode(address_space, ctx)?; - } - tl.finish(ctx)?; - Ok(address_space.unwrap_or(ir::AddressSpace::Handle)) - } - fn type_expression( &mut self, expr: Handle>, diff --git a/naga/src/front/wgsl/lower/template_list.rs b/naga/src/front/wgsl/lower/template_list.rs index 579660ace..ff6d0e46c 100644 --- a/naga/src/front/wgsl/lower/template_list.rs +++ b/naga/src/front/wgsl/lower/template_list.rs @@ -110,7 +110,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> { ctx: &ExpressionContext<'source, '_, '_>, ) -> Result<'source, ir::AddressSpace> { let expr = self.expect_next("`AS`, an address space")?; - let (enumerant, span) = Lowerer::enumerant(expr, ctx)?; + let (enumerant, span) = ctx.enumerant(expr)?; conv::map_address_space(enumerant, span, &ctx.enable_extensions) } pub fn maybe_address_space( @@ -118,7 +118,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> { ctx: &ExpressionContext<'source, '_, '_>, ) -> Result<'source, Option> { if let Some(expr) = self.template_list.next() { - let (enumerant, span) = Lowerer::enumerant(*expr, ctx)?; + let (enumerant, span) = ctx.enumerant(*expr)?; Ok(Some(conv::map_address_space( enumerant, span, @@ -134,7 +134,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> { ctx: &ExpressionContext<'source, '_, '_>, ) -> Result<'source, ir::StorageAccess> { let expr = self.expect_next("`Access`, an access mode")?; - let (enumerant, span) = Lowerer::enumerant(expr, ctx)?; + let (enumerant, span) = ctx.enumerant(expr)?; conv::map_access_mode(enumerant, span) } pub fn maybe_access_mode( @@ -144,7 +144,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> { ) -> Result<'source, ()> { if let &mut ir::AddressSpace::Storage { ref mut access } = space { if let Some(expr) = self.template_list.next() { - let (enumerant, span) = Lowerer::enumerant(*expr, ctx)?; + let (enumerant, span) = ctx.enumerant(*expr)?; let access_mode = conv::map_access_mode(enumerant, span)?; *access = access_mode; } else { @@ -160,7 +160,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> { ctx: &ExpressionContext<'source, '_, '_>, ) -> Result<'source, ir::StorageFormat> { let expr = self.expect_next("`Format`, a texel format")?; - let (enumerant, span) = Lowerer::enumerant(expr, ctx)?; + let (enumerant, span) = ctx.enumerant(expr)?; conv::map_storage_format(enumerant, span) } @@ -169,7 +169,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> { ctx: &ExpressionContext<'source, '_, '_>, ) -> Result<'source, bool> { if let Some(expr) = self.template_list.next() { - let (enumerant, span) = Lowerer::enumerant(*expr, ctx)?; + let (enumerant, span) = ctx.enumerant(*expr)?; conv::map_ray_flag(&ctx.enable_extensions, enumerant, span)?; Ok(true) } else { @@ -182,7 +182,7 @@ impl<'iter, 'source> TemplateListIter<'iter, 'source> { ctx: &ExpressionContext<'source, '_, '_>, ) -> Result<'source, crate::CooperativeRole> { let role_expr = self.expect_next("`Role`, a cooperative matrix role")?; - let (enumerant, span) = Lowerer::enumerant(role_expr, ctx)?; + let (enumerant, span) = ctx.enumerant(role_expr)?; let role = conv::map_cooperative_role(enumerant, span)?; Ok(role) }