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

[naga wgsl-in] Introduce a Result alias for the WGSL front end.

Browse Source 
Introduce a new type alias, `naga::front::wgsl::Result`, that is
`core::result::Result` with the error type fixed to
`naga::front::wgsl::Error`. Use this alias where appropriate.

This commit should cause no changes in behavior or interface.
This commit is contained in:
Jim Blandy
2025-03-15 14:55:46 -07:00
committed by Erich Gubler
parent 1c69416c32
commit 77fcca7522
10 changed files with 151 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
naga/src/front/wgsl/index.rs
View File

@@ -1,6 +1,6 @@
use alloc::{vec, vec::Vec};
use super::Error;
use super::{Error, Result};
use crate::front::wgsl::parse::ast;
use crate::{FastHashMap, Handle, Span};
@@ -17,7 +17,7 @@ impl<'a> Index<'a> {
///
/// Return an error if the graph of references between declarations contains
/// any cycles.
pub fn generate(tu: &ast::TranslationUnit<'a>) -> Result<Self, Error<'a>> {
pub fn generate(tu: &ast::TranslationUnit<'a>) -> Result<'a, Self> {
// Produce a map from global definitions' names to their `Handle<GlobalDecl>`s.
// While doing so, reject conflicting definitions.
let mut globals = FastHashMap::with_capacity_and_hasher(tu.decls.len(), Default::default());
@@ -103,7 +103,7 @@ struct DependencySolver<'source, 'temp> {
impl<'a> DependencySolver<'a, '_> {
/// Produce the sorted list of declaration handles, and check for cycles.
fn solve(mut self) -> Result<Vec<Handle<ast::GlobalDecl<'a>>>, Error<'a>> {
fn solve(mut self) -> Result<'a, Vec<Handle<ast::GlobalDecl<'a>>>> {
for (id, _) in self.module.decls.iter() {
if self.visited[id.index()] {
continue;
@@ -117,7 +117,7 @@ impl<'a> DependencySolver<'a, '_> {
/// Ensure that all declarations used by `id` have been added to the
/// ordering, and then append `id` itself.
fn dfs(&mut self, id: Handle<ast::GlobalDecl<'a>>) -> Result<(), Error<'a>> {
fn dfs(&mut self, id: Handle<ast::GlobalDecl<'a>>) -> Result<'a, ()> {
let decl = &self.module.decls[id];
let id_usize = id.index();

12
naga/src/front/wgsl/lower/construction.rs
View File

@@ -6,7 +6,7 @@ use alloc::{
};
use core::num::NonZeroU32;
use crate::front::wgsl::error::Error;
use crate::front::wgsl::{Error, Result};
use crate::front::wgsl::lower::{ExpressionContext, Lowerer};
use crate::front::wgsl::parse::ast;
use crate::{Handle, Span};
@@ -119,7 +119,7 @@ impl<'source> Lowerer<'source, '_> {
ty_span: Span,
components: &[Handle<ast::Expression<'source>>],
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
use crate::proc::TypeResolution as Tr;
let constructor_h = self.constructor(constructor, ctx)?;
@@ -141,7 +141,7 @@ impl<'source> Lowerer<'source, '_> {
let components = ast_components
.iter()
.map(|&expr| self.expression_for_abstract(expr, ctx))
.collect::<Result<_, _>>()?;
.collect::<Result<_>>()?;
let spans = ast_components
.iter()
.map(|&expr| ctx.ast_expressions.get_span(expr))
@@ -373,7 +373,7 @@ impl<'source> Lowerer<'source, '_> {
Default::default(),
)
})
.collect::<Result<Vec<_>, _>>()?;
.collect::<Result<Vec<_>>>()?;
let ty = ctx.ensure_type_exists(crate::TypeInner::Matrix {
columns,
@@ -410,7 +410,7 @@ impl<'source> Lowerer<'source, '_> {
Default::default(),
)
})
.collect::<Result<Vec<_>, _>>()?;
.collect::<Result<Vec<_>>>()?;
let ty = ctx.ensure_type_exists(crate::TypeInner::Matrix {
columns,
@@ -576,7 +576,7 @@ impl<'source> Lowerer<'source, '_> {
&mut self,
constructor: &ast::ConstructorType<'source>,
ctx: &mut ExpressionContext<'source, '_, 'out>,
) -> Result<Constructor<Handle<crate::Type>>, Error<'source>> {
) -> Result<'source, Constructor<Handle<crate::Type>>> {
let handle = match *constructor {
ast::ConstructorType::Scalar(scalar) => {
let ty = ctx.ensure_type_exists(scalar.to_inner_scalar());

19
naga/src/front/wgsl/lower/conversion.rs
View File

@@ -2,6 +2,7 @@
use alloc::{boxed::Box, string::String, vec::Vec};
use crate::front::wgsl::Result;
use crate::front::wgsl::error::{
AutoConversionError, AutoConversionLeafScalarError, ConcretizationFailedError,
};
@@ -25,7 +26,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
expr: Handle<crate::Expression>,
goal_ty: &crate::proc::TypeResolution,
goal_span: Span,
) -> Result<Handle<crate::Expression>, super::Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let expr_span = self.get_expression_span(expr);
// Keep the TypeResolution so we can get type names for
// structs in error messages.
@@ -87,7 +88,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
expr: Handle<crate::Expression>,
goal_scalar: crate::Scalar,
goal_span: Span,
) -> Result<Handle<crate::Expression>, super::Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let expr_span = self.get_expression_span(expr);
let expr_resolution = super::resolve!(self, expr);
let types = &self.module.types;
@@ -127,7 +128,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
expr: Handle<crate::Expression>,
expr_span: Span,
goal_scalar: crate::Scalar,
) -> Result<Handle<crate::Expression>, super::Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let expr_inner = super::resolve_inner!(self, expr);
if let crate::TypeInner::Array { .. } = *expr_inner {
self.as_const_evaluator()
@@ -149,7 +150,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
exprs: &mut [Handle<crate::Expression>],
goal_ty: &crate::proc::TypeResolution,
goal_span: Span,
) -> Result<(), super::Error<'source>> {
) -> Result<'source, ()> {
for expr in exprs.iter_mut() {
*expr = self.try_automatic_conversions(*expr, goal_ty, goal_span)?;
}
@@ -170,7 +171,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
exprs: &mut [Handle<crate::Expression>],
goal_scalar: crate::Scalar,
goal_span: Span,
) -> Result<(), super::Error<'source>> {
) -> Result<'source, ()> {
use crate::proc::TypeResolution as Tr;
use crate::TypeInner as Ti;
let goal_scalar_res = Tr::Value(Ti::Scalar(goal_scalar));
@@ -210,7 +211,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
&mut self,
expr: &mut Handle<crate::Expression>,
goal: crate::Scalar,
) -> Result<(), super::Error<'source>> {
) -> Result<'source, ()> {
let inner = super::resolve_inner!(self, *expr);
// Do nothing if `inner` doesn't even have leaf scalars;
// it's a type error that validation will catch.
@@ -241,7 +242,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
&mut self,
exprs: &mut [Handle<crate::Expression>],
goal: crate::Scalar,
) -> Result<(), super::Error<'source>> {
) -> Result<'source, ()> {
for expr in exprs.iter_mut() {
self.convert_to_leaf_scalar(expr, goal)?;
}
@@ -255,7 +256,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
pub fn concretize(
&mut self,
mut expr: Handle<crate::Expression>,
) -> Result<Handle<crate::Expression>, super::Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let inner = super::resolve_inner!(self, expr);
if let Some(scalar) = inner.automatically_convertible_scalar(&self.module.types) {
let concretized = scalar.concretize();
@@ -303,7 +304,7 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
pub fn automatic_conversion_consensus<'handle, I>(
&self,
components: I,
) -> Result<crate::Scalar, usize>
) -> core::result::Result<crate::Scalar, usize>
where
I: IntoIterator<Item = &'handle Handle<crate::Expression>>,
I::IntoIter: Clone, // for debugging

95
naga/src/front/wgsl/lower/mod.rs
View File

@@ -5,6 +5,7 @@ use alloc::{
};
use core::num::NonZeroU32;
use crate::front::wgsl::Result;
use crate::front::wgsl::error::{Error, ExpectedToken, InvalidAssignmentType};
use crate::front::wgsl::index::Index;
use crate::front::wgsl::parse::number::Number;
@@ -468,7 +469,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
&mut self,
expr: crate::Expression,
span: Span,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let mut eval = self.as_const_evaluator();
eval.try_eval_and_append(expr, span)
.map_err(|e| Error::ConstantEvaluatorError(e.into(), span))
@@ -477,7 +478,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
fn const_eval_expr_to_u32(
&self,
handle: Handle<crate::Expression>,
) -> Result<u32, crate::proc::U32EvalError> {
) -> core::result::Result<u32, crate::proc::U32EvalError> {
match self.expr_type {
ExpressionContextType::Runtime(ref ctx) => {
if !ctx.local_expression_kind_tracker.is_const(handle) {
@@ -525,7 +526,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
&mut self,
local: &Handle<ast::Local>,
span: Span,
) -> Result<Typed<Handle<crate::Expression>>, Error<'source>> {
) -> Result<'source, Typed<Handle<crate::Expression>>> {
match self.expr_type {
ExpressionContextType::Runtime(ref ctx) => Ok(ctx.local_table[local].runtime()),
ExpressionContextType::Constant(Some(ref ctx)) => ctx.local_table[local]
@@ -538,7 +539,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
fn runtime_expression_ctx(
&mut self,
span: Span,
) -> Result<&mut LocalExpressionContext<'temp, 'out>, Error<'source>> {
) -> Result<'source, &mut LocalExpressionContext<'temp, 'out>> {
match self.expr_type {
ExpressionContextType::Runtime(ref mut ctx) => Ok(ctx),
ExpressionContextType::Constant(_) | ExpressionContextType::Override => {
@@ -552,7 +553,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
expr: Handle<crate::Expression>,
component_span: Span,
gather_span: Span,
) -> Result<crate::SwizzleComponent, Error<'source>> {
) -> Result<'source, crate::SwizzleComponent> {
match self.expr_type {
ExpressionContextType::Runtime(ref rctx) => {
if !rctx.local_expression_kind_tracker.is_const(expr) {
@@ -599,7 +600,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
fn register_type(
&mut self,
handle: Handle<crate::Expression>,
) -> Result<Handle<crate::Type>, Error<'source>> {
) -> Result<'source, Handle<crate::Type>> {
self.grow_types(handle)?;
// This is equivalent to calling ExpressionContext::typifier(),
// except that this lets the borrow checker see that it's okay
@@ -637,7 +638,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
fn grow_types(
&mut self,
handle: Handle<crate::Expression>,
) -> Result<&mut Self, Error<'source>> {
) -> Result<'source, &mut Self> {
let empty_arena = Arena::new();
let resolve_ctx;
let typifier;
@@ -670,7 +671,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
&mut self,
image: Handle<crate::Expression>,
span: Span,
) -> Result<(crate::ImageClass, bool), Error<'source>> {
) -> Result<'source, (crate::ImageClass, bool)> {
match *resolve_inner!(self, image) {
crate::TypeInner::Image { class, arrayed, .. } => Ok((class, arrayed)),
_ => Err(Error::BadTexture(span)),
@@ -704,7 +705,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
op: crate::BinaryOperator,
left: &mut Handle<crate::Expression>,
right: &mut Handle<crate::Expression>,
) -> Result<(), Error<'source>> {
) -> Result<'source, ()> {
if matches!(
op,
crate::BinaryOperator::Add
@@ -743,7 +744,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
&mut self,
expression: crate::Expression,
span: Span,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
match self.expr_type {
ExpressionContextType::Runtime(ref mut rctx)
| ExpressionContextType::Constant(Some(ref mut rctx)) => {
@@ -770,7 +771,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
fn apply_load_rule(
&mut self,
expr: Typed<Handle<crate::Expression>>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
match expr {
Typed::Reference(pointer) => {
let load = crate::Expression::Load { pointer };
@@ -795,7 +796,7 @@ struct ArgumentContext<'ctx, 'source> {
}
impl<'source> ArgumentContext<'_, 'source> {
pub fn finish(self) -> Result<(), Error<'source>> {
pub fn finish(self) -> Result<'source, ()> {
if self.args.len() == 0 {
Ok(())
} else {
@@ -807,7 +808,7 @@ impl<'source> ArgumentContext<'_, 'source> {
}
}
pub fn next(&mut self) -> Result<Handle<ast::Expression<'source>>, Error<'source>> {
pub fn next(&mut self) -> Result<'source, Handle<ast::Expression<'source>>> {
match self.args.next().copied() {
Some(arg) => {
self.args_used += 1;
@@ -884,7 +885,7 @@ impl<T> Typed<T> {
}
}
fn try_map<U, E>(self, mut f: impl FnMut(T) -> Result<U, E>) -> Result<Typed<U>, E> {
fn try_map<U, E>(self, mut f: impl FnMut(T) -> core::result::Result<U, E>) -> core::result::Result<Typed<U>, E> {
Ok(match self {
Self::Reference(expr) => Typed::Reference(f(expr)?),
Self::Plain(expr) => Typed::Plain(f(expr)?),
@@ -917,7 +918,7 @@ impl Components {
}
}
fn single_component(name: &str, name_span: Span) -> Result<u32, Error> {
fn single_component(name: &str, name_span: Span) -> Result<u32> {
let ch = name.chars().next().ok_or(Error::BadAccessor(name_span))?;
match Self::letter_component(ch) {
Some(sc) => Ok(sc as u32),
@@ -928,7 +929,7 @@ impl Components {
/// Construct a `Components` value from a 'member' name, like `"wzy"` or `"x"`.
///
/// Use `name_span` for reporting errors in parsing the component string.
fn new(name: &str, name_span: Span) -> Result<Self, Error> {
fn new(name: &str, name_span: Span) -> Result<Self> {
let size = match name.len() {
1 => return Ok(Components::Single(Self::single_component(name, name_span)?)),
2 => crate::VectorSize::Bi,
@@ -1055,7 +1056,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
pub fn lower(
&mut self,
tu: ast::TranslationUnit<'source>,
) -> Result<crate::Module, Error<'source>> {
) -> Result<'source, crate::Module> {
let mut module = crate::Module {
diagnostic_filters: tu.diagnostic_filters,
diagnostic_filter_leaf: tu.diagnostic_filter_leaf,
@@ -1233,7 +1234,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
explicit_ty: Option<Handle<crate::Type>>,
abstract_rule: AbstractRule,
ectx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<(Handle<crate::Type>, Option<Handle<crate::Expression>>), Error<'source>> {
) -> Result<'source, (Handle<crate::Type>, Option<Handle<crate::Expression>>)> {
let ty;
let initializer;
match (init, explicit_ty) {
@@ -1286,7 +1287,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
f: &ast::Function<'source>,
span: Span,
ctx: &mut GlobalContext<'source, '_, '_>,
) -> Result<LoweredGlobalDecl, Error<'source>> {
) -> Result<'source, LoweredGlobalDecl> {
let mut local_table = FastHashMap::default();
let mut expressions = Arena::new();
let mut named_expressions = FastIndexMap::default();
@@ -1296,7 +1297,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
.arguments
.iter()
.enumerate()
.map(|(i, arg)| -> Result<_, Error<'_>> {
.map(|(i, arg)| -> Result<'_, _> {
let ty = self.resolve_ast_type(arg.ty, &mut ctx.as_const())?;
let expr = expressions
.append(crate::Expression::FunctionArgument(i as u32), arg.name.span);
@@ -1310,12 +1311,12 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
binding: self.binding(&arg.binding, ty, ctx)?,
})
})
.collect::<Result<Vec<_>, _>>()?;
.collect::<Result<Vec<_>>>()?;
let result = f
.result
.as_ref()
.map(|res| -> Result<_, Error<'_>> {
.map(|res| -> Result<'_, _> {
let ty = self.resolve_ast_type(res.ty, &mut ctx.as_const())?;
Ok(crate::FunctionResult {
ty,
@@ -1423,7 +1424,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
size_expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let span = ctx.ast_expressions.get_span(size_expr);
let expr = self.expression(size_expr, ctx)?;
match resolve_inner!(ctx, expr).scalar_kind().ok_or(0) {
@@ -1437,7 +1438,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
b: &ast::Block<'source>,
is_inside_loop: bool,
ctx: &mut StatementContext<'source, '_, '_>,
) -> Result<crate::Block, Error<'source>> {
) -> Result<'source, crate::Block> {
let mut block = crate::Block::default();
for stmt in b.stmts.iter() {
@@ -1453,7 +1454,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
block: &mut crate::Block,
is_inside_loop: bool,
ctx: &mut StatementContext<'source, '_, '_>,
) -> Result<(), Error<'source>> {
) -> Result<'source, ()> {
let out = match stmt.kind {
ast::StatementKind::Block(ref block) => {
let block = self.block(block, is_inside_loop, ctx)?;
@@ -1655,7 +1656,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
},
}
})
.collect::<Result<(Vec<_>, Vec<_>), _>>()?;
.collect::<Result<(Vec<_>, Vec<_>)>>()?;
let mut consensus =
ectx.automatic_conversion_consensus(&exprs)
@@ -1709,7 +1710,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
fall_through: case.fall_through,
})
})
.collect::<Result<_, _>>()?;
.collect::<Result<_>>()?;
crate::Statement::Switch { selector, cases }
}
@@ -1959,7 +1960,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let expr = self.expression_for_abstract(expr, ctx)?;
ctx.concretize(expr)
}
@@ -1968,7 +1969,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let expr = self.expression_for_reference(expr, ctx)?;
ctx.apply_load_rule(expr)
}
@@ -1977,7 +1978,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Typed<Handle<crate::Expression>>, Error<'source>> {
) -> Result<'source, Typed<Handle<crate::Expression>>> {
let span = ctx.ast_expressions.get_span(expr);
let expr = &ctx.ast_expressions[expr];
@@ -2209,7 +2210,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
right: Handle<ast::Expression<'source>>,
span: Span,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Typed<crate::Expression>, Error<'source>> {
) -> Result<'source, Typed<crate::Expression>> {
// Load both operands.
let mut left = self.expression_for_abstract(left, ctx)?;
let mut right = self.expression_for_abstract(right, ctx)?;
@@ -2297,7 +2298,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
arguments: &[Handle<ast::Expression<'source>>],
ctx: &mut ExpressionContext<'source, '_, '_>,
is_statement: bool,
) -> Result<Option<Handle<crate::Expression>>, Error<'source>> {
) -> Result<'source, Option<Handle<crate::Expression>>> {
let function_span = function.span;
match ctx.globals.get(function.name) {
Some(&LoweredGlobalDecl::Type(ty)) => {
@@ -2341,7 +2342,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
ctx.ast_expressions.get_span(arg),
)
})
.collect::<Result<Vec<_>, _>>()?;
.collect::<Result<Vec<_>>>()?;
let has_result = ctx.module.functions[function].result.is_some();
@@ -2934,7 +2935,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let span = ctx.ast_expressions.get_span(expr);
let pointer = self.expression(expr, ctx)?;
@@ -2960,7 +2961,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
args: &[Handle<ast::Expression<'source>>],
is_statement: bool,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Option<Handle<crate::Expression>>, Error<'source>> {
) -> Result<'source, Option<Handle<crate::Expression>>> {
let mut args = ctx.prepare_args(args, 2, span);
let pointer = self.atomic_pointer(args.next()?, ctx)?;
@@ -3013,14 +3014,14 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
args: &[Handle<ast::Expression<'source>>],
span: Span,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<crate::Expression, Error<'source>> {
) -> Result<'source, crate::Expression> {
let mut args = ctx.prepare_args(args, fun.min_argument_count(), span);
fn get_image_and_span<'source>(
lowerer: &mut Lowerer<'source, '_>,
args: &mut ArgumentContext<'_, 'source>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<(Handle<crate::Expression>, Span), Error<'source>> {
) -> Result<'source, (Handle<crate::Expression>, Span)> {
let image = args.next()?;
let image_span = ctx.ast_expressions.get_span(image);
let image = lowerer.expression(image, ctx)?;
@@ -3135,7 +3136,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
collective_op: crate::CollectiveOperation,
arguments: &[Handle<ast::Expression<'source>>],
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let mut args = ctx.prepare_args(arguments, 1, span);
let argument = self.expression(args.next()?, ctx)?;
@@ -3164,7 +3165,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
mode: SubgroupGather,
arguments: &[Handle<ast::Expression<'source>>],
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let mut args = ctx.prepare_args(arguments, 2, span);
let argument = self.expression(args.next()?, ctx)?;
@@ -3207,7 +3208,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
s: &ast::Struct<'source>,
span: Span,
ctx: &mut GlobalContext<'source, '_, '_>,
) -> Result<Handle<crate::Type>, Error<'source>> {
) -> Result<'source, Handle<crate::Type>> {
let mut offset = 0;
let mut struct_alignment = Alignment::ONE;
let mut members = Vec::with_capacity(s.members.len());
@@ -3281,7 +3282,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<(u32, Span), Error<'source>> {
) -> Result<'source, (u32, Span)> {
let span = ctx.ast_expressions.get_span(expr);
let expr = self.expression(expr, ctx)?;
let value = ctx
@@ -3301,7 +3302,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
size: ast::ArraySize<'source>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<crate::ArraySize, Error<'source>> {
) -> Result<'source, crate::ArraySize> {
Ok(match size {
ast::ArraySize::Constant(expr) => {
let span = ctx.ast_expressions.get_span(expr);
@@ -3351,7 +3352,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
size_expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
span: Span,
) -> Result<Handle<crate::Override>, Error<'source>> {
) -> Result<'source, Handle<crate::Override>> {
let expr = self.expression(size_expr, ctx)?;
match resolve_inner!(ctx, expr).scalar_kind().ok_or(0) {
Ok(crate::ScalarKind::Sint) | Ok(crate::ScalarKind::Uint) => Ok({
@@ -3388,7 +3389,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
handle: Handle<ast::Type<'source>>,
name: Option<String>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Type>, Error<'source>> {
) -> Result<'source, Handle<crate::Type>> {
let inner = match ctx.types[handle] {
ast::Type::Scalar(scalar) => scalar.to_inner_scalar(),
ast::Type::Vector { size, ty, ty_span } => {
@@ -3475,7 +3476,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
handle: Handle<ast::Type<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Type>, Error<'source>> {
) -> Result<'source, Handle<crate::Type>> {
self.resolve_named_ast_type(handle, None, ctx)
}
@@ -3484,7 +3485,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
binding: &Option<ast::Binding<'source>>,
ty: Handle<crate::Type>,
ctx: &mut GlobalContext<'source, '_, '_>,
) -> Result<Option<crate::Binding>, Error<'source>> {
) -> Result<'source, Option<crate::Binding>> {
Ok(match *binding {
Some(ast::Binding::BuiltIn(b)) => Some(crate::Binding::BuiltIn(b)),
Some(ast::Binding::Location {
@@ -3516,7 +3517,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
&mut self,
expr: Handle<ast::Expression<'source>>,
ctx: &mut ExpressionContext<'source, '_, '_>,
) -> Result<Handle<crate::Expression>, Error<'source>> {
) -> Result<'source, Handle<crate::Expression>> {
let span = ctx.ast_expressions.get_span(expr);
let pointer = self.expression(expr, ctx)?;

8
naga/src/front/wgsl/mod.rs
View File

@@ -27,6 +27,8 @@ use crate::Scalar;
#[cfg(test)]
use std::println;
pub(crate) type Result<'a, T> = core::result::Result<T, Error<'a>>;
pub struct Frontend {
parser: Parser,
}
@@ -38,11 +40,11 @@ impl Frontend {
}
}
pub fn parse(&mut self, source: &str) -> Result<crate::Module, ParseError> {
pub fn parse(&mut self, source: &str) -> core::result::Result<crate::Module, ParseError> {
self.inner(source).map_err(|x| x.as_parse_error(source))
}
fn inner<'a>(&mut self, source: &'a str) -> Result<crate::Module, Error<'a>> {
fn inner<'a>(&mut self, source: &'a str) -> Result<'a, crate::Module> {
let tu = self.parser.parse(source)?;
let index = index::Index::generate(&tu)?;
let module = Lowerer::new(&index).lower(tu)?;
@@ -62,7 +64,7 @@ impl Frontend {
/// for this, particularly if calls to this method are exposed to user input.
///
/// </div>
pub fn parse_str(source: &str) -> Result<crate::Module, ParseError> {
pub fn parse_str(source: &str) -> core::result::Result<crate::Module, ParseError> {
Frontend::new().parse(source)
}

15
naga/src/front/wgsl/parse/conv.rs
View File

@@ -1,8 +1,7 @@
use super::Error;
use crate::front::wgsl::Scalar;
use crate::front::wgsl::{Error, Result, Scalar};
use crate::Span;
pub fn map_address_space(word: &str, span: Span) -> Result<crate::AddressSpace, Error<'_>> {
pub fn map_address_space(word: &str, span: Span) -> Result<'_, crate::AddressSpace> {
match word {
"private" => Ok(crate::AddressSpace::Private),
"workgroup" => Ok(crate::AddressSpace::WorkGroup),
@@ -16,7 +15,7 @@ pub fn map_address_space(word: &str, span: Span) -> Result<crate::AddressSpace,
}
}
pub fn map_built_in(word: &str, span: Span) -> Result<crate::BuiltIn, Error<'_>> {
pub fn map_built_in(word: &str, span: Span) -> Result<'_, crate::BuiltIn> {
Ok(match word {
"position" => crate::BuiltIn::Position { invariant: false },
// vertex
@@ -44,7 +43,7 @@ pub fn map_built_in(word: &str, span: Span) -> Result<crate::BuiltIn, Error<'_>>
})
}
pub fn map_interpolation(word: &str, span: Span) -> Result<crate::Interpolation, Error<'_>> {
pub fn map_interpolation(word: &str, span: Span) -> Result<'_, crate::Interpolation> {
match word {
"linear" => Ok(crate::Interpolation::Linear),
"flat" => Ok(crate::Interpolation::Flat),
@@ -53,7 +52,7 @@ pub fn map_interpolation(word: &str, span: Span) -> Result<crate::Interpolation,
}
}
pub fn map_sampling(word: &str, span: Span) -> Result<crate::Sampling, Error<'_>> {
pub fn map_sampling(word: &str, span: Span) -> Result<'_, crate::Sampling> {
match word {
"center" => Ok(crate::Sampling::Center),
"centroid" => Ok(crate::Sampling::Centroid),
@@ -64,7 +63,7 @@ pub fn map_sampling(word: &str, span: Span) -> Result<crate::Sampling, Error<'_>
}
}
pub fn map_storage_format(word: &str, span: Span) -> Result<crate::StorageFormat, Error<'_>> {
pub fn map_storage_format(word: &str, span: Span) -> Result<'_, crate::StorageFormat> {
use crate::StorageFormat as Sf;
Ok(match word {
"r8unorm" => Sf::R8Unorm,
@@ -264,7 +263,7 @@ pub fn map_standard_fun(word: &str) -> Option<crate::MathFunction> {
pub fn map_conservative_depth(
word: &str,
span: Span,
) -> Result<crate::ConservativeDepth, Error<'_>> {
) -> Result<'_, crate::ConservativeDepth> {
use crate::ConservativeDepth as Cd;
match word {
"greater_equal" => Ok(Cd::GreaterEqual),

2
naga/src/front/wgsl/parse/directive.rs
View File

@@ -39,7 +39,7 @@ impl crate::diagnostic_filter::Severity {
self,
err: crate::front::wgsl::error::Error<'a>,
source: &str,
) -> Result<(), crate::front::wgsl::error::Error<'a>> {
) -> crate::front::wgsl::Result<'a, ()> {
self.report_diag(err, |e, level| {
let e = e.as_parse_error(source);
log::log!(level, "{}", e.emit_to_string(source));

5
naga/src/front/wgsl/parse/directive/enable_extension.rs
View File

@@ -2,7 +2,8 @@
//!
//! The focal point of this module is the [`EnableExtension`] API.
use crate::{front::wgsl::error::Error, Span};
use crate::Span;
use crate::front::wgsl::{Error, Result};
/// Tracks the status of every enable-extension known to Naga.
#[derive(Clone, Debug, Eq, PartialEq)]
@@ -61,7 +62,7 @@ impl EnableExtension {
const DUAL_SOURCE_BLENDING: &'static str = "dual_source_blending";
/// Convert from a sentinel word in WGSL into its associated [`EnableExtension`], if possible.
pub(crate) fn from_ident(word: &str, span: Span) -> Result<Self, Error<'_>> {
pub(crate) fn from_ident(word: &str, span: Span) -> Result<Self> {
Ok(match word {
Self::F16 => Self::Unimplemented(UnimplementedEnableExtension::F16),
Self::CLIP_DISTANCES => {

40
naga/src/front/wgsl/parse/lexer.rs
View File

@@ -1,4 +1,4 @@
use super::{number::consume_number, Error, ExpectedToken};
use super::{number::consume_number, Error, ExpectedToken, Result};
use crate::front::wgsl::error::NumberError;
use crate::front::wgsl::parse::directive::enable_extension::EnableExtensions;
use crate::front::wgsl::parse::{conv, Number};
@@ -12,7 +12,7 @@ pub enum Token<'a> {
Separator(char),
Paren(char),
Attribute,
Number(Result<Number, NumberError>),
Number(core::result::Result<Number, NumberError>),
Word(&'a str),
Operation(char),
LogicalOperation(char),
@@ -242,8 +242,8 @@ impl<'a> Lexer<'a> {
#[inline]
pub fn capture_span<T, E>(
&mut self,
inner: impl FnOnce(&mut Self) -> Result<T, E>,
) -> Result<(T, Span), E> {
inner: impl FnOnce(&mut Self) -> core::result::Result<T, E>,
) -> core::result::Result<(T, Span), E> {
let start = self.current_byte_offset();
let res = inner(self)?;
let end = self.current_byte_offset();
@@ -322,7 +322,7 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn expect_span(
&mut self,
expected: Token<'a>,
) -> Result<Span, Error<'a>> {
) -> Result<'a, Span> {
let next = self.next();
if next.0 == expected {
Ok(next.1)
@@ -331,7 +331,7 @@ impl<'a> Lexer<'a> {
}
}
pub(in crate::front::wgsl) fn expect(&mut self, expected: Token<'a>) -> Result<(), Error<'a>> {
pub(in crate::front::wgsl) fn expect(&mut self, expected: Token<'a>) -> Result<'a, ()> {
self.expect_span(expected)?;
Ok(())
}
@@ -339,7 +339,7 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn expect_generic_paren(
&mut self,
expected: char,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
let next = self.next_generic();
if next.0 == Token::Paren(expected) {
Ok(())
@@ -368,7 +368,7 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn next_ident_with_span(
&mut self,
) -> Result<(&'a str, Span), Error<'a>> {
) -> Result<'a, (&'a str, Span)> {
match self.next() {
(Token::Word(word), span) => Self::word_as_ident_with_span(word, span),
other => Err(Error::Unexpected(other.1, ExpectedToken::Identifier)),
@@ -377,14 +377,14 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn peek_ident_with_span(
&mut self,
) -> Result<(&'a str, Span), Error<'a>> {
) -> Result<'a, (&'a str, Span)> {
match self.peek() {
(Token::Word(word), span) => Self::word_as_ident_with_span(word, span),
other => Err(Error::Unexpected(other.1, ExpectedToken::Identifier)),
}
}
fn word_as_ident_with_span(word: &'a str, span: Span) -> Result<(&'a str, Span), Error<'a>> {
fn word_as_ident_with_span(word: &'a str, span: Span) -> Result<'a, (&'a str, Span)> {
match word {
"_" => Err(Error::InvalidIdentifierUnderscore(span)),
word if word.starts_with("__") => Err(Error::ReservedIdentifierPrefix(span)),
@@ -394,13 +394,13 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn next_ident(
&mut self,
) -> Result<super::ast::Ident<'a>, Error<'a>> {
) -> Result<'a, super::ast::Ident<'a>> {
self.next_ident_with_span()
.and_then(|(word, span)| Self::word_as_ident(word, span))
.map(|(name, span)| super::ast::Ident { name, span })
}
fn word_as_ident(word: &'a str, span: Span) -> Result<(&'a str, Span), Error<'a>> {
fn word_as_ident(word: &'a str, span: Span) -> Result<'a, (&'a str, Span)> {
if crate::keywords::wgsl::RESERVED.contains(&word) {
Err(Error::ReservedKeyword(span))
} else {
@@ -409,7 +409,7 @@ impl<'a> Lexer<'a> {
}
/// Parses a generic scalar type, for example `<f32>`.
pub(in crate::front::wgsl) fn next_scalar_generic(&mut self) -> Result<Scalar, Error<'a>> {
pub(in crate::front::wgsl) fn next_scalar_generic(&mut self) -> Result<'a, Scalar> {
self.expect_generic_paren('<')?;
let pair = match self.next() {
(Token::Word(word), span) => {
@@ -426,7 +426,7 @@ impl<'a> Lexer<'a> {
/// Returns the span covering the inner type, excluding the brackets.
pub(in crate::front::wgsl) fn next_scalar_generic_with_span(
&mut self,
) -> Result<(Scalar, Span), Error<'a>> {
) -> Result<'a, (Scalar, Span)> {
self.expect_generic_paren('<')?;
let pair = match self.next() {
(Token::Word(word), span) => conv::get_scalar_type(word)
@@ -440,7 +440,7 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn next_storage_access(
&mut self,
) -> Result<crate::StorageAccess, Error<'a>> {
) -> Result<'a, crate::StorageAccess> {
let (ident, span) = self.next_ident_with_span()?;
match ident {
"read" => Ok(crate::StorageAccess::LOAD),
@@ -455,7 +455,7 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn next_format_generic(
&mut self,
) -> Result<(crate::StorageFormat, crate::StorageAccess), Error<'a>> {
) -> Result<'a, (crate::StorageFormat, crate::StorageAccess)> {
self.expect(Token::Paren('<'))?;
let (ident, ident_span) = self.next_ident_with_span()?;
let format = conv::map_storage_format(ident, ident_span)?;
@@ -467,7 +467,7 @@ impl<'a> Lexer<'a> {
pub(in crate::front::wgsl) fn next_acceleration_structure_flags(
&mut self,
) -> Result<bool, Error<'a>> {
) -> Result<'a, bool> {
Ok(if self.skip(Token::Paren('<')) {
if !self.skip(Token::Paren('>')) {
let (name, span) = self.next_ident_with_span()?;
@@ -487,16 +487,16 @@ impl<'a> Lexer<'a> {
})
}
pub(in crate::front::wgsl) fn open_arguments(&mut self) -> Result<(), Error<'a>> {
pub(in crate::front::wgsl) fn open_arguments(&mut self) -> Result<'a, ()> {
self.expect(Token::Paren('('))
}
pub(in crate::front::wgsl) fn close_arguments(&mut self) -> Result<(), Error<'a>> {
pub(in crate::front::wgsl) fn close_arguments(&mut self) -> Result<'a, ()> {
let _ = self.skip(Token::Separator(','));
self.expect(Token::Paren(')'))
}
pub(in crate::front::wgsl) fn next_argument(&mut self) -> Result<bool, Error<'a>> {
pub(in crate::front::wgsl) fn next_argument(&mut self) -> Result<'a, bool> {
let paren = Token::Paren(')');
if self.skip(Token::Separator(',')) {
Ok(!self.skip(paren))

94
naga/src/front/wgsl/parse/mod.rs
View File

@@ -13,7 +13,7 @@ use crate::front::wgsl::parse::directive::language_extension::LanguageExtension;
use crate::front::wgsl::parse::directive::DirectiveKind;
use crate::front::wgsl::parse::lexer::{Lexer, Token};
use crate::front::wgsl::parse::number::Number;
use crate::front::wgsl::Scalar;
use crate::front::wgsl::{Result, Scalar};
use crate::front::SymbolTable;
use crate::{Arena, FastHashSet, FastIndexSet, Handle, ShaderStage, Span};
@@ -98,8 +98,8 @@ impl<'a> ExpressionContext<'a, '_, '_> {
mut parser: impl FnMut(
&mut Lexer<'a>,
&mut Self,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>>,
) -> Result<'a, Handle<ast::Expression<'a>>> {
let start = lexer.start_byte_offset();
let mut accumulator = parser(lexer, self)?;
while let Some(op) = classifier(lexer.peek().0) {
@@ -114,7 +114,7 @@ impl<'a> ExpressionContext<'a, '_, '_> {
Ok(accumulator)
}
fn declare_local(&mut self, name: ast::Ident<'a>) -> Result<Handle<ast::Local>, Error<'a>> {
fn declare_local(&mut self, name: ast::Ident<'a>) -> Result<'a, Handle<ast::Local>> {
let handle = self.locals.append(ast::Local, name.span);
if let Some(old) = self.local_table.add(name.name, handle) {
Err(Error::Redefinition {
@@ -166,7 +166,7 @@ impl<T> Default for ParsedAttribute<T> {
}
impl<T> ParsedAttribute<T> {
fn set(&mut self, value: T, name_span: Span) -> Result<(), Error<'static>> {
fn set(&mut self, value: T, name_span: Span) -> Result<'static, ()> {
if self.value.is_some() {
return Err(Error::RepeatedAttribute(name_span));
}
@@ -193,7 +193,7 @@ impl<'a> BindingParser<'a> {
name: &'a str,
name_span: Span,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
match name {
"location" => {
lexer.expect(Token::Paren('('))?;
@@ -245,7 +245,7 @@ impl<'a> BindingParser<'a> {
Ok(())
}
fn finish(self, span: Span) -> Result<Option<ast::Binding<'a>>, Error<'a>> {
fn finish(self, span: Span) -> Result<'a, Option<ast::Binding<'a>>> {
match (
self.location.value,
self.built_in.value,
@@ -322,9 +322,9 @@ impl Parser {
)
}
fn track_recursion<'a, F, R>(&mut self, f: F) -> Result<R, Error<'a>>
fn track_recursion<'a, F, R>(&mut self, f: F) -> Result<'a, R>
where
F: FnOnce(&mut Self) -> Result<R, Error<'a>>,
F: FnOnce(&mut Self) -> Result<'a, R>,
{
self.recursion_depth += 1;
if self.recursion_depth >= 256 {
@@ -339,7 +339,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<ast::SwitchValue<'a>, Error<'a>> {
) -> Result<'a, ast::SwitchValue<'a>> {
if let Token::Word("default") = lexer.peek().0 {
let _ = lexer.next();
return Ok(ast::SwitchValue::Default);
@@ -366,7 +366,7 @@ impl Parser {
word: &'a str,
span: Span,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Option<ast::ConstructorType<'a>>, Error<'a>> {
) -> Result<'a, Option<ast::ConstructorType<'a>>> {
if let Some(scalar) = conv::get_scalar_type(word) {
return Ok(Some(ast::ConstructorType::Scalar(scalar)));
}
@@ -617,7 +617,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Vec<Handle<ast::Expression<'a>>>, Error<'a>> {
) -> Result<'a, Vec<Handle<ast::Expression<'a>>>> {
self.push_rule_span(Rule::EnclosedExpr, lexer);
lexer.open_arguments()?;
let mut arguments = Vec::new();
@@ -641,7 +641,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
self.push_rule_span(Rule::EnclosedExpr, lexer);
let expr = self.general_expression(lexer, ctx)?;
self.pop_rule_span(lexer);
@@ -656,7 +656,7 @@ impl Parser {
name: &'a str,
name_span: Span,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
assert!(self.rules.last().is_some());
let expr = match name {
@@ -718,7 +718,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
self.push_rule_span(Rule::PrimaryExpr, lexer);
const fn literal_ray_flag<'b>(flag: crate::RayFlag) -> ast::Expression<'b> {
ast::Expression::Literal(ast::Literal::Number(Number::U32(flag.bits())))
@@ -855,7 +855,7 @@ impl Parser {
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
expr: Handle<ast::Expression<'a>>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
let mut expr = expr;
loop {
@@ -887,7 +887,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
self.push_rule_span(Rule::GenericExpr, lexer);
let expr = self.general_expression(lexer, ctx)?;
self.pop_rule_span(lexer);
@@ -899,7 +899,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
self.track_recursion(|this| {
this.push_rule_span(Rule::UnaryExpr, lexer);
//TODO: refactor this to avoid backing up
@@ -964,7 +964,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
self.track_recursion(|this| {
this.push_rule_span(Rule::LhsExpr, lexer);
let start = lexer.start_byte_offset();
@@ -1008,7 +1008,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
let start = lexer.start_byte_offset();
self.push_rule_span(Rule::SingularExpr, lexer);
let primary_expr = self.primary_expression(lexer, ctx)?;
@@ -1022,7 +1022,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
context: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
// equality_expression
context.parse_binary_op(
lexer,
@@ -1115,7 +1115,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Expression<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Expression<'a>>> {
self.general_expression_with_span(lexer, ctx)
.map(|(expr, _)| expr)
}
@@ -1124,7 +1124,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
context: &mut ExpressionContext<'a, '_, '_>,
) -> Result<(Handle<ast::Expression<'a>>, Span), Error<'a>> {
) -> Result<'a, (Handle<ast::Expression<'a>>, Span)> {
self.push_rule_span(Rule::GeneralExpr, lexer);
// logical_or_expression
let handle = context.parse_binary_op(
@@ -1188,7 +1188,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<ast::GlobalVariable<'a>, Error<'a>> {
) -> Result<'a, ast::GlobalVariable<'a>> {
self.push_rule_span(Rule::VariableDecl, lexer);
let mut space = crate::AddressSpace::Handle;
@@ -1238,7 +1238,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Vec<ast::StructMember<'a>>, Error<'a>> {
) -> Result<'a, Vec<ast::StructMember<'a>>> {
let mut members = Vec::new();
let mut member_names = FastHashSet::default();
@@ -1308,7 +1308,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<(Handle<ast::Type<'a>>, Span), Error<'a>> {
) -> Result<'a, (Handle<ast::Type<'a>>, Span)> {
lexer.expect_generic_paren('<')?;
let start = lexer.start_byte_offset();
let ty = self.type_decl(lexer, ctx)?;
@@ -1324,7 +1324,7 @@ impl Parser {
ctx: &mut ExpressionContext<'a, '_, '_>,
columns: crate::VectorSize,
rows: crate::VectorSize,
) -> Result<ast::Type<'a>, Error<'a>> {
) -> Result<'a, ast::Type<'a>> {
let (ty, ty_span) = self.singular_generic(lexer, ctx)?;
Ok(ast::Type::Matrix {
columns,
@@ -1339,7 +1339,7 @@ impl Parser {
lexer: &mut Lexer<'a>,
word: &'a str,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Option<ast::Type<'a>>, Error<'a>> {
) -> Result<'a, Option<ast::Type<'a>>> {
if let Some(scalar) = conv::get_scalar_type(word) {
return Ok(Some(ast::Type::Scalar(scalar)));
}
@@ -1734,7 +1734,7 @@ impl Parser {
}))
}
const fn check_texture_sample_type(scalar: Scalar, span: Span) -> Result<(), Error<'static>> {
const fn check_texture_sample_type(scalar: Scalar, span: Span) -> Result<'static, ()> {
use crate::ScalarKind::*;
// Validate according to https://gpuweb.github.io/gpuweb/wgsl/#sampled-texture-type
match scalar {
@@ -1755,7 +1755,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Handle<ast::Type<'a>>, Error<'a>> {
) -> Result<'a, Handle<ast::Type<'a>>> {
self.track_recursion(|this| {
this.push_rule_span(Rule::TypeDecl, lexer);
@@ -1786,7 +1786,7 @@ impl Parser {
block: &mut ast::Block<'a>,
target: Handle<ast::Expression<'a>>,
span_start: usize,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
use crate::BinaryOperator as Bo;
let op = lexer.next();
@@ -1845,7 +1845,7 @@ impl Parser {
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
block: &mut ast::Block<'a>,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
let span_start = lexer.start_byte_offset();
let target = self.lhs_expression(lexer, ctx)?;
self.assignment_op_and_rhs(lexer, ctx, block, target, span_start)
@@ -1861,7 +1861,7 @@ impl Parser {
span_start: usize,
context: &mut ExpressionContext<'a, '_, '_>,
block: &mut ast::Block<'a>,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
self.push_rule_span(Rule::SingularExpr, lexer);
context.unresolved.insert(ast::Dependency {
@@ -1892,7 +1892,7 @@ impl Parser {
lexer: &mut Lexer<'a>,
context: &mut ExpressionContext<'a, '_, '_>,
block: &mut ast::Block<'a>,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
let span_start = lexer.start_byte_offset();
match lexer.peek() {
(Token::Word(name), span) => {
@@ -1919,7 +1919,7 @@ impl Parser {
ctx: &mut ExpressionContext<'a, '_, '_>,
block: &mut ast::Block<'a>,
brace_nesting_level: u8,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
self.track_recursion(|this| {
this.push_rule_span(Rule::Statement, lexer);
match lexer.peek() {
@@ -2199,7 +2199,7 @@ impl Parser {
let mut body = ast::Block::default();
if !lexer.skip(Token::Separator(';')) {
let (condition, span) =
lexer.capture_span(|lexer| -> Result<_, Error<'_>> {
lexer.capture_span(|lexer| -> Result<'_, _> {
let condition = this.general_expression(lexer, ctx)?;
lexer.expect(Token::Separator(';'))?;
Ok(condition)
@@ -2307,7 +2307,7 @@ impl Parser {
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
brace_nesting_level: u8,
) -> Result<ast::StatementKind<'a>, Error<'a>> {
) -> Result<'a, ast::StatementKind<'a>> {
let _ = lexer.next();
let mut body = ast::Block::default();
let mut continuing = ast::Block::default();
@@ -2387,7 +2387,7 @@ impl Parser {
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
brace_nesting_level: u8,
) -> Result<(ast::Block<'a>, Span), Error<'a>> {
) -> Result<'a, (ast::Block<'a>, Span)> {
self.push_rule_span(Rule::Block, lexer);
ctx.local_table.push_scope();
@@ -2434,7 +2434,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
ctx: &mut ExpressionContext<'a, '_, '_>,
) -> Result<Option<ast::Binding<'a>>, Error<'a>> {
) -> Result<'a, Option<ast::Binding<'a>>> {
let mut bind_parser = BindingParser::default();
self.push_rule_span(Rule::Attribute, lexer);
@@ -2454,7 +2454,7 @@ impl Parser {
must_use: Option<Span>,
out: &mut ast::TranslationUnit<'a>,
dependencies: &mut FastIndexSet<ast::Dependency<'a>>,
) -> Result<ast::Function<'a>, Error<'a>> {
) -> Result<'a, ast::Function<'a>> {
self.push_rule_span(Rule::FunctionDecl, lexer);
// read function name
let fun_name = lexer.next_ident()?;
@@ -2546,8 +2546,8 @@ impl Parser {
fn directive_ident_list<'a>(
&self,
lexer: &mut Lexer<'a>,
handler: impl FnMut(&'a str, Span) -> Result<(), Error<'a>>,
) -> Result<(), Error<'a>> {
handler: impl FnMut(&'a str, Span) -> Result<'a, ()>,
) -> Result<'a, ()> {
let mut handler = handler;
'next_arg: loop {
let (ident, span) = lexer.next_ident_with_span()?;
@@ -2576,7 +2576,7 @@ impl Parser {
&mut self,
lexer: &mut Lexer<'a>,
out: &mut ast::TranslationUnit<'a>,
) -> Result<(), Error<'a>> {
) -> Result<'a, ()> {
// read attributes
let mut binding = None;
let mut stage = ParsedAttribute::default();
@@ -2598,7 +2598,7 @@ impl Parser {
unresolved: &mut dependencies,
};
let mut diagnostic_filters = DiagnosticFilterMap::new();
let ensure_no_diag_attrs = |on_what, filters: DiagnosticFilterMap| -> Result<(), Error> {
let ensure_no_diag_attrs = |on_what, filters: DiagnosticFilterMap| -> Result<()> {
if filters.is_empty() {
Ok(())
} else {
@@ -2842,7 +2842,7 @@ impl Parser {
}
}
pub fn parse<'a>(&mut self, source: &'a str) -> Result<ast::TranslationUnit<'a>, Error<'a>> {
pub fn parse<'a>(&mut self, source: &'a str) -> Result<'a, ast::TranslationUnit<'a>> {
self.reset();
let mut lexer = Lexer::new(source);
@@ -2928,7 +2928,7 @@ impl Parser {
const fn increase_brace_nesting(
brace_nesting_level: u8,
brace_span: Span,
) -> Result<u8, Error<'static>> {
) -> Result<'static, u8> {
// From [spec.](https://gpuweb.github.io/gpuweb/wgsl/#limits):
//
// > § 2.4. Limits
@@ -2951,7 +2951,7 @@ impl Parser {
Ok(brace_nesting_level + 1)
}
fn diagnostic_filter<'a>(&self, lexer: &mut Lexer<'a>) -> Result<DiagnosticFilter, Error<'a>> {
fn diagnostic_filter<'a>(&self, lexer: &mut Lexer<'a>) -> Result<'a, DiagnosticFilter> {
lexer.expect(Token::Paren('('))?;
let (severity_control_name, severity_control_name_span) = lexer.next_ident_with_span()?;