Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 2318 insertions, 0 deletions

diff --git a/third_party/rust/naga/src/front/glsl/parser/declarations.rs b/third_party/rust/naga/src/front/glsl/parser/declarations.rs
new file mode 100644
index 0000000000..f5e38fb016
--- /dev/null
+++ b/third_party/rust/naga/src/front/glsl/parser/declarations.rs
@@ -0,0 +1,677 @@
+use crate::{
+    front::glsl::{
+        ast::{
+            GlobalLookup, GlobalLookupKind, Precision, QualifierKey, QualifierValue,
+            StorageQualifier, StructLayout, TypeQualifiers,
+        },
+        context::{Context, ExprPos},
+        error::ExpectedToken,
+        offset,
+        token::{Token, TokenValue},
+        types::scalar_components,
+        variables::{GlobalOrConstant, VarDeclaration},
+        Error, ErrorKind, Frontend, Span,
+    },
+    proc::Alignment,
+    AddressSpace, Expression, FunctionResult, Handle, Scalar, ScalarKind, Statement, StructMember,
+    Type, TypeInner,
+};
+
+use super::{DeclarationContext, ParsingContext, Result};
+
+/// Helper method used to retrieve the child type of `ty` at
+/// index `i`.
+///
+/// # Note
+///
+/// Does not check if the index is valid and returns the same type
+/// when indexing out-of-bounds a struct or indexing a non indexable
+/// type.
+fn element_or_member_type(
+    ty: Handle<Type>,
+    i: usize,
+    types: &mut crate::UniqueArena<Type>,
+) -> Handle<Type> {
+    match types[ty].inner {
+        // The child type of a vector is a scalar of the same kind and width
+        TypeInner::Vector { scalar, .. } => types.insert(
+            Type {
+                name: None,
+                inner: TypeInner::Scalar(scalar),
+            },
+            Default::default(),
+        ),
+        // The child type of a matrix is a vector of floats with the same
+        // width and the size of the matrix rows.
+        TypeInner::Matrix { rows, scalar, .. } => types.insert(
+            Type {
+                name: None,
+                inner: TypeInner::Vector { size: rows, scalar },
+            },
+            Default::default(),
+        ),
+        // The child type of an array is the base type of the array
+        TypeInner::Array { base, .. } => base,
+        // The child type of a struct at index `i` is the type of it's
+        // member at that same index.
+        //
+        // In case the index is out of bounds the same type is returned
+        TypeInner::Struct { ref members, .. } => {
+            members.get(i).map(|member| member.ty).unwrap_or(ty)
+        }
+        // The type isn't indexable, the same type is returned
+        _ => ty,
+    }
+}
+
+impl<'source> ParsingContext<'source> {
+    pub fn parse_external_declaration(
+        &mut self,
+        frontend: &mut Frontend,
+        global_ctx: &mut Context,
+    ) -> Result<()> {
+        if self
+            .parse_declaration(frontend, global_ctx, true, false)?
+            .is_none()
+        {
+            let token = self.bump(frontend)?;
+            match token.value {
+                TokenValue::Semicolon if frontend.meta.version == 460 => Ok(()),
+                _ => {
+                    let expected = match frontend.meta.version {
+                        460 => vec![TokenValue::Semicolon.into(), ExpectedToken::Eof],
+                        _ => vec![ExpectedToken::Eof],
+                    };
+                    Err(Error {
+                        kind: ErrorKind::InvalidToken(token.value, expected),
+                        meta: token.meta,
+                    })
+                }
+            }
+        } else {
+            Ok(())
+        }
+    }
+
+    pub fn parse_initializer(
+        &mut self,
+        frontend: &mut Frontend,
+        ty: Handle<Type>,
+        ctx: &mut Context,
+    ) -> Result<(Handle<Expression>, Span)> {
+        // initializer:
+        //     assignment_expression
+        //     LEFT_BRACE initializer_list RIGHT_BRACE
+        //     LEFT_BRACE initializer_list COMMA RIGHT_BRACE
+        //
+        // initializer_list:
+        //     initializer
+        //     initializer_list COMMA initializer
+        if let Some(Token { mut meta, .. }) = self.bump_if(frontend, TokenValue::LeftBrace) {
+            // initializer_list
+            let mut components = Vec::new();
+            loop {
+                // The type expected to be parsed inside the initializer list
+                let new_ty = element_or_member_type(ty, components.len(), &mut ctx.module.types);
+
+                components.push(self.parse_initializer(frontend, new_ty, ctx)?.0);
+
+                let token = self.bump(frontend)?;
+                match token.value {
+                    TokenValue::Comma => {
+                        if let Some(Token { meta: end_meta, .. }) =
+                            self.bump_if(frontend, TokenValue::RightBrace)
+                        {
+                            meta.subsume(end_meta);
+                            break;
+                        }
+                    }
+                    TokenValue::RightBrace => {
+                        meta.subsume(token.meta);
+                        break;
+                    }
+                    _ => {
+                        return Err(Error {
+                            kind: ErrorKind::InvalidToken(
+                                token.value,
+                                vec![TokenValue::Comma.into(), TokenValue::RightBrace.into()],
+                            ),
+                            meta: token.meta,
+                        })
+                    }
+                }
+            }
+
+            Ok((
+                ctx.add_expression(Expression::Compose { ty, components }, meta)?,
+                meta,
+            ))
+        } else {
+            let mut stmt = ctx.stmt_ctx();
+            let expr = self.parse_assignment(frontend, ctx, &mut stmt)?;
+            let (mut init, init_meta) = ctx.lower_expect(stmt, frontend, expr, ExprPos::Rhs)?;
+
+            let scalar_components = scalar_components(&ctx.module.types[ty].inner);
+            if let Some(scalar) = scalar_components {
+                ctx.implicit_conversion(&mut init, init_meta, scalar)?;
+            }
+
+            Ok((init, init_meta))
+        }
+    }
+
+    // Note: caller preparsed the type and qualifiers
+    // Note: caller skips this if the fallthrough token is not expected to be consumed here so this
+    // produced Error::InvalidToken if it isn't consumed
+    pub fn parse_init_declarator_list(
+        &mut self,
+        frontend: &mut Frontend,
+        mut ty: Handle<Type>,
+        ctx: &mut DeclarationContext,
+    ) -> Result<()> {
+        // init_declarator_list:
+        //     single_declaration
+        //     init_declarator_list COMMA IDENTIFIER
+        //     init_declarator_list COMMA IDENTIFIER array_specifier
+        //     init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer
+        //     init_declarator_list COMMA IDENTIFIER EQUAL initializer
+        //
+        // single_declaration:
+        //     fully_specified_type
+        //     fully_specified_type IDENTIFIER
+        //     fully_specified_type IDENTIFIER array_specifier
+        //     fully_specified_type IDENTIFIER array_specifier EQUAL initializer
+        //     fully_specified_type IDENTIFIER EQUAL initializer
+
+        // Consume any leading comma, e.g. this is valid: `float, a=1;`
+        if self
+            .peek(frontend)
+            .map_or(false, |t| t.value == TokenValue::Comma)
+        {
+            self.next(frontend);
+        }
+
+        loop {
+            let token = self.bump(frontend)?;
+            let name = match token.value {
+                TokenValue::Semicolon => break,
+                TokenValue::Identifier(name) => name,
+                _ => {
+                    return Err(Error {
+                        kind: ErrorKind::InvalidToken(
+                            token.value,
+                            vec![ExpectedToken::Identifier, TokenValue::Semicolon.into()],
+                        ),
+                        meta: token.meta,
+                    })
+                }
+            };
+            let mut meta = token.meta;
+
+            // array_specifier
+            // array_specifier EQUAL initializer
+            // EQUAL initializer
+
+            // parse an array specifier if it exists
+            // NOTE: unlike other parse methods this one doesn't expect an array specifier and
+            // returns Ok(None) rather than an error if there is not one
+            self.parse_array_specifier(frontend, ctx.ctx, &mut meta, &mut ty)?;
+
+            let is_global_const =
+                ctx.qualifiers.storage.0 == StorageQualifier::Const && ctx.external;
+
+            let init = self
+                .bump_if(frontend, TokenValue::Assign)
+                .map::<Result<_>, _>(|_| {
+                    let prev_const = ctx.ctx.is_const;
+                    ctx.ctx.is_const = is_global_const;
+
+                    let (mut expr, init_meta) = self.parse_initializer(frontend, ty, ctx.ctx)?;
+
+                    let scalar_components = scalar_components(&ctx.ctx.module.types[ty].inner);
+                    if let Some(scalar) = scalar_components {
+                        ctx.ctx.implicit_conversion(&mut expr, init_meta, scalar)?;
+                    }
+
+                    ctx.ctx.is_const = prev_const;
+
+                    meta.subsume(init_meta);
+
+                    Ok(expr)
+                })
+                .transpose()?;
+
+            let decl_initializer;
+            let late_initializer;
+            if is_global_const {
+                decl_initializer = init;
+                late_initializer = None;
+            } else if ctx.external {
+                decl_initializer =
+                    init.and_then(|expr| ctx.ctx.lift_up_const_expression(expr).ok());
+                late_initializer = None;
+            } else if let Some(init) = init {
+                if ctx.is_inside_loop || !ctx.ctx.expression_constness.is_const(init) {
+                    decl_initializer = None;
+                    late_initializer = Some(init);
+                } else {
+                    decl_initializer = Some(init);
+                    late_initializer = None;
+                }
+            } else {
+                decl_initializer = None;
+                late_initializer = None;
+            };
+
+            let pointer = ctx.add_var(frontend, ty, name, decl_initializer, meta)?;
+
+            if let Some(value) = late_initializer {
+                ctx.ctx.emit_restart();
+                ctx.ctx.body.push(Statement::Store { pointer, value }, meta);
+            }
+
+            let token = self.bump(frontend)?;
+            match token.value {
+                TokenValue::Semicolon => break,
+                TokenValue::Comma => {}
+                _ => {
+                    return Err(Error {
+                        kind: ErrorKind::InvalidToken(
+                            token.value,
+                            vec![TokenValue::Comma.into(), TokenValue::Semicolon.into()],
+                        ),
+                        meta: token.meta,
+                    })
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// `external` whether or not we are in a global or local context
+    pub fn parse_declaration(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        external: bool,
+        is_inside_loop: bool,
+    ) -> Result<Option<Span>> {
+        //declaration:
+        //    function_prototype  SEMICOLON
+        //
+        //    init_declarator_list SEMICOLON
+        //    PRECISION precision_qualifier type_specifier SEMICOLON
+        //
+        //    type_qualifier IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE SEMICOLON
+        //    type_qualifier IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE IDENTIFIER SEMICOLON
+        //    type_qualifier IDENTIFIER LEFT_BRACE struct_declaration_list RIGHT_BRACE IDENTIFIER array_specifier SEMICOLON
+        //    type_qualifier SEMICOLON type_qualifier IDENTIFIER SEMICOLON
+        //    type_qualifier IDENTIFIER identifier_list SEMICOLON
+
+        if self.peek_type_qualifier(frontend) || self.peek_type_name(frontend) {
+            let mut qualifiers = self.parse_type_qualifiers(frontend, ctx)?;
+
+            if self.peek_type_name(frontend) {
+                // This branch handles variables and function prototypes and if
+                // external is true also function definitions
+                let (ty, mut meta) = self.parse_type(frontend, ctx)?;
+
+                let token = self.bump(frontend)?;
+                let token_fallthrough = match token.value {
+                    TokenValue::Identifier(name) => match self.expect_peek(frontend)?.value {
+                        TokenValue::LeftParen => {
+                            // This branch handles function definition and prototypes
+                            self.bump(frontend)?;
+
+                            let result = ty.map(|ty| FunctionResult { ty, binding: None });
+
+                            let mut context = Context::new(frontend, ctx.module, false)?;
+
+                            self.parse_function_args(frontend, &mut context)?;
+
+                            let end_meta = self.expect(frontend, TokenValue::RightParen)?.meta;
+                            meta.subsume(end_meta);
+
+                            let token = self.bump(frontend)?;
+                            return match token.value {
+                                TokenValue::Semicolon => {
+                                    // This branch handles function prototypes
+                                    frontend.add_prototype(context, name, result, meta);
+
+                                    Ok(Some(meta))
+                                }
+                                TokenValue::LeftBrace if external => {
+                                    // This branch handles function definitions
+                                    // as you can see by the guard this branch
+                                    // only happens if external is also true
+
+                                    // parse the body
+                                    self.parse_compound_statement(
+                                        token.meta,
+                                        frontend,
+                                        &mut context,
+                                        &mut None,
+                                        false,
+                                    )?;
+
+                                    frontend.add_function(context, name, result, meta);
+
+                                    Ok(Some(meta))
+                                }
+                                _ if external => Err(Error {
+                                    kind: ErrorKind::InvalidToken(
+                                        token.value,
+                                        vec![
+                                            TokenValue::LeftBrace.into(),
+                                            TokenValue::Semicolon.into(),
+                                        ],
+                                    ),
+                                    meta: token.meta,
+                                }),
+                                _ => Err(Error {
+                                    kind: ErrorKind::InvalidToken(
+                                        token.value,
+                                        vec![TokenValue::Semicolon.into()],
+                                    ),
+                                    meta: token.meta,
+                                }),
+                            };
+                        }
+                        // Pass the token to the init_declarator_list parser
+                        _ => Token {
+                            value: TokenValue::Identifier(name),
+                            meta: token.meta,
+                        },
+                    },
+                    // Pass the token to the init_declarator_list parser
+                    _ => token,
+                };
+
+                // If program execution has reached here then this will be a
+                // init_declarator_list
+                // token_fallthrough will have a token that was already bumped
+                if let Some(ty) = ty {
+                    let mut ctx = DeclarationContext {
+                        qualifiers,
+                        external,
+                        is_inside_loop,
+                        ctx,
+                    };
+
+                    self.backtrack(token_fallthrough)?;
+                    self.parse_init_declarator_list(frontend, ty, &mut ctx)?;
+                } else {
+                    frontend.errors.push(Error {
+                        kind: ErrorKind::SemanticError("Declaration cannot have void type".into()),
+                        meta,
+                    })
+                }
+
+                Ok(Some(meta))
+            } else {
+                // This branch handles struct definitions and modifiers like
+                // ```glsl
+                // layout(early_fragment_tests);
+                // ```
+                let token = self.bump(frontend)?;
+                match token.value {
+                    TokenValue::Identifier(ty_name) => {
+                        if self.bump_if(frontend, TokenValue::LeftBrace).is_some() {
+                            self.parse_block_declaration(
+                                frontend,
+                                ctx,
+                                &mut qualifiers,
+                                ty_name,
+                                token.meta,
+                            )
+                            .map(Some)
+                        } else {
+                            if qualifiers.invariant.take().is_some() {
+                                frontend.make_variable_invariant(ctx, &ty_name, token.meta)?;
+
+                                qualifiers.unused_errors(&mut frontend.errors);
+                                self.expect(frontend, TokenValue::Semicolon)?;
+                                return Ok(Some(qualifiers.span));
+                            }
+
+                            //TODO: declaration
+                            // type_qualifier IDENTIFIER SEMICOLON
+                            // type_qualifier IDENTIFIER identifier_list SEMICOLON
+                            Err(Error {
+                                kind: ErrorKind::NotImplemented("variable qualifier"),
+                                meta: token.meta,
+                            })
+                        }
+                    }
+                    TokenValue::Semicolon => {
+                        if let Some(value) =
+                            qualifiers.uint_layout_qualifier("local_size_x", &mut frontend.errors)
+                        {
+                            frontend.meta.workgroup_size[0] = value;
+                        }
+                        if let Some(value) =
+                            qualifiers.uint_layout_qualifier("local_size_y", &mut frontend.errors)
+                        {
+                            frontend.meta.workgroup_size[1] = value;
+                        }
+                        if let Some(value) =
+                            qualifiers.uint_layout_qualifier("local_size_z", &mut frontend.errors)
+                        {
+                            frontend.meta.workgroup_size[2] = value;
+                        }
+
+                        frontend.meta.early_fragment_tests |= qualifiers
+                            .none_layout_qualifier("early_fragment_tests", &mut frontend.errors);
+
+                        qualifiers.unused_errors(&mut frontend.errors);
+
+                        Ok(Some(qualifiers.span))
+                    }
+                    _ => Err(Error {
+                        kind: ErrorKind::InvalidToken(
+                            token.value,
+                            vec![ExpectedToken::Identifier, TokenValue::Semicolon.into()],
+                        ),
+                        meta: token.meta,
+                    }),
+                }
+            }
+        } else {
+            match self.peek(frontend).map(|t| &t.value) {
+                Some(&TokenValue::Precision) => {
+                    // PRECISION precision_qualifier type_specifier SEMICOLON
+                    self.bump(frontend)?;
+
+                    let token = self.bump(frontend)?;
+                    let _ = match token.value {
+                        TokenValue::PrecisionQualifier(p) => p,
+                        _ => {
+                            return Err(Error {
+                                kind: ErrorKind::InvalidToken(
+                                    token.value,
+                                    vec![
+                                        TokenValue::PrecisionQualifier(Precision::High).into(),
+                                        TokenValue::PrecisionQualifier(Precision::Medium).into(),
+                                        TokenValue::PrecisionQualifier(Precision::Low).into(),
+                                    ],
+                                ),
+                                meta: token.meta,
+                            })
+                        }
+                    };
+
+                    let (ty, meta) = self.parse_type_non_void(frontend, ctx)?;
+
+                    match ctx.module.types[ty].inner {
+                        TypeInner::Scalar(Scalar {
+                            kind: ScalarKind::Float | ScalarKind::Sint,
+                            ..
+                        }) => {}
+                        _ => frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "Precision statement can only work on floats and ints".into(),
+                            ),
+                            meta,
+                        }),
+                    }
+
+                    self.expect(frontend, TokenValue::Semicolon)?;
+
+                    Ok(Some(meta))
+                }
+                _ => Ok(None),
+            }
+        }
+    }
+
+    pub fn parse_block_declaration(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        qualifiers: &mut TypeQualifiers,
+        ty_name: String,
+        mut meta: Span,
+    ) -> Result<Span> {
+        let layout = match qualifiers.layout_qualifiers.remove(&QualifierKey::Layout) {
+            Some((QualifierValue::Layout(l), _)) => l,
+            None => {
+                if let StorageQualifier::AddressSpace(AddressSpace::Storage { .. }) =
+                    qualifiers.storage.0
+                {
+                    StructLayout::Std430
+                } else {
+                    StructLayout::Std140
+                }
+            }
+            _ => unreachable!(),
+        };
+
+        let mut members = Vec::new();
+        let span = self.parse_struct_declaration_list(frontend, ctx, &mut members, layout)?;
+        self.expect(frontend, TokenValue::RightBrace)?;
+
+        let mut ty = ctx.module.types.insert(
+            Type {
+                name: Some(ty_name),
+                inner: TypeInner::Struct {
+                    members: members.clone(),
+                    span,
+                },
+            },
+            Default::default(),
+        );
+
+        let token = self.bump(frontend)?;
+        let name = match token.value {
+            TokenValue::Semicolon => None,
+            TokenValue::Identifier(name) => {
+                self.parse_array_specifier(frontend, ctx, &mut meta, &mut ty)?;
+
+                self.expect(frontend, TokenValue::Semicolon)?;
+
+                Some(name)
+            }
+            _ => {
+                return Err(Error {
+                    kind: ErrorKind::InvalidToken(
+                        token.value,
+                        vec![ExpectedToken::Identifier, TokenValue::Semicolon.into()],
+                    ),
+                    meta: token.meta,
+                })
+            }
+        };
+
+        let global = frontend.add_global_var(
+            ctx,
+            VarDeclaration {
+                qualifiers,
+                ty,
+                name,
+                init: None,
+                meta,
+            },
+        )?;
+
+        for (i, k, ty) in members.into_iter().enumerate().filter_map(|(i, m)| {
+            let ty = m.ty;
+            m.name.map(|s| (i as u32, s, ty))
+        }) {
+            let lookup = GlobalLookup {
+                kind: match global {
+                    GlobalOrConstant::Global(handle) => GlobalLookupKind::BlockSelect(handle, i),
+                    GlobalOrConstant::Constant(handle) => GlobalLookupKind::Constant(handle, ty),
+                },
+                entry_arg: None,
+                mutable: true,
+            };
+            ctx.add_global(&k, lookup)?;
+
+            frontend.global_variables.push((k, lookup));
+        }
+
+        Ok(meta)
+    }
+
+    // TODO: Accept layout arguments
+    pub fn parse_struct_declaration_list(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        members: &mut Vec<StructMember>,
+        layout: StructLayout,
+    ) -> Result<u32> {
+        let mut span = 0;
+        let mut align = Alignment::ONE;
+
+        loop {
+            // TODO: type_qualifier
+
+            let (base_ty, mut meta) = self.parse_type_non_void(frontend, ctx)?;
+
+            loop {
+                let (name, name_meta) = self.expect_ident(frontend)?;
+                let mut ty = base_ty;
+                self.parse_array_specifier(frontend, ctx, &mut meta, &mut ty)?;
+
+                meta.subsume(name_meta);
+
+                let info = offset::calculate_offset(
+                    ty,
+                    meta,
+                    layout,
+                    &mut ctx.module.types,
+                    &mut frontend.errors,
+                );
+
+                let member_alignment = info.align;
+                span = member_alignment.round_up(span);
+                align = member_alignment.max(align);
+
+                members.push(StructMember {
+                    name: Some(name),
+                    ty: info.ty,
+                    binding: None,
+                    offset: span,
+                });
+
+                span += info.span;
+
+                if self.bump_if(frontend, TokenValue::Comma).is_none() {
+                    break;
+                }
+            }
+
+            self.expect(frontend, TokenValue::Semicolon)?;
+
+            if let TokenValue::RightBrace = self.expect_peek(frontend)?.value {
+                break;
+            }
+        }
+
+        span = align.round_up(span);
+
+        Ok(span)
+    }
+}
diff --git a/third_party/rust/naga/src/front/glsl/parser/expressions.rs b/third_party/rust/naga/src/front/glsl/parser/expressions.rs
new file mode 100644
index 0000000000..1b8febce90
--- /dev/null
+++ b/third_party/rust/naga/src/front/glsl/parser/expressions.rs
@@ -0,0 +1,542 @@
+use std::num::NonZeroU32;
+
+use crate::{
+    front::glsl::{
+        ast::{FunctionCall, FunctionCallKind, HirExpr, HirExprKind},
+        context::{Context, StmtContext},
+        error::{ErrorKind, ExpectedToken},
+        parser::ParsingContext,
+        token::{Token, TokenValue},
+        Error, Frontend, Result, Span,
+    },
+    ArraySize, BinaryOperator, Handle, Literal, Type, TypeInner, UnaryOperator,
+};
+
+impl<'source> ParsingContext<'source> {
+    pub fn parse_primary(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+    ) -> Result<Handle<HirExpr>> {
+        let mut token = self.bump(frontend)?;
+
+        let literal = match token.value {
+            TokenValue::IntConstant(int) => {
+                if int.width != 32 {
+                    frontend.errors.push(Error {
+                        kind: ErrorKind::SemanticError("Unsupported non-32bit integer".into()),
+                        meta: token.meta,
+                    });
+                }
+                if int.signed {
+                    Literal::I32(int.value as i32)
+                } else {
+                    Literal::U32(int.value as u32)
+                }
+            }
+            TokenValue::FloatConstant(float) => {
+                if float.width != 32 {
+                    frontend.errors.push(Error {
+                        kind: ErrorKind::SemanticError("Unsupported floating-point value (expected single-precision floating-point number)".into()),
+                        meta: token.meta,
+                    });
+                }
+                Literal::F32(float.value)
+            }
+            TokenValue::BoolConstant(value) => Literal::Bool(value),
+            TokenValue::LeftParen => {
+                let expr = self.parse_expression(frontend, ctx, stmt)?;
+                let meta = self.expect(frontend, TokenValue::RightParen)?.meta;
+
+                token.meta.subsume(meta);
+
+                return Ok(expr);
+            }
+            _ => {
+                return Err(Error {
+                    kind: ErrorKind::InvalidToken(
+                        token.value,
+                        vec![
+                            TokenValue::LeftParen.into(),
+                            ExpectedToken::IntLiteral,
+                            ExpectedToken::FloatLiteral,
+                            ExpectedToken::BoolLiteral,
+                        ],
+                    ),
+                    meta: token.meta,
+                });
+            }
+        };
+
+        Ok(stmt.hir_exprs.append(
+            HirExpr {
+                kind: HirExprKind::Literal(literal),
+                meta: token.meta,
+            },
+            Default::default(),
+        ))
+    }
+
+    pub fn parse_function_call_args(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+        meta: &mut Span,
+    ) -> Result<Vec<Handle<HirExpr>>> {
+        let mut args = Vec::new();
+        if let Some(token) = self.bump_if(frontend, TokenValue::RightParen) {
+            meta.subsume(token.meta);
+        } else {
+            loop {
+                args.push(self.parse_assignment(frontend, ctx, stmt)?);
+
+                let token = self.bump(frontend)?;
+                match token.value {
+                    TokenValue::Comma => {}
+                    TokenValue::RightParen => {
+                        meta.subsume(token.meta);
+                        break;
+                    }
+                    _ => {
+                        return Err(Error {
+                            kind: ErrorKind::InvalidToken(
+                                token.value,
+                                vec![TokenValue::Comma.into(), TokenValue::RightParen.into()],
+                            ),
+                            meta: token.meta,
+                        });
+                    }
+                }
+            }
+        }
+
+        Ok(args)
+    }
+
+    pub fn parse_postfix(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+    ) -> Result<Handle<HirExpr>> {
+        let mut base = if self.peek_type_name(frontend) {
+            let (mut handle, mut meta) = self.parse_type_non_void(frontend, ctx)?;
+
+            self.expect(frontend, TokenValue::LeftParen)?;
+            let args = self.parse_function_call_args(frontend, ctx, stmt, &mut meta)?;
+
+            if let TypeInner::Array {
+                size: ArraySize::Dynamic,
+                stride,
+                base,
+            } = ctx.module.types[handle].inner
+            {
+                let span = ctx.module.types.get_span(handle);
+
+                let size = u32::try_from(args.len())
+                    .ok()
+                    .and_then(NonZeroU32::new)
+                    .ok_or(Error {
+                        kind: ErrorKind::SemanticError(
+                            "There must be at least one argument".into(),
+                        ),
+                        meta,
+                    })?;
+
+                handle = ctx.module.types.insert(
+                    Type {
+                        name: None,
+                        inner: TypeInner::Array {
+                            stride,
+                            base,
+                            size: ArraySize::Constant(size),
+                        },
+                    },
+                    span,
+                )
+            }
+
+            stmt.hir_exprs.append(
+                HirExpr {
+                    kind: HirExprKind::Call(FunctionCall {
+                        kind: FunctionCallKind::TypeConstructor(handle),
+                        args,
+                    }),
+                    meta,
+                },
+                Default::default(),
+            )
+        } else if let TokenValue::Identifier(_) = self.expect_peek(frontend)?.value {
+            let (name, mut meta) = self.expect_ident(frontend)?;
+
+            let expr = if self.bump_if(frontend, TokenValue::LeftParen).is_some() {
+                let args = self.parse_function_call_args(frontend, ctx, stmt, &mut meta)?;
+
+                let kind = match frontend.lookup_type.get(&name) {
+                    Some(ty) => FunctionCallKind::TypeConstructor(*ty),
+                    None => FunctionCallKind::Function(name),
+                };
+
+                HirExpr {
+                    kind: HirExprKind::Call(FunctionCall { kind, args }),
+                    meta,
+                }
+            } else {
+                let var = match frontend.lookup_variable(ctx, &name, meta)? {
+                    Some(var) => var,
+                    None => {
+                        return Err(Error {
+                            kind: ErrorKind::UnknownVariable(name),
+                            meta,
+                        })
+                    }
+                };
+
+                HirExpr {
+                    kind: HirExprKind::Variable(var),
+                    meta,
+                }
+            };
+
+            stmt.hir_exprs.append(expr, Default::default())
+        } else {
+            self.parse_primary(frontend, ctx, stmt)?
+        };
+
+        while let TokenValue::LeftBracket
+        | TokenValue::Dot
+        | TokenValue::Increment
+        | TokenValue::Decrement = self.expect_peek(frontend)?.value
+        {
+            let Token { value, mut meta } = self.bump(frontend)?;
+
+            match value {
+                TokenValue::LeftBracket => {
+                    let index = self.parse_expression(frontend, ctx, stmt)?;
+                    let end_meta = self.expect(frontend, TokenValue::RightBracket)?.meta;
+
+                    meta.subsume(end_meta);
+                    base = stmt.hir_exprs.append(
+                        HirExpr {
+                            kind: HirExprKind::Access { base, index },
+                            meta,
+                        },
+                        Default::default(),
+                    )
+                }
+                TokenValue::Dot => {
+                    let (field, end_meta) = self.expect_ident(frontend)?;
+
+                    if self.bump_if(frontend, TokenValue::LeftParen).is_some() {
+                        let args = self.parse_function_call_args(frontend, ctx, stmt, &mut meta)?;
+
+                        base = stmt.hir_exprs.append(
+                            HirExpr {
+                                kind: HirExprKind::Method {
+                                    expr: base,
+                                    name: field,
+                                    args,
+                                },
+                                meta,
+                            },
+                            Default::default(),
+                        );
+                        continue;
+                    }
+
+                    meta.subsume(end_meta);
+                    base = stmt.hir_exprs.append(
+                        HirExpr {
+                            kind: HirExprKind::Select { base, field },
+                            meta,
+                        },
+                        Default::default(),
+                    )
+                }
+                TokenValue::Increment | TokenValue::Decrement => {
+                    base = stmt.hir_exprs.append(
+                        HirExpr {
+                            kind: HirExprKind::PrePostfix {
+                                op: match value {
+                                    TokenValue::Increment => crate::BinaryOperator::Add,
+                                    _ => crate::BinaryOperator::Subtract,
+                                },
+                                postfix: true,
+                                expr: base,
+                            },
+                            meta,
+                        },
+                        Default::default(),
+                    )
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        Ok(base)
+    }
+
+    pub fn parse_unary(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+    ) -> Result<Handle<HirExpr>> {
+        Ok(match self.expect_peek(frontend)?.value {
+            TokenValue::Plus | TokenValue::Dash | TokenValue::Bang | TokenValue::Tilde => {
+                let Token { value, mut meta } = self.bump(frontend)?;
+
+                let expr = self.parse_unary(frontend, ctx, stmt)?;
+                let end_meta = stmt.hir_exprs[expr].meta;
+
+                let kind = match value {
+                    TokenValue::Dash => HirExprKind::Unary {
+                        op: UnaryOperator::Negate,
+                        expr,
+                    },
+                    TokenValue::Bang => HirExprKind::Unary {
+                        op: UnaryOperator::LogicalNot,
+                        expr,
+                    },
+                    TokenValue::Tilde => HirExprKind::Unary {
+                        op: UnaryOperator::BitwiseNot,
+                        expr,
+                    },
+                    _ => return Ok(expr),
+                };
+
+                meta.subsume(end_meta);
+                stmt.hir_exprs
+                    .append(HirExpr { kind, meta }, Default::default())
+            }
+            TokenValue::Increment | TokenValue::Decrement => {
+                let Token { value, meta } = self.bump(frontend)?;
+
+                let expr = self.parse_unary(frontend, ctx, stmt)?;
+
+                stmt.hir_exprs.append(
+                    HirExpr {
+                        kind: HirExprKind::PrePostfix {
+                            op: match value {
+                                TokenValue::Increment => crate::BinaryOperator::Add,
+                                _ => crate::BinaryOperator::Subtract,
+                            },
+                            postfix: false,
+                            expr,
+                        },
+                        meta,
+                    },
+                    Default::default(),
+                )
+            }
+            _ => self.parse_postfix(frontend, ctx, stmt)?,
+        })
+    }
+
+    pub fn parse_binary(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+        passthrough: Option<Handle<HirExpr>>,
+        min_bp: u8,
+    ) -> Result<Handle<HirExpr>> {
+        let mut left = passthrough
+            .ok_or(ErrorKind::EndOfFile /* Dummy error */)
+            .or_else(|_| self.parse_unary(frontend, ctx, stmt))?;
+        let mut meta = stmt.hir_exprs[left].meta;
+
+        while let Some((l_bp, r_bp)) = binding_power(&self.expect_peek(frontend)?.value) {
+            if l_bp < min_bp {
+                break;
+            }
+
+            let Token { value, .. } = self.bump(frontend)?;
+
+            let right = self.parse_binary(frontend, ctx, stmt, None, r_bp)?;
+            let end_meta = stmt.hir_exprs[right].meta;
+
+            meta.subsume(end_meta);
+            left = stmt.hir_exprs.append(
+                HirExpr {
+                    kind: HirExprKind::Binary {
+                        left,
+                        op: match value {
+                            TokenValue::LogicalOr => BinaryOperator::LogicalOr,
+                            TokenValue::LogicalXor => BinaryOperator::NotEqual,
+                            TokenValue::LogicalAnd => BinaryOperator::LogicalAnd,
+                            TokenValue::VerticalBar => BinaryOperator::InclusiveOr,
+                            TokenValue::Caret => BinaryOperator::ExclusiveOr,
+                            TokenValue::Ampersand => BinaryOperator::And,
+                            TokenValue::Equal => BinaryOperator::Equal,
+                            TokenValue::NotEqual => BinaryOperator::NotEqual,
+                            TokenValue::GreaterEqual => BinaryOperator::GreaterEqual,
+                            TokenValue::LessEqual => BinaryOperator::LessEqual,
+                            TokenValue::LeftAngle => BinaryOperator::Less,
+                            TokenValue::RightAngle => BinaryOperator::Greater,
+                            TokenValue::LeftShift => BinaryOperator::ShiftLeft,
+                            TokenValue::RightShift => BinaryOperator::ShiftRight,
+                            TokenValue::Plus => BinaryOperator::Add,
+                            TokenValue::Dash => BinaryOperator::Subtract,
+                            TokenValue::Star => BinaryOperator::Multiply,
+                            TokenValue::Slash => BinaryOperator::Divide,
+                            TokenValue::Percent => BinaryOperator::Modulo,
+                            _ => unreachable!(),
+                        },
+                        right,
+                    },
+                    meta,
+                },
+                Default::default(),
+            )
+        }
+
+        Ok(left)
+    }
+
+    pub fn parse_conditional(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+        passthrough: Option<Handle<HirExpr>>,
+    ) -> Result<Handle<HirExpr>> {
+        let mut condition = self.parse_binary(frontend, ctx, stmt, passthrough, 0)?;
+        let mut meta = stmt.hir_exprs[condition].meta;
+
+        if self.bump_if(frontend, TokenValue::Question).is_some() {
+            let accept = self.parse_expression(frontend, ctx, stmt)?;
+            self.expect(frontend, TokenValue::Colon)?;
+            let reject = self.parse_assignment(frontend, ctx, stmt)?;
+            let end_meta = stmt.hir_exprs[reject].meta;
+
+            meta.subsume(end_meta);
+            condition = stmt.hir_exprs.append(
+                HirExpr {
+                    kind: HirExprKind::Conditional {
+                        condition,
+                        accept,
+                        reject,
+                    },
+                    meta,
+                },
+                Default::default(),
+            )
+        }
+
+        Ok(condition)
+    }
+
+    pub fn parse_assignment(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+    ) -> Result<Handle<HirExpr>> {
+        let tgt = self.parse_unary(frontend, ctx, stmt)?;
+        let mut meta = stmt.hir_exprs[tgt].meta;
+
+        Ok(match self.expect_peek(frontend)?.value {
+            TokenValue::Assign => {
+                self.bump(frontend)?;
+                let value = self.parse_assignment(frontend, ctx, stmt)?;
+                let end_meta = stmt.hir_exprs[value].meta;
+
+                meta.subsume(end_meta);
+                stmt.hir_exprs.append(
+                    HirExpr {
+                        kind: HirExprKind::Assign { tgt, value },
+                        meta,
+                    },
+                    Default::default(),
+                )
+            }
+            TokenValue::OrAssign
+            | TokenValue::AndAssign
+            | TokenValue::AddAssign
+            | TokenValue::DivAssign
+            | TokenValue::ModAssign
+            | TokenValue::SubAssign
+            | TokenValue::MulAssign
+            | TokenValue::LeftShiftAssign
+            | TokenValue::RightShiftAssign
+            | TokenValue::XorAssign => {
+                let token = self.bump(frontend)?;
+                let right = self.parse_assignment(frontend, ctx, stmt)?;
+                let end_meta = stmt.hir_exprs[right].meta;
+
+                meta.subsume(end_meta);
+                let value = stmt.hir_exprs.append(
+                    HirExpr {
+                        meta,
+                        kind: HirExprKind::Binary {
+                            left: tgt,
+                            op: match token.value {
+                                TokenValue::OrAssign => BinaryOperator::InclusiveOr,
+                                TokenValue::AndAssign => BinaryOperator::And,
+                                TokenValue::AddAssign => BinaryOperator::Add,
+                                TokenValue::DivAssign => BinaryOperator::Divide,
+                                TokenValue::ModAssign => BinaryOperator::Modulo,
+                                TokenValue::SubAssign => BinaryOperator::Subtract,
+                                TokenValue::MulAssign => BinaryOperator::Multiply,
+                                TokenValue::LeftShiftAssign => BinaryOperator::ShiftLeft,
+                                TokenValue::RightShiftAssign => BinaryOperator::ShiftRight,
+                                TokenValue::XorAssign => BinaryOperator::ExclusiveOr,
+                                _ => unreachable!(),
+                            },
+                            right,
+                        },
+                    },
+                    Default::default(),
+                );
+
+                stmt.hir_exprs.append(
+                    HirExpr {
+                        kind: HirExprKind::Assign { tgt, value },
+                        meta,
+                    },
+                    Default::default(),
+                )
+            }
+            _ => self.parse_conditional(frontend, ctx, stmt, Some(tgt))?,
+        })
+    }
+
+    pub fn parse_expression(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        stmt: &mut StmtContext,
+    ) -> Result<Handle<HirExpr>> {
+        let mut expr = self.parse_assignment(frontend, ctx, stmt)?;
+
+        while let TokenValue::Comma = self.expect_peek(frontend)?.value {
+            self.bump(frontend)?;
+            expr = self.parse_assignment(frontend, ctx, stmt)?;
+        }
+
+        Ok(expr)
+    }
+}
+
+const fn binding_power(value: &TokenValue) -> Option<(u8, u8)> {
+    Some(match *value {
+        TokenValue::LogicalOr => (1, 2),
+        TokenValue::LogicalXor => (3, 4),
+        TokenValue::LogicalAnd => (5, 6),
+        TokenValue::VerticalBar => (7, 8),
+        TokenValue::Caret => (9, 10),
+        TokenValue::Ampersand => (11, 12),
+        TokenValue::Equal | TokenValue::NotEqual => (13, 14),
+        TokenValue::GreaterEqual
+        | TokenValue::LessEqual
+        | TokenValue::LeftAngle
+        | TokenValue::RightAngle => (15, 16),
+        TokenValue::LeftShift | TokenValue::RightShift => (17, 18),
+        TokenValue::Plus | TokenValue::Dash => (19, 20),
+        TokenValue::Star | TokenValue::Slash | TokenValue::Percent => (21, 22),
+        _ => return None,
+    })
+}
diff --git a/third_party/rust/naga/src/front/glsl/parser/functions.rs b/third_party/rust/naga/src/front/glsl/parser/functions.rs
new file mode 100644
index 0000000000..38184eedf7
--- /dev/null
+++ b/third_party/rust/naga/src/front/glsl/parser/functions.rs
@@ -0,0 +1,656 @@
+use crate::front::glsl::context::ExprPos;
+use crate::front::glsl::Span;
+use crate::Literal;
+use crate::{
+    front::glsl::{
+        ast::ParameterQualifier,
+        context::Context,
+        parser::ParsingContext,
+        token::{Token, TokenValue},
+        variables::VarDeclaration,
+        Error, ErrorKind, Frontend, Result,
+    },
+    Block, Expression, Statement, SwitchCase, UnaryOperator,
+};
+
+impl<'source> ParsingContext<'source> {
+    pub fn peek_parameter_qualifier(&mut self, frontend: &mut Frontend) -> bool {
+        self.peek(frontend).map_or(false, |t| match t.value {
+            TokenValue::In | TokenValue::Out | TokenValue::InOut | TokenValue::Const => true,
+            _ => false,
+        })
+    }
+
+    /// Returns the parsed `ParameterQualifier` or `ParameterQualifier::In`
+    pub fn parse_parameter_qualifier(&mut self, frontend: &mut Frontend) -> ParameterQualifier {
+        if self.peek_parameter_qualifier(frontend) {
+            match self.bump(frontend).unwrap().value {
+                TokenValue::In => ParameterQualifier::In,
+                TokenValue::Out => ParameterQualifier::Out,
+                TokenValue::InOut => ParameterQualifier::InOut,
+                TokenValue::Const => ParameterQualifier::Const,
+                _ => unreachable!(),
+            }
+        } else {
+            ParameterQualifier::In
+        }
+    }
+
+    pub fn parse_statement(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        terminator: &mut Option<usize>,
+        is_inside_loop: bool,
+    ) -> Result<Option<Span>> {
+        // Type qualifiers always identify a declaration statement
+        if self.peek_type_qualifier(frontend) {
+            return self.parse_declaration(frontend, ctx, false, is_inside_loop);
+        }
+
+        // Type names can identify either declaration statements or type constructors
+        // depending on whether the token following the type name is a `(` (LeftParen)
+        if self.peek_type_name(frontend) {
+            // Start by consuming the type name so that we can peek the token after it
+            let token = self.bump(frontend)?;
+            // Peek the next token and check if it's a `(` (LeftParen) if so the statement
+            // is a constructor, otherwise it's a declaration. We need to do the check
+            // beforehand and not in the if since we will backtrack before the if
+            let declaration = TokenValue::LeftParen != self.expect_peek(frontend)?.value;
+
+            self.backtrack(token)?;
+
+            if declaration {
+                return self.parse_declaration(frontend, ctx, false, is_inside_loop);
+            }
+        }
+
+        let new_break = || {
+            let mut block = Block::new();
+            block.push(Statement::Break, crate::Span::default());
+            block
+        };
+
+        let &Token {
+            ref value,
+            mut meta,
+        } = self.expect_peek(frontend)?;
+
+        let meta_rest = match *value {
+            TokenValue::Continue => {
+                let meta = self.bump(frontend)?.meta;
+                ctx.body.push(Statement::Continue, meta);
+                terminator.get_or_insert(ctx.body.len());
+                self.expect(frontend, TokenValue::Semicolon)?.meta
+            }
+            TokenValue::Break => {
+                let meta = self.bump(frontend)?.meta;
+                ctx.body.push(Statement::Break, meta);
+                terminator.get_or_insert(ctx.body.len());
+                self.expect(frontend, TokenValue::Semicolon)?.meta
+            }
+            TokenValue::Return => {
+                self.bump(frontend)?;
+                let (value, meta) = match self.expect_peek(frontend)?.value {
+                    TokenValue::Semicolon => (None, self.bump(frontend)?.meta),
+                    _ => {
+                        // TODO: Implicit conversions
+                        let mut stmt = ctx.stmt_ctx();
+                        let expr = self.parse_expression(frontend, ctx, &mut stmt)?;
+                        self.expect(frontend, TokenValue::Semicolon)?;
+                        let (handle, meta) =
+                            ctx.lower_expect(stmt, frontend, expr, ExprPos::Rhs)?;
+                        (Some(handle), meta)
+                    }
+                };
+
+                ctx.emit_restart();
+
+                ctx.body.push(Statement::Return { value }, meta);
+                terminator.get_or_insert(ctx.body.len());
+
+                meta
+            }
+            TokenValue::Discard => {
+                let meta = self.bump(frontend)?.meta;
+                ctx.body.push(Statement::Kill, meta);
+                terminator.get_or_insert(ctx.body.len());
+
+                self.expect(frontend, TokenValue::Semicolon)?.meta
+            }
+            TokenValue::If => {
+                let mut meta = self.bump(frontend)?.meta;
+
+                self.expect(frontend, TokenValue::LeftParen)?;
+                let condition = {
+                    let mut stmt = ctx.stmt_ctx();
+                    let expr = self.parse_expression(frontend, ctx, &mut stmt)?;
+                    let (handle, more_meta) =
+                        ctx.lower_expect(stmt, frontend, expr, ExprPos::Rhs)?;
+                    meta.subsume(more_meta);
+                    handle
+                };
+                self.expect(frontend, TokenValue::RightParen)?;
+
+                let accept = ctx.new_body(|ctx| {
+                    if let Some(more_meta) =
+                        self.parse_statement(frontend, ctx, &mut None, is_inside_loop)?
+                    {
+                        meta.subsume(more_meta);
+                    }
+                    Ok(())
+                })?;
+
+                let reject = ctx.new_body(|ctx| {
+                    if self.bump_if(frontend, TokenValue::Else).is_some() {
+                        if let Some(more_meta) =
+                            self.parse_statement(frontend, ctx, &mut None, is_inside_loop)?
+                        {
+                            meta.subsume(more_meta);
+                        }
+                    }
+                    Ok(())
+                })?;
+
+                ctx.body.push(
+                    Statement::If {
+                        condition,
+                        accept,
+                        reject,
+                    },
+                    meta,
+                );
+
+                meta
+            }
+            TokenValue::Switch => {
+                let mut meta = self.bump(frontend)?.meta;
+                let end_meta;
+
+                self.expect(frontend, TokenValue::LeftParen)?;
+
+                let (selector, uint) = {
+                    let mut stmt = ctx.stmt_ctx();
+                    let expr = self.parse_expression(frontend, ctx, &mut stmt)?;
+                    let (root, meta) = ctx.lower_expect(stmt, frontend, expr, ExprPos::Rhs)?;
+                    let uint = ctx.resolve_type(root, meta)?.scalar_kind()
+                        == Some(crate::ScalarKind::Uint);
+                    (root, uint)
+                };
+
+                self.expect(frontend, TokenValue::RightParen)?;
+
+                ctx.emit_restart();
+
+                let mut cases = Vec::new();
+                // Track if any default case is present in the switch statement.
+                let mut default_present = false;
+
+                self.expect(frontend, TokenValue::LeftBrace)?;
+                loop {
+                    let value = match self.expect_peek(frontend)?.value {
+                        TokenValue::Case => {
+                            self.bump(frontend)?;
+
+                            let (const_expr, meta) =
+                                self.parse_constant_expression(frontend, ctx.module)?;
+
+                            match ctx.module.const_expressions[const_expr] {
+                                Expression::Literal(Literal::I32(value)) => match uint {
+                                    // This unchecked cast isn't good, but since
+                                    // we only reach this code when the selector
+                                    // is unsigned but the case label is signed,
+                                    // verification will reject the module
+                                    // anyway (which also matches GLSL's rules).
+                                    true => crate::SwitchValue::U32(value as u32),
+                                    false => crate::SwitchValue::I32(value),
+                                },
+                                Expression::Literal(Literal::U32(value)) => {
+                                    crate::SwitchValue::U32(value)
+                                }
+                                _ => {
+                                    frontend.errors.push(Error {
+                                        kind: ErrorKind::SemanticError(
+                                            "Case values can only be integers".into(),
+                                        ),
+                                        meta,
+                                    });
+
+                                    crate::SwitchValue::I32(0)
+                                }
+                            }
+                        }
+                        TokenValue::Default => {
+                            self.bump(frontend)?;
+                            default_present = true;
+                            crate::SwitchValue::Default
+                        }
+                        TokenValue::RightBrace => {
+                            end_meta = self.bump(frontend)?.meta;
+                            break;
+                        }
+                        _ => {
+                            let Token { value, meta } = self.bump(frontend)?;
+                            return Err(Error {
+                                kind: ErrorKind::InvalidToken(
+                                    value,
+                                    vec![
+                                        TokenValue::Case.into(),
+                                        TokenValue::Default.into(),
+                                        TokenValue::RightBrace.into(),
+                                    ],
+                                ),
+                                meta,
+                            });
+                        }
+                    };
+
+                    self.expect(frontend, TokenValue::Colon)?;
+
+                    let mut fall_through = true;
+
+                    let body = ctx.new_body(|ctx| {
+                        let mut case_terminator = None;
+                        loop {
+                            match self.expect_peek(frontend)?.value {
+                                TokenValue::Case | TokenValue::Default | TokenValue::RightBrace => {
+                                    break
+                                }
+                                _ => {
+                                    self.parse_statement(
+                                        frontend,
+                                        ctx,
+                                        &mut case_terminator,
+                                        is_inside_loop,
+                                    )?;
+                                }
+                            }
+                        }
+
+                        if let Some(mut idx) = case_terminator {
+                            if let Statement::Break = ctx.body[idx - 1] {
+                                fall_through = false;
+                                idx -= 1;
+                            }
+
+                            ctx.body.cull(idx..)
+                        }
+
+                        Ok(())
+                    })?;
+
+                    cases.push(SwitchCase {
+                        value,
+                        body,
+                        fall_through,
+                    })
+                }
+
+                meta.subsume(end_meta);
+
+                // NOTE: do not unwrap here since a switch statement isn't required
+                // to have any cases.
+                if let Some(case) = cases.last_mut() {
+                    // GLSL requires that the last case not be empty, so we check
+                    // that here and produce an error otherwise (fall_through must
+                    // also be checked because `break`s count as statements but
+                    // they aren't added to the body)
+                    if case.body.is_empty() && case.fall_through {
+                        frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "last case/default label must be followed by statements".into(),
+                            ),
+                            meta,
+                        })
+                    }
+
+                    // GLSL allows the last case to not have any `break` statement,
+                    // this would mark it as fall through but naga's IR requires that
+                    // the last case must not be fall through, so we mark need to mark
+                    // the last case as not fall through always.
+                    case.fall_through = false;
+                }
+
+                // Add an empty default case in case non was present, this is needed because
+                // naga's IR requires that all switch statements must have a default case but
+                // GLSL doesn't require that, so we might need to add an empty default case.
+                if !default_present {
+                    cases.push(SwitchCase {
+                        value: crate::SwitchValue::Default,
+                        body: Block::new(),
+                        fall_through: false,
+                    })
+                }
+
+                ctx.body.push(Statement::Switch { selector, cases }, meta);
+
+                meta
+            }
+            TokenValue::While => {
+                let mut meta = self.bump(frontend)?.meta;
+
+                let loop_body = ctx.new_body(|ctx| {
+                    let mut stmt = ctx.stmt_ctx();
+                    self.expect(frontend, TokenValue::LeftParen)?;
+                    let root = self.parse_expression(frontend, ctx, &mut stmt)?;
+                    meta.subsume(self.expect(frontend, TokenValue::RightParen)?.meta);
+
+                    let (expr, expr_meta) = ctx.lower_expect(stmt, frontend, root, ExprPos::Rhs)?;
+                    let condition = ctx.add_expression(
+                        Expression::Unary {
+                            op: UnaryOperator::LogicalNot,
+                            expr,
+                        },
+                        expr_meta,
+                    )?;
+
+                    ctx.emit_restart();
+
+                    ctx.body.push(
+                        Statement::If {
+                            condition,
+                            accept: new_break(),
+                            reject: Block::new(),
+                        },
+                        crate::Span::default(),
+                    );
+
+                    meta.subsume(expr_meta);
+
+                    if let Some(body_meta) = self.parse_statement(frontend, ctx, &mut None, true)? {
+                        meta.subsume(body_meta);
+                    }
+                    Ok(())
+                })?;
+
+                ctx.body.push(
+                    Statement::Loop {
+                        body: loop_body,
+                        continuing: Block::new(),
+                        break_if: None,
+                    },
+                    meta,
+                );
+
+                meta
+            }
+            TokenValue::Do => {
+                let mut meta = self.bump(frontend)?.meta;
+
+                let loop_body = ctx.new_body(|ctx| {
+                    let mut terminator = None;
+                    self.parse_statement(frontend, ctx, &mut terminator, true)?;
+
+                    let mut stmt = ctx.stmt_ctx();
+
+                    self.expect(frontend, TokenValue::While)?;
+                    self.expect(frontend, TokenValue::LeftParen)?;
+                    let root = self.parse_expression(frontend, ctx, &mut stmt)?;
+                    let end_meta = self.expect(frontend, TokenValue::RightParen)?.meta;
+
+                    meta.subsume(end_meta);
+
+                    let (expr, expr_meta) = ctx.lower_expect(stmt, frontend, root, ExprPos::Rhs)?;
+                    let condition = ctx.add_expression(
+                        Expression::Unary {
+                            op: UnaryOperator::LogicalNot,
+                            expr,
+                        },
+                        expr_meta,
+                    )?;
+
+                    ctx.emit_restart();
+
+                    ctx.body.push(
+                        Statement::If {
+                            condition,
+                            accept: new_break(),
+                            reject: Block::new(),
+                        },
+                        crate::Span::default(),
+                    );
+
+                    if let Some(idx) = terminator {
+                        ctx.body.cull(idx..)
+                    }
+                    Ok(())
+                })?;
+
+                ctx.body.push(
+                    Statement::Loop {
+                        body: loop_body,
+                        continuing: Block::new(),
+                        break_if: None,
+                    },
+                    meta,
+                );
+
+                meta
+            }
+            TokenValue::For => {
+                let mut meta = self.bump(frontend)?.meta;
+
+                ctx.symbol_table.push_scope();
+                self.expect(frontend, TokenValue::LeftParen)?;
+
+                if self.bump_if(frontend, TokenValue::Semicolon).is_none() {
+                    if self.peek_type_name(frontend) || self.peek_type_qualifier(frontend) {
+                        self.parse_declaration(frontend, ctx, false, false)?;
+                    } else {
+                        let mut stmt = ctx.stmt_ctx();
+                        let expr = self.parse_expression(frontend, ctx, &mut stmt)?;
+                        ctx.lower(stmt, frontend, expr, ExprPos::Rhs)?;
+                        self.expect(frontend, TokenValue::Semicolon)?;
+                    }
+                }
+
+                let loop_body = ctx.new_body(|ctx| {
+                    if self.bump_if(frontend, TokenValue::Semicolon).is_none() {
+                        let (expr, expr_meta) = if self.peek_type_name(frontend)
+                            || self.peek_type_qualifier(frontend)
+                        {
+                            let mut qualifiers = self.parse_type_qualifiers(frontend, ctx)?;
+                            let (ty, mut meta) = self.parse_type_non_void(frontend, ctx)?;
+                            let name = self.expect_ident(frontend)?.0;
+
+                            self.expect(frontend, TokenValue::Assign)?;
+
+                            let (value, end_meta) = self.parse_initializer(frontend, ty, ctx)?;
+                            meta.subsume(end_meta);
+
+                            let decl = VarDeclaration {
+                                qualifiers: &mut qualifiers,
+                                ty,
+                                name: Some(name),
+                                init: None,
+                                meta,
+                            };
+
+                            let pointer = frontend.add_local_var(ctx, decl)?;
+
+                            ctx.emit_restart();
+
+                            ctx.body.push(Statement::Store { pointer, value }, meta);
+
+                            (value, end_meta)
+                        } else {
+                            let mut stmt = ctx.stmt_ctx();
+                            let root = self.parse_expression(frontend, ctx, &mut stmt)?;
+                            ctx.lower_expect(stmt, frontend, root, ExprPos::Rhs)?
+                        };
+
+                        let condition = ctx.add_expression(
+                            Expression::Unary {
+                                op: UnaryOperator::LogicalNot,
+                                expr,
+                            },
+                            expr_meta,
+                        )?;
+
+                        ctx.emit_restart();
+
+                        ctx.body.push(
+                            Statement::If {
+                                condition,
+                                accept: new_break(),
+                                reject: Block::new(),
+                            },
+                            crate::Span::default(),
+                        );
+
+                        self.expect(frontend, TokenValue::Semicolon)?;
+                    }
+                    Ok(())
+                })?;
+
+                let continuing = ctx.new_body(|ctx| {
+                    match self.expect_peek(frontend)?.value {
+                        TokenValue::RightParen => {}
+                        _ => {
+                            let mut stmt = ctx.stmt_ctx();
+                            let rest = self.parse_expression(frontend, ctx, &mut stmt)?;
+                            ctx.lower(stmt, frontend, rest, ExprPos::Rhs)?;
+                        }
+                    }
+                    Ok(())
+                })?;
+
+                meta.subsume(self.expect(frontend, TokenValue::RightParen)?.meta);
+
+                let loop_body = ctx.with_body(loop_body, |ctx| {
+                    if let Some(stmt_meta) = self.parse_statement(frontend, ctx, &mut None, true)? {
+                        meta.subsume(stmt_meta);
+                    }
+                    Ok(())
+                })?;
+
+                ctx.body.push(
+                    Statement::Loop {
+                        body: loop_body,
+                        continuing,
+                        break_if: None,
+                    },
+                    meta,
+                );
+
+                ctx.symbol_table.pop_scope();
+
+                meta
+            }
+            TokenValue::LeftBrace => {
+                let mut meta = self.bump(frontend)?.meta;
+
+                let mut block_terminator = None;
+
+                let block = ctx.new_body(|ctx| {
+                    let block_meta = self.parse_compound_statement(
+                        meta,
+                        frontend,
+                        ctx,
+                        &mut block_terminator,
+                        is_inside_loop,
+                    )?;
+                    meta.subsume(block_meta);
+                    Ok(())
+                })?;
+
+                ctx.body.push(Statement::Block(block), meta);
+                if block_terminator.is_some() {
+                    terminator.get_or_insert(ctx.body.len());
+                }
+
+                meta
+            }
+            TokenValue::Semicolon => self.bump(frontend)?.meta,
+            _ => {
+                // Attempt to force expression parsing for remainder of the
+                // tokens. Unknown or invalid tokens will be caught there and
+                // turned into an error.
+                let mut stmt = ctx.stmt_ctx();
+                let expr = self.parse_expression(frontend, ctx, &mut stmt)?;
+                ctx.lower(stmt, frontend, expr, ExprPos::Rhs)?;
+                self.expect(frontend, TokenValue::Semicolon)?.meta
+            }
+        };
+
+        meta.subsume(meta_rest);
+        Ok(Some(meta))
+    }
+
+    pub fn parse_compound_statement(
+        &mut self,
+        mut meta: Span,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        terminator: &mut Option<usize>,
+        is_inside_loop: bool,
+    ) -> Result<Span> {
+        ctx.symbol_table.push_scope();
+
+        loop {
+            if let Some(Token {
+                meta: brace_meta, ..
+            }) = self.bump_if(frontend, TokenValue::RightBrace)
+            {
+                meta.subsume(brace_meta);
+                break;
+            }
+
+            let stmt = self.parse_statement(frontend, ctx, terminator, is_inside_loop)?;
+
+            if let Some(stmt_meta) = stmt {
+                meta.subsume(stmt_meta);
+            }
+        }
+
+        if let Some(idx) = *terminator {
+            ctx.body.cull(idx..)
+        }
+
+        ctx.symbol_table.pop_scope();
+
+        Ok(meta)
+    }
+
+    pub fn parse_function_args(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+    ) -> Result<()> {
+        if self.bump_if(frontend, TokenValue::Void).is_some() {
+            return Ok(());
+        }
+
+        loop {
+            if self.peek_type_name(frontend) || self.peek_parameter_qualifier(frontend) {
+                let qualifier = self.parse_parameter_qualifier(frontend);
+                let mut ty = self.parse_type_non_void(frontend, ctx)?.0;
+
+                match self.expect_peek(frontend)?.value {
+                    TokenValue::Comma => {
+                        self.bump(frontend)?;
+                        ctx.add_function_arg(None, ty, qualifier)?;
+                        continue;
+                    }
+                    TokenValue::Identifier(_) => {
+                        let mut name = self.expect_ident(frontend)?;
+                        self.parse_array_specifier(frontend, ctx, &mut name.1, &mut ty)?;
+
+                        ctx.add_function_arg(Some(name), ty, qualifier)?;
+
+                        if self.bump_if(frontend, TokenValue::Comma).is_some() {
+                            continue;
+                        }
+
+                        break;
+                    }
+                    _ => break,
+                }
+            }
+
+            break;
+        }
+
+        Ok(())
+    }
+}
diff --git a/third_party/rust/naga/src/front/glsl/parser/types.rs b/third_party/rust/naga/src/front/glsl/parser/types.rs
new file mode 100644
index 0000000000..1b612b298d
--- /dev/null
+++ b/third_party/rust/naga/src/front/glsl/parser/types.rs
@@ -0,0 +1,443 @@
+use std::num::NonZeroU32;
+
+use crate::{
+    front::glsl::{
+        ast::{QualifierKey, QualifierValue, StorageQualifier, StructLayout, TypeQualifiers},
+        context::Context,
+        error::ExpectedToken,
+        parser::ParsingContext,
+        token::{Token, TokenValue},
+        Error, ErrorKind, Frontend, Result,
+    },
+    AddressSpace, ArraySize, Handle, Span, Type, TypeInner,
+};
+
+impl<'source> ParsingContext<'source> {
+    /// Parses an optional array_specifier returning whether or not it's present
+    /// and modifying the type handle if it exists
+    pub fn parse_array_specifier(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        span: &mut Span,
+        ty: &mut Handle<Type>,
+    ) -> Result<()> {
+        while self.parse_array_specifier_single(frontend, ctx, span, ty)? {}
+        Ok(())
+    }
+
+    /// Implementation of [`Self::parse_array_specifier`] for a single array_specifier
+    fn parse_array_specifier_single(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        span: &mut Span,
+        ty: &mut Handle<Type>,
+    ) -> Result<bool> {
+        if self.bump_if(frontend, TokenValue::LeftBracket).is_some() {
+            let size = if let Some(Token { meta, .. }) =
+                self.bump_if(frontend, TokenValue::RightBracket)
+            {
+                span.subsume(meta);
+                ArraySize::Dynamic
+            } else {
+                let (value, constant_span) = self.parse_uint_constant(frontend, ctx)?;
+                let size = NonZeroU32::new(value).ok_or(Error {
+                    kind: ErrorKind::SemanticError("Array size must be greater than zero".into()),
+                    meta: constant_span,
+                })?;
+                let end_span = self.expect(frontend, TokenValue::RightBracket)?.meta;
+                span.subsume(end_span);
+                ArraySize::Constant(size)
+            };
+
+            frontend.layouter.update(ctx.module.to_ctx()).unwrap();
+            let stride = frontend.layouter[*ty].to_stride();
+            *ty = ctx.module.types.insert(
+                Type {
+                    name: None,
+                    inner: TypeInner::Array {
+                        base: *ty,
+                        size,
+                        stride,
+                    },
+                },
+                *span,
+            );
+
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    pub fn parse_type(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+    ) -> Result<(Option<Handle<Type>>, Span)> {
+        let token = self.bump(frontend)?;
+        let mut handle = match token.value {
+            TokenValue::Void => return Ok((None, token.meta)),
+            TokenValue::TypeName(ty) => ctx.module.types.insert(ty, token.meta),
+            TokenValue::Struct => {
+                let mut meta = token.meta;
+                let ty_name = self.expect_ident(frontend)?.0;
+                self.expect(frontend, TokenValue::LeftBrace)?;
+                let mut members = Vec::new();
+                let span = self.parse_struct_declaration_list(
+                    frontend,
+                    ctx,
+                    &mut members,
+                    StructLayout::Std140,
+                )?;
+                let end_meta = self.expect(frontend, TokenValue::RightBrace)?.meta;
+                meta.subsume(end_meta);
+                let ty = ctx.module.types.insert(
+                    Type {
+                        name: Some(ty_name.clone()),
+                        inner: TypeInner::Struct { members, span },
+                    },
+                    meta,
+                );
+                frontend.lookup_type.insert(ty_name, ty);
+                ty
+            }
+            TokenValue::Identifier(ident) => match frontend.lookup_type.get(&ident) {
+                Some(ty) => *ty,
+                None => {
+                    return Err(Error {
+                        kind: ErrorKind::UnknownType(ident),
+                        meta: token.meta,
+                    })
+                }
+            },
+            _ => {
+                return Err(Error {
+                    kind: ErrorKind::InvalidToken(
+                        token.value,
+                        vec![
+                            TokenValue::Void.into(),
+                            TokenValue::Struct.into(),
+                            ExpectedToken::TypeName,
+                        ],
+                    ),
+                    meta: token.meta,
+                });
+            }
+        };
+
+        let mut span = token.meta;
+        self.parse_array_specifier(frontend, ctx, &mut span, &mut handle)?;
+        Ok((Some(handle), span))
+    }
+
+    pub fn parse_type_non_void(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+    ) -> Result<(Handle<Type>, Span)> {
+        let (maybe_ty, meta) = self.parse_type(frontend, ctx)?;
+        let ty = maybe_ty.ok_or_else(|| Error {
+            kind: ErrorKind::SemanticError("Type can't be void".into()),
+            meta,
+        })?;
+
+        Ok((ty, meta))
+    }
+
+    pub fn peek_type_qualifier(&mut self, frontend: &mut Frontend) -> bool {
+        self.peek(frontend).map_or(false, |t| match t.value {
+            TokenValue::Invariant
+            | TokenValue::Interpolation(_)
+            | TokenValue::Sampling(_)
+            | TokenValue::PrecisionQualifier(_)
+            | TokenValue::Const
+            | TokenValue::In
+            | TokenValue::Out
+            | TokenValue::Uniform
+            | TokenValue::Shared
+            | TokenValue::Buffer
+            | TokenValue::Restrict
+            | TokenValue::MemoryQualifier(_)
+            | TokenValue::Layout => true,
+            _ => false,
+        })
+    }
+
+    pub fn parse_type_qualifiers<'a>(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+    ) -> Result<TypeQualifiers<'a>> {
+        let mut qualifiers = TypeQualifiers::default();
+
+        while self.peek_type_qualifier(frontend) {
+            let token = self.bump(frontend)?;
+
+            // Handle layout qualifiers outside the match since this can push multiple values
+            if token.value == TokenValue::Layout {
+                self.parse_layout_qualifier_id_list(frontend, ctx, &mut qualifiers)?;
+                continue;
+            }
+
+            qualifiers.span.subsume(token.meta);
+
+            match token.value {
+                TokenValue::Invariant => {
+                    if qualifiers.invariant.is_some() {
+                        frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "Cannot use more than one invariant qualifier per declaration"
+                                    .into(),
+                            ),
+                            meta: token.meta,
+                        })
+                    }
+
+                    qualifiers.invariant = Some(token.meta);
+                }
+                TokenValue::Interpolation(i) => {
+                    if qualifiers.interpolation.is_some() {
+                        frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "Cannot use more than one interpolation qualifier per declaration"
+                                    .into(),
+                            ),
+                            meta: token.meta,
+                        })
+                    }
+
+                    qualifiers.interpolation = Some((i, token.meta));
+                }
+                TokenValue::Const
+                | TokenValue::In
+                | TokenValue::Out
+                | TokenValue::Uniform
+                | TokenValue::Shared
+                | TokenValue::Buffer => {
+                    let storage = match token.value {
+                        TokenValue::Const => StorageQualifier::Const,
+                        TokenValue::In => StorageQualifier::Input,
+                        TokenValue::Out => StorageQualifier::Output,
+                        TokenValue::Uniform => {
+                            StorageQualifier::AddressSpace(AddressSpace::Uniform)
+                        }
+                        TokenValue::Shared => {
+                            StorageQualifier::AddressSpace(AddressSpace::WorkGroup)
+                        }
+                        TokenValue::Buffer => {
+                            StorageQualifier::AddressSpace(AddressSpace::Storage {
+                                access: crate::StorageAccess::all(),
+                            })
+                        }
+                        _ => unreachable!(),
+                    };
+
+                    if StorageQualifier::AddressSpace(AddressSpace::Function)
+                        != qualifiers.storage.0
+                    {
+                        frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "Cannot use more than one storage qualifier per declaration".into(),
+                            ),
+                            meta: token.meta,
+                        });
+                    }
+
+                    qualifiers.storage = (storage, token.meta);
+                }
+                TokenValue::Sampling(s) => {
+                    if qualifiers.sampling.is_some() {
+                        frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "Cannot use more than one sampling qualifier per declaration"
+                                    .into(),
+                            ),
+                            meta: token.meta,
+                        })
+                    }
+
+                    qualifiers.sampling = Some((s, token.meta));
+                }
+                TokenValue::PrecisionQualifier(p) => {
+                    if qualifiers.precision.is_some() {
+                        frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "Cannot use more than one precision qualifier per declaration"
+                                    .into(),
+                            ),
+                            meta: token.meta,
+                        })
+                    }
+
+                    qualifiers.precision = Some((p, token.meta));
+                }
+                TokenValue::MemoryQualifier(access) => {
+                    let storage_access = qualifiers
+                        .storage_access
+                        .get_or_insert((crate::StorageAccess::all(), Span::default()));
+                    if !storage_access.0.contains(!access) {
+                        frontend.errors.push(Error {
+                            kind: ErrorKind::SemanticError(
+                                "The same memory qualifier can only be used once".into(),
+                            ),
+                            meta: token.meta,
+                        })
+                    }
+
+                    storage_access.0 &= access;
+                    storage_access.1.subsume(token.meta);
+                }
+                TokenValue::Restrict => continue,
+                _ => unreachable!(),
+            };
+        }
+
+        Ok(qualifiers)
+    }
+
+    pub fn parse_layout_qualifier_id_list(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        qualifiers: &mut TypeQualifiers,
+    ) -> Result<()> {
+        self.expect(frontend, TokenValue::LeftParen)?;
+        loop {
+            self.parse_layout_qualifier_id(frontend, ctx, &mut qualifiers.layout_qualifiers)?;
+
+            if self.bump_if(frontend, TokenValue::Comma).is_some() {
+                continue;
+            }
+
+            break;
+        }
+        let token = self.expect(frontend, TokenValue::RightParen)?;
+        qualifiers.span.subsume(token.meta);
+
+        Ok(())
+    }
+
+    pub fn parse_layout_qualifier_id(
+        &mut self,
+        frontend: &mut Frontend,
+        ctx: &mut Context,
+        qualifiers: &mut crate::FastHashMap<QualifierKey, (QualifierValue, Span)>,
+    ) -> Result<()> {
+        // layout_qualifier_id:
+        //     IDENTIFIER
+        //     IDENTIFIER EQUAL constant_expression
+        //     SHARED
+        let mut token = self.bump(frontend)?;
+        match token.value {
+            TokenValue::Identifier(name) => {
+                let (key, value) = match name.as_str() {
+                    "std140" => (
+                        QualifierKey::Layout,
+                        QualifierValue::Layout(StructLayout::Std140),
+                    ),
+                    "std430" => (
+                        QualifierKey::Layout,
+                        QualifierValue::Layout(StructLayout::Std430),
+                    ),
+                    word => {
+                        if let Some(format) = map_image_format(word) {
+                            (QualifierKey::Format, QualifierValue::Format(format))
+                        } else {
+                            let key = QualifierKey::String(name.into());
+                            let value = if self.bump_if(frontend, TokenValue::Assign).is_some() {
+                                let (value, end_meta) =
+                                    match self.parse_uint_constant(frontend, ctx) {
+                                        Ok(v) => v,
+                                        Err(e) => {
+                                            frontend.errors.push(e);
+                                            (0, Span::default())
+                                        }
+                                    };
+                                token.meta.subsume(end_meta);
+
+                                QualifierValue::Uint(value)
+                            } else {
+                                QualifierValue::None
+                            };
+
+                            (key, value)
+                        }
+                    }
+                };
+
+                qualifiers.insert(key, (value, token.meta));
+            }
+            _ => frontend.errors.push(Error {
+                kind: ErrorKind::InvalidToken(token.value, vec![ExpectedToken::Identifier]),
+                meta: token.meta,
+            }),
+        }
+
+        Ok(())
+    }
+
+    pub fn peek_type_name(&mut self, frontend: &mut Frontend) -> bool {
+        self.peek(frontend).map_or(false, |t| match t.value {
+            TokenValue::TypeName(_) | TokenValue::Void => true,
+            TokenValue::Struct => true,
+            TokenValue::Identifier(ref ident) => frontend.lookup_type.contains_key(ident),
+            _ => false,
+        })
+    }
+}
+
+fn map_image_format(word: &str) -> Option<crate::StorageFormat> {
+    use crate::StorageFormat as Sf;
+
+    let format = match word {
+        // float-image-format-qualifier:
+        "rgba32f" => Sf::Rgba32Float,
+        "rgba16f" => Sf::Rgba16Float,
+        "rg32f" => Sf::Rg32Float,
+        "rg16f" => Sf::Rg16Float,
+        "r11f_g11f_b10f" => Sf::Rg11b10Float,
+        "r32f" => Sf::R32Float,
+        "r16f" => Sf::R16Float,
+        "rgba16" => Sf::Rgba16Unorm,
+        "rgb10_a2ui" => Sf::Rgb10a2Uint,
+        "rgb10_a2" => Sf::Rgb10a2Unorm,
+        "rgba8" => Sf::Rgba8Unorm,
+        "rg16" => Sf::Rg16Unorm,
+        "rg8" => Sf::Rg8Unorm,
+        "r16" => Sf::R16Unorm,
+        "r8" => Sf::R8Unorm,
+        "rgba16_snorm" => Sf::Rgba16Snorm,
+        "rgba8_snorm" => Sf::Rgba8Snorm,
+        "rg16_snorm" => Sf::Rg16Snorm,
+        "rg8_snorm" => Sf::Rg8Snorm,
+        "r16_snorm" => Sf::R16Snorm,
+        "r8_snorm" => Sf::R8Snorm,
+        // int-image-format-qualifier:
+        "rgba32i" => Sf::Rgba32Sint,
+        "rgba16i" => Sf::Rgba16Sint,
+        "rgba8i" => Sf::Rgba8Sint,
+        "rg32i" => Sf::Rg32Sint,
+        "rg16i" => Sf::Rg16Sint,
+        "rg8i" => Sf::Rg8Sint,
+        "r32i" => Sf::R32Sint,
+        "r16i" => Sf::R16Sint,
+        "r8i" => Sf::R8Sint,
+        // uint-image-format-qualifier:
+        "rgba32ui" => Sf::Rgba32Uint,
+        "rgba16ui" => Sf::Rgba16Uint,
+        "rgba8ui" => Sf::Rgba8Uint,
+        "rg32ui" => Sf::Rg32Uint,
+        "rg16ui" => Sf::Rg16Uint,
+        "rg8ui" => Sf::Rg8Uint,
+        "r32ui" => Sf::R32Uint,
+        "r16ui" => Sf::R16Uint,
+        "r8ui" => Sf::R8Uint,
+        // TODO: These next ones seem incorrect to me
+        // "rgb10_a2ui" => Sf::Rgb10a2Unorm,
+        _ => return None,
+    };
+
+    Some(format)
+}