From d4fb81a00525e468464c141d0d6bac11f9eea1c5 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Tue, 3 Mar 2020 22:56:02 -0500
Subject: [PATCH] [wgsl] basic typed constructors

---
 examples/convert.rs |  2 +-
 grammars/wgsl.pest  |  6 ++++--
 src/front/wgsl.rs   | 30 +++++++++++++++++++++++++++---
 3 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/examples/convert.rs b/examples/convert.rs
index 11eadc9ace..35cc954e5a 100644
--- a/examples/convert.rs
+++ b/examples/convert.rs
@@ -19,7 +19,7 @@ fn main() {
     };
 
     if args.len() <= 2 {
-        println!("{:?}", module);
+        println!("{:#?}", module);
         return
     } else if args[2].ends_with(".metal") {
         use naga::back::msl;
diff --git a/grammars/wgsl.pest b/grammars/wgsl.pest
index beb993a9cf..54b0bf6224 100644
--- a/grammars/wgsl.pest
+++ b/grammars/wgsl.pest
@@ -141,14 +141,16 @@ statement = {
 }
 
 primary_expression = _{
-    type_decl ~ "(" ~ argument_expression_list ~ ")"
+    typed_expression
   | const_expr
   | multiplicative_expression
 }
 
 //multiplicative_expression = { primary_expression ~ "*" ~ primary_expression } //TODO
 multiplicative_expression = { ident ~ "*" ~ primary_expression }
-argument_expression_list = { (primary_expression ~ ",")* ~ primary_expression }
+typed_expression = { type_decl ~ "(" ~ argument_expression_list ~ ")" }
+argument_expression_list = _{ (primary_expression ~ ",")* ~ primary_expression }
+
 
 ident = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
 int_literal = @{ ("-"? ~ "0x"? ~ ASCII_HEX_DIGIT+) | "0" | ("-"? ~ ASCII_NONZERO_DIGIT ~ ASCII_DIGIT*) }
diff --git a/src/front/wgsl.rs b/src/front/wgsl.rs
index 4410f75282..f53c9f87ae 100644
--- a/src/front/wgsl.rs
+++ b/src/front/wgsl.rs
@@ -245,9 +245,20 @@ impl Parser {
         &self,
         primary_expression: pest::iterators::Pair<Rule>,
         function: &mut crate::Function,
+        type_store: &mut Storage<crate::Type>,
         const_store: &mut Storage<crate::Constant>,
     ) -> Result<Token<crate::Expression>, Error> {
         let expression = match primary_expression.as_rule() {
+            Rule::typed_expression => {
+                let mut expr_pairs = primary_expression.into_inner();
+                let ty = self.parse_type_decl(expr_pairs.next().unwrap(), type_store)?;
+                let mut components = Vec::new();
+                for argument_pair in expr_pairs {
+                    let expr_token = self.parse_primary_expression(argument_pair, function, type_store, const_store)?;
+                    components.push(expr_token);
+                }
+                crate::Expression::Compose { ty, components }
+            }
             Rule::const_expr => {
                 let inner = Self::parse_const_expression(primary_expression, const_store)?;
                 let token = const_store.append(crate::Constant {
@@ -257,7 +268,7 @@ impl Parser {
                 });
                 crate::Expression::Constant(token)
             }
-            ref other => panic!("Unknown expression {:?}", other),
+            _ => panic!("Unknown expression {:?}", primary_expression),
         };
         Ok(function.expressions.append(expression))
     }
@@ -283,6 +294,19 @@ impl Parser {
             expressions: Storage::new(),
             body: Vec::new(),
         };
+        for (const_token, constant) in module.constants.iter() {
+            if let Some(ref name) = constant.name {
+                let expr_token = fun.expressions.append(crate::Expression::Constant(const_token));
+                lookup_ident.insert(name.clone(), expr_token);
+            }
+        }
+        for (var_token, variable) in module.global_variables.iter() {
+            if let Some(ref name) = variable.name {
+                let expr_token = fun.expressions.append(crate::Expression::GlobalVariable(var_token));
+                lookup_ident.insert(name.clone(), expr_token);
+            }
+        }
+
         let param_list = function_header_pairs.next().unwrap();
         assert_eq!(param_list.as_rule(), Rule::param_list);
         for (i, variable_ident_decl) in param_list.into_inner().enumerate() {
@@ -313,7 +337,7 @@ impl Parser {
                 Rule::return_statement => {
                     let mut return_pairs = first_statement.into_inner();
                     let value = match return_pairs.next() {
-                        Some(exp) => Some(self.parse_primary_expression(exp, &mut fun, &mut module.constants)?),
+                        Some(exp) => Some(self.parse_primary_expression(exp, &mut fun, &mut module.types, &mut module.constants)?),
                         None => None,
                     };
                     crate::Statement::Return { value }
@@ -322,7 +346,7 @@ impl Parser {
                     let mut assignment_pairs = first_statement.into_inner();
                     let left_token = lookup_ident.lookup(assignment_pairs.next().unwrap().as_str())?;
                     let right_pair = assignment_pairs.next().unwrap();
-                    let right_token = self.parse_primary_expression(right_pair, &mut fun, &mut module.constants)?;
+                    let right_token = self.parse_primary_expression(right_pair, &mut fun, &mut module.types, &mut module.constants)?;
                     crate::Statement::Store {
                         pointer: left_token,
                         value: right_token,