Skip to main content

naga/front/wgsl/lower/
template_list.rs

1use alloc::{boxed::Box, vec::Vec};
2
3use crate::{
4    front::wgsl::{
5        error::Error,
6        lower::{ExpressionContext, Lowerer, Result},
7        parse::{ast, conv},
8    },
9    ir, Handle, Span,
10};
11
12/// Iterator over a template list.
13///
14/// All functions will attempt to consume an element in the list.
15///
16/// Function variants prefixed with "maybe" will not return an error if there
17/// are no more elements left in the list.
18pub struct TemplateListIter<'iter, 'source> {
19    ident_span: Span,
20    template_list: core::slice::Iter<'iter, Handle<ast::Expression<'source>>>,
21}
22
23impl<'iter, 'source> TemplateListIter<'iter, 'source> {
24    pub fn new(ident_span: Span, template_list: &'iter [Handle<ast::Expression<'source>>]) -> Self {
25        Self {
26            ident_span,
27            template_list: template_list.iter(),
28        }
29    }
30
31    pub fn finish(self, ctx: &ExpressionContext<'source, '_, '_>) -> Result<'source, ()> {
32        let unused_args: Vec<Span> = self
33            .template_list
34            .map(|expr| ctx.ast_expressions.get_span(*expr))
35            .collect();
36        if unused_args.is_empty() {
37            Ok(())
38        } else {
39            Err(Box::new(Error::UnusedArgsForTemplate(unused_args)))
40        }
41    }
42
43    fn expect_next(
44        &mut self,
45        description: &'static str,
46    ) -> Result<'source, Handle<ast::Expression<'source>>> {
47        if let Some(expr) = self.template_list.next() {
48            Ok(*expr)
49        } else {
50            Err(Box::new(Error::MissingTemplateArg {
51                span: self.ident_span,
52                description,
53            }))
54        }
55    }
56
57    pub fn ty(
58        &mut self,
59        lowerer: &mut Lowerer<'source, '_>,
60        ctx: &mut ExpressionContext<'source, '_, '_>,
61    ) -> Result<'source, Handle<ir::Type>> {
62        let expr = self.expect_next("`T`, a type")?;
63        lowerer.type_expression(expr, ctx)
64    }
65
66    /// Lower the next template list element as a type, and return its span.
67    ///
68    /// This returns the span of the template list element. This is generally
69    /// different from the span of the returned `Handle<ir::Type>`, as the
70    /// latter may refer to the type's definition, not its use in the template list.
71    pub fn ty_with_span(
72        &mut self,
73        lowerer: &mut Lowerer<'source, '_>,
74        ctx: &mut ExpressionContext<'source, '_, '_>,
75    ) -> Result<'source, (Handle<ir::Type>, Span)> {
76        let expr = self.expect_next("`T`, a type")?;
77        let span = ctx.ast_expressions.get_span(expr);
78        let ty = lowerer.type_expression(expr, ctx)?;
79        Ok((ty, span))
80    }
81
82    pub fn scalar_ty(
83        &mut self,
84        lowerer: &mut Lowerer<'source, '_>,
85        ctx: &mut ExpressionContext<'source, '_, '_>,
86    ) -> Result<'source, (ir::Scalar, Span)> {
87        let expr = self.expect_next("`T`, a scalar type")?;
88        let ty = lowerer.type_expression(expr, ctx)?;
89        let span = ctx.ast_expressions.get_span(expr);
90        match ctx.module.types[ty].inner {
91            ir::TypeInner::Scalar(scalar) => Ok((scalar, span)),
92            _ => Err(Box::new(Error::UnknownScalarType(span))),
93        }
94    }
95
96    pub fn maybe_array_size(
97        &mut self,
98        lowerer: &mut Lowerer<'source, '_>,
99        ctx: &mut ExpressionContext<'source, '_, '_>,
100    ) -> Result<'source, ir::ArraySize> {
101        if let Some(expr) = self.template_list.next() {
102            lowerer.array_size(*expr, ctx)
103        } else {
104            Ok(ir::ArraySize::Dynamic)
105        }
106    }
107
108    pub fn address_space(
109        &mut self,
110        ctx: &ExpressionContext<'source, '_, '_>,
111    ) -> Result<'source, ir::AddressSpace> {
112        let expr = self.expect_next("`AS`, an address space")?;
113        let (enumerant, span) = ctx.enumerant(expr)?;
114        conv::map_address_space(enumerant, span, &ctx.enable_extensions)
115    }
116
117    pub fn maybe_address_space(
118        &mut self,
119        ctx: &ExpressionContext<'source, '_, '_>,
120    ) -> Result<'source, Option<ir::AddressSpace>> {
121        let Some(expr) = self.template_list.next() else {
122            return Ok(None);
123        };
124
125        let (enumerant, span) = ctx.enumerant(*expr)?;
126        Ok(Some(conv::map_address_space(
127            enumerant,
128            span,
129            &ctx.enable_extensions,
130        )?))
131    }
132
133    pub fn access_mode(
134        &mut self,
135        ctx: &ExpressionContext<'source, '_, '_>,
136    ) -> Result<'source, ir::StorageAccess> {
137        let expr = self.expect_next("`Access`, an access mode")?;
138        let (enumerant, span) = ctx.enumerant(expr)?;
139        conv::map_access_mode(enumerant, span)
140    }
141
142    /// Update `space` with an access mode from `self`, if appropriate.
143    ///
144    /// If `space` is [`Storage`], and there is another template parameter in
145    /// `self`, parse it as a storage mode and mutate `space` accordingly. If
146    /// there are no more template parameters, treat that like `read`.
147    ///
148    /// If `space` is some other address space, don't consume any template
149    /// parameters.
150    ///
151    /// [`Storage`]: ir::AddressSpace::Storage
152    pub fn maybe_access_mode(
153        &mut self,
154        space: &mut ir::AddressSpace,
155        ctx: &ExpressionContext<'source, '_, '_>,
156    ) -> Result<'source, ()> {
157        if let &mut ir::AddressSpace::Storage { ref mut access } = space {
158            if let Some(expr) = self.template_list.next() {
159                let (enumerant, span) = ctx.enumerant(*expr)?;
160                let access_mode = conv::map_access_mode(enumerant, span)?;
161                *access = access_mode;
162            } else {
163                // defaulting to `read`
164                *access = ir::StorageAccess::LOAD
165            }
166        }
167        Ok(())
168    }
169
170    pub fn storage_format(
171        &mut self,
172        ctx: &ExpressionContext<'source, '_, '_>,
173    ) -> Result<'source, ir::StorageFormat> {
174        let expr = self.expect_next("`Format`, a texel format")?;
175        let (enumerant, span) = ctx.enumerant(expr)?;
176        conv::map_storage_format(enumerant, span)
177    }
178
179    pub fn maybe_vertex_return(
180        &mut self,
181        ctx: &ExpressionContext<'source, '_, '_>,
182    ) -> Result<'source, bool> {
183        let Some(expr) = self.template_list.next() else {
184            return Ok(false);
185        };
186
187        let (enumerant, span) = ctx.enumerant(*expr)?;
188        conv::map_ray_flag(&ctx.enable_extensions, enumerant, span)?;
189        Ok(true)
190    }
191
192    pub fn cooperative_role(
193        &mut self,
194        ctx: &ExpressionContext<'source, '_, '_>,
195    ) -> Result<'source, crate::CooperativeRole> {
196        let role_expr = self.expect_next("`Role`, a cooperative matrix role")?;
197        let (enumerant, span) = ctx.enumerant(role_expr)?;
198        let role = conv::map_cooperative_role(enumerant, span)?;
199        Ok(role)
200    }
201}