[wgsl-in] allow global var without explicit type

Signed-off-by: sagudev <[email protected]>
gfx-rs · Sep 2, 2024 · b408fe3 · b408fe3
1 parent 105cb9d
commit b408fe3
Show file tree

Hide file tree

Showing 3 changed files with 36 additions and 17 deletions.
diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs
@@ -1034,26 +1034,41 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                     ctx.globals.insert(f.name.name, lowered_decl);
                 }
                 ast::GlobalDeclKind::Var(ref v) => {
-                    let ty = self.resolve_ast_type(v.ty, &mut ctx)?;
-
-                    let init;
-                    if let Some(init_ast) = v.init {
-                        let mut ectx = ctx.as_override();
-                        let lowered = self.expression_for_abstract(init_ast, &mut ectx)?;
-                        let ty_res = crate::proc::TypeResolution::Handle(ty);
-                        let converted = ectx
-                            .try_automatic_conversions(lowered, &ty_res, v.name.span)
-                            .map_err(|error| match error {
+                    let explicit_ty =
+                        v.ty.map(|ast| self.resolve_ast_type(ast, &mut ctx))
+                            .transpose()?;
+
+                    let mut ectx = ctx.as_override();
+
+                    let ty;
+                    let initializer;
+                    match (v.init, explicit_ty) {
+                        (Some(init), Some(explicit_ty)) => {
+                            let init = self.expression_for_abstract(init, &mut ectx)?;
+                            let ty_res = crate::proc::TypeResolution::Handle(explicit_ty);
+                            let init = ectx
+                                .try_automatic_conversions(init, &ty_res, v.name.span)
+                                .map_err(|error| match error {
                                 Error::AutoConversion(e) => Error::InitializationTypeMismatch {
                                     name: v.name.span,
                                     expected: e.dest_type,
                                     got: e.source_type,
                                 },
                                 other => other,
                             })?;
-                        init = Some(converted);
-                    } else {
-                        init = None;
+                            ty = explicit_ty;
+                            initializer = Some(init);
+                        }
+                        (Some(init), None) => {
+                            let concretized = self.expression(init, &mut ectx)?;
+                            ty = ectx.register_type(concretized)?;
+                            initializer = Some(concretized);
+                        }
+                        (None, Some(explicit_ty)) => {
+                            ty = explicit_ty;
+                            initializer = None;
+                        }
+                        (None, None) => return Err(Error::DeclMissingTypeAndInit(v.name.span)),
                     }
 
                     let binding = if let Some(ref binding) = v.binding {
@@ -1071,7 +1086,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                             space: v.space,
                             binding,
                             ty,
-                            init,
+                            init: initializer,
                         },
                         span,
                     );

diff --git a/naga/src/front/wgsl/parse/ast.rs b/naga/src/front/wgsl/parse/ast.rs
@@ -142,7 +142,7 @@ pub struct GlobalVariable<'a> {
     pub name: Ident<'a>,
     pub space: crate::AddressSpace,
     pub binding: Option<ResourceBinding<'a>>,
-    pub ty: Handle<Type<'a>>,
+    pub ty: Option<Handle<Type<'a>>>,
     pub init: Option<Handle<Expression<'a>>>,
 }
 

diff --git a/naga/src/front/wgsl/parse/mod.rs b/naga/src/front/wgsl/parse/mod.rs
@@ -991,8 +991,12 @@ impl Parser {
             lexer.expect(Token::Paren('>'))?;
         }
         let name = lexer.next_ident()?;
-        lexer.expect(Token::Separator(':'))?;
-        let ty = self.type_decl(lexer, ctx)?;
+
+        let ty = if lexer.skip(Token::Separator(':')) {
+            Some(self.type_decl(lexer, ctx)?)
+        } else {
+            None
+        };
 
         let init = if lexer.skip(Token::Operation('=')) {
             let handle = self.general_expression(lexer, ctx)?;