From 77fcca752216ac562d779cb7efe4cdf880d006c3 Mon Sep 17 00:00:00 2001 From: Jim Blandy Date: Sat, 15 Mar 2025 14:55:46 -0700 Subject: [PATCH] [naga wgsl-in] Introduce a `Result` alias for the WGSL front end. 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. --- naga/src/front/wgsl/index.rs | 8 +- naga/src/front/wgsl/lower/construction.rs | 12 +-- naga/src/front/wgsl/lower/conversion.rs | 19 ++-- naga/src/front/wgsl/lower/mod.rs | 95 ++++++++++--------- naga/src/front/wgsl/mod.rs | 8 +- naga/src/front/wgsl/parse/conv.rs | 15 ++- naga/src/front/wgsl/parse/directive.rs | 2 +- .../wgsl/parse/directive/enable_extension.rs | 5 +- naga/src/front/wgsl/parse/lexer.rs | 40 ++++---- naga/src/front/wgsl/parse/mod.rs | 94 +++++++++--------- 10 files changed, 151 insertions(+), 147 deletions(-) diff --git a/naga/src/front/wgsl/index.rs b/naga/src/front/wgsl/index.rs index 7dafb6ef64..dc85f4d4e8 100644 --- a/naga/src/front/wgsl/index.rs +++ b/naga/src/front/wgsl/index.rs @@ -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> { + pub fn generate(tu: &ast::TranslationUnit<'a>) -> Result<'a, Self> { // Produce a map from global definitions' names to their `Handle`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>>, Error<'a>> { + fn solve(mut self) -> Result<'a, Vec>>> { 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>) -> Result<(), Error<'a>> { + fn dfs(&mut self, id: Handle>) -> Result<'a, ()> { let decl = &self.module.decls[id]; let id_usize = id.index(); diff --git a/naga/src/front/wgsl/lower/construction.rs b/naga/src/front/wgsl/lower/construction.rs index b5fc3b66f0..fa5b4f96d8 100644 --- a/naga/src/front/wgsl/lower/construction.rs +++ b/naga/src/front/wgsl/lower/construction.rs @@ -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>], ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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::>()?; + .collect::>()?; let spans = ast_components .iter() .map(|&expr| ctx.ast_expressions.get_span(expr)) @@ -373,7 +373,7 @@ impl<'source> Lowerer<'source, '_> { Default::default(), ) }) - .collect::, _>>()?; + .collect::>>()?; let ty = ctx.ensure_type_exists(crate::TypeInner::Matrix { columns, @@ -410,7 +410,7 @@ impl<'source> Lowerer<'source, '_> { Default::default(), ) }) - .collect::, _>>()?; + .collect::>>()?; 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>, Error<'source>> { + ) -> Result<'source, Constructor>> { let handle = match *constructor { ast::ConstructorType::Scalar(scalar) => { let ty = ctx.ensure_type_exists(scalar.to_inner_scalar()); diff --git a/naga/src/front/wgsl/lower/conversion.rs b/naga/src/front/wgsl/lower/conversion.rs index 58a7f39124..e422b376d2 100644 --- a/naga/src/front/wgsl/lower/conversion.rs +++ b/naga/src/front/wgsl/lower/conversion.rs @@ -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, goal_ty: &crate::proc::TypeResolution, goal_span: Span, - ) -> Result, super::Error<'source>> { + ) -> Result<'source, Handle> { 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, goal_scalar: crate::Scalar, goal_span: Span, - ) -> Result, super::Error<'source>> { + ) -> Result<'source, Handle> { 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, expr_span: Span, goal_scalar: crate::Scalar, - ) -> Result, super::Error<'source>> { + ) -> Result<'source, Handle> { 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], 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], 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, 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], 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, - ) -> Result, super::Error<'source>> { + ) -> Result<'source, Handle> { 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 + ) -> core::result::Result where I: IntoIterator>, I::IntoIter: Clone, // for debugging diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs index ba9421f848..6fa26faa89 100644 --- a/naga/src/front/wgsl/lower/mod.rs +++ b/naga/src/front/wgsl/lower/mod.rs @@ -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, Error<'source>> { + ) -> Result<'source, Handle> { 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, - ) -> Result { + ) -> core::result::Result { 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, span: Span, - ) -> Result>, Error<'source>> { + ) -> Result<'source, Typed>> { 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, component_span: Span, gather_span: Span, - ) -> Result> { + ) -> 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, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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, - ) -> 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, 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, right: &mut Handle, - ) -> 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, Error<'source>> { + ) -> Result<'source, Handle> { 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>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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>, Error<'source>> { + pub fn next(&mut self) -> Result<'source, Handle>> { match self.args.next().copied() { Some(arg) => { self.args_used += 1; @@ -884,7 +885,7 @@ impl Typed { } } - fn try_map(self, mut f: impl FnMut(T) -> Result) -> Result, E> { + fn try_map(self, mut f: impl FnMut(T) -> core::result::Result) -> core::result::Result, 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 { + fn single_component(name: &str, name_span: Span) -> Result { 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 { + fn new(name: &str, name_span: Span) -> Result { 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> { + ) -> 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>, abstract_rule: AbstractRule, ectx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result<(Handle, Option>), Error<'source>> { + ) -> Result<'source, (Handle, Option>)> { 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> { + ) -> 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::, _>>()?; + .collect::>>()?; 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>, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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> { + ) -> 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::, Vec<_>), _>>()?; + .collect::, 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::>()?; + .collect::>()?; crate::Statement::Switch { selector, cases } } @@ -1959,7 +1960,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { &mut self, expr: Handle>, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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>, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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>, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result>, Error<'source>> { + ) -> Result<'source, Typed>> { 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>, span: Span, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Typed> { // 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>], ctx: &mut ExpressionContext<'source, '_, '_>, is_statement: bool, - ) -> Result>, Error<'source>> { + ) -> Result<'source, Option>> { 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::, _>>()?; + .collect::>>()?; let has_result = ctx.module.functions[function].result.is_some(); @@ -2934,7 +2935,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { &mut self, expr: Handle>, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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>], is_statement: bool, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result>, Error<'source>> { + ) -> Result<'source, Option>> { 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>], span: Span, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result> { + ) -> 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, Span), Error<'source>> { + ) -> Result<'source, (Handle, 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>], ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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>], ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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, Error<'source>> { + ) -> Result<'source, Handle> { 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>, 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> { + ) -> 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>, ctx: &mut ExpressionContext<'source, '_, '_>, span: Span, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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>, name: Option, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { 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>, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { self.resolve_named_ast_type(handle, None, ctx) } @@ -3484,7 +3485,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { binding: &Option>, ty: Handle, ctx: &mut GlobalContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Option> { 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>, ctx: &mut ExpressionContext<'source, '_, '_>, - ) -> Result, Error<'source>> { + ) -> Result<'source, Handle> { let span = ctx.ast_expressions.get_span(expr); let pointer = self.expression(expr, ctx)?; diff --git a/naga/src/front/wgsl/mod.rs b/naga/src/front/wgsl/mod.rs index dc97298acd..a10ebe43ad 100644 --- a/naga/src/front/wgsl/mod.rs +++ b/naga/src/front/wgsl/mod.rs @@ -27,6 +27,8 @@ use crate::Scalar; #[cfg(test)] use std::println; +pub(crate) type Result<'a, T> = core::result::Result>; + pub struct Frontend { parser: Parser, } @@ -38,11 +40,11 @@ impl Frontend { } } - pub fn parse(&mut self, source: &str) -> Result { + pub fn parse(&mut self, source: &str) -> core::result::Result { self.inner(source).map_err(|x| x.as_parse_error(source)) } - fn inner<'a>(&mut self, source: &'a str) -> Result> { + 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. /// /// -pub fn parse_str(source: &str) -> Result { +pub fn parse_str(source: &str) -> core::result::Result { Frontend::new().parse(source) } diff --git a/naga/src/front/wgsl/parse/conv.rs b/naga/src/front/wgsl/parse/conv.rs index 00c19d877d..1f99ecd5ba 100644 --- a/naga/src/front/wgsl/parse/conv.rs +++ b/naga/src/front/wgsl/parse/conv.rs @@ -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> { +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 Result> { +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> }) } -pub fn map_interpolation(word: &str, span: Span) -> Result> { +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 Result> { +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 } } -pub fn map_storage_format(word: &str, span: Span) -> Result> { +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 { pub fn map_conservative_depth( word: &str, span: Span, -) -> Result> { +) -> Result<'_, crate::ConservativeDepth> { use crate::ConservativeDepth as Cd; match word { "greater_equal" => Ok(Cd::GreaterEqual), diff --git a/naga/src/front/wgsl/parse/directive.rs b/naga/src/front/wgsl/parse/directive.rs index 3a661bc585..7a4edde11a 100644 --- a/naga/src/front/wgsl/parse/directive.rs +++ b/naga/src/front/wgsl/parse/directive.rs @@ -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)); diff --git a/naga/src/front/wgsl/parse/directive/enable_extension.rs b/naga/src/front/wgsl/parse/directive/enable_extension.rs index 6096417480..4c10e08d40 100644 --- a/naga/src/front/wgsl/parse/directive/enable_extension.rs +++ b/naga/src/front/wgsl/parse/directive/enable_extension.rs @@ -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> { + pub(crate) fn from_ident(word: &str, span: Span) -> Result { Ok(match word { Self::F16 => Self::Unimplemented(UnimplementedEnableExtension::F16), Self::CLIP_DISTANCES => { diff --git a/naga/src/front/wgsl/parse/lexer.rs b/naga/src/front/wgsl/parse/lexer.rs index 12b4534617..ac3cb973fc 100644 --- a/naga/src/front/wgsl/parse/lexer.rs +++ b/naga/src/front/wgsl/parse/lexer.rs @@ -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(core::result::Result), Word(&'a str), Operation(char), LogicalOperation(char), @@ -242,8 +242,8 @@ impl<'a> Lexer<'a> { #[inline] pub fn capture_span( &mut self, - inner: impl FnOnce(&mut Self) -> Result, - ) -> Result<(T, Span), E> { + inner: impl FnOnce(&mut Self) -> core::result::Result, + ) -> 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> { + ) -> 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, 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 ``. - pub(in crate::front::wgsl) fn next_scalar_generic(&mut self) -> Result> { + 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> { + ) -> 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> { + ) -> 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> { + 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)) diff --git a/naga/src/front/wgsl/parse/mod.rs b/naga/src/front/wgsl/parse/mod.rs index 6b9be15312..629d7cdf14 100644 --- a/naga/src/front/wgsl/parse/mod.rs +++ b/naga/src/front/wgsl/parse/mod.rs @@ -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>, Error<'a>>, - ) -> Result>, Error<'a>> { + ) -> Result<'a, Handle>>, + ) -> Result<'a, Handle>> { 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, Error<'a>> { + fn declare_local(&mut self, name: ast::Ident<'a>) -> Result<'a, Handle> { 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 Default for ParsedAttribute { } impl ParsedAttribute { - 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>, Error<'a>> { + fn finish(self, span: Span) -> Result<'a, Option>> { 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> + fn track_recursion<'a, F, R>(&mut self, f: F) -> Result<'a, R> where - F: FnOnce(&mut Self) -> Result>, + 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, 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>, Error<'a>> { + ) -> Result<'a, Option>> { 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>>, Error<'a>> { + ) -> Result<'a, Vec>>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, - ) -> Result>, Error<'a>> { + ) -> Result<'a, Handle>> { let mut expr = expr; loop { @@ -887,7 +887,7 @@ impl Parser { &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, - ) -> Result>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { // equality_expression context.parse_binary_op( lexer, @@ -1115,7 +1115,7 @@ impl Parser { &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, - ) -> Result>, Error<'a>> { + ) -> Result<'a, Handle>> { 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>, Span), Error<'a>> { + ) -> Result<'a, (Handle>, 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, 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>, Error<'a>> { + ) -> Result<'a, Vec>> { 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>, Span), Error<'a>> { + ) -> Result<'a, (Handle>, 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, 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>, Error<'a>> { + ) -> Result<'a, Option>> { 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>, Error<'a>> { + ) -> Result<'a, Handle>> { self.track_recursion(|this| { this.push_rule_span(Rule::TypeDecl, lexer); @@ -1786,7 +1786,7 @@ impl Parser { block: &mut ast::Block<'a>, target: Handle>, 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, 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>, Error<'a>> { + ) -> Result<'a, Option>> { let mut bind_parser = BindingParser::default(); self.push_rule_span(Rule::Attribute, lexer); @@ -2454,7 +2454,7 @@ impl Parser { must_use: Option, out: &mut ast::TranslationUnit<'a>, dependencies: &mut FastIndexSet>, - ) -> Result, 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, 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> { + ) -> 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> { + 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()?;