From ee325a6a67438a2c49c711ec49c2f8afdf9d93d1 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Thu, 12 Mar 2020 12:47:16 -0400
Subject: [PATCH] Add imported function calls

---
 src/front/wgsl.rs | 50 +++++++++++++++++++++++++++++++++++------------
 src/lib.rs        |  4 ++++
 2 files changed, 42 insertions(+), 12 deletions(-)

diff --git a/src/front/wgsl.rs b/src/front/wgsl.rs
index 158810d9bb..a345d0772a 100644
--- a/src/front/wgsl.rs
+++ b/src/front/wgsl.rs
@@ -19,6 +19,7 @@ impl<'a> Lexer<'a> {
 #[derive(Debug, PartialEq)]
 pub enum Token<'a> {
     Separator(char),
+    DoubleColon,
     Paren(char),
     DoubleParen(char),
     Number(&'a str),
@@ -65,7 +66,16 @@ impl<'a> Lexer<'a> {
             None => return Token::End,
         };
         let token = match cur {
-            ':' | ';' | ',' | '.' => {
+            ':' => {
+                self.input = chars.as_str();
+                if chars.next() == Some(':') {
+                    self.input = chars.as_str();
+                    Token::DoubleColon
+                } else {
+                    Token::Separator(cur)
+                }
+            }
+            ';' | ',' | '.' => {
                 self.input = chars.as_str();
                 Token::Separator(cur)
             }
@@ -434,19 +444,35 @@ impl Parser {
                     self.scopes.pop();
                     return Ok(*handle);
                 }
-                *lexer = backup;
-                let ty = self.parse_type_decl(lexer, ctx.types)?;
-                Self::expect(lexer, Token::Paren('('))?;
-                let mut components = Vec::new();
-                while lexer.peek() != Token::Paren(')') {
-                    if !components.is_empty() {
-                        Self::expect(lexer, Token::Separator(','))?;
+                if self.std_namespace.as_ref().map(|s| s.as_str()) == Some(word) {
+                    Self::expect(lexer, Token::DoubleColon)?;
+                    let name = Self::parse_ident(lexer)?;
+                    let mut arguments = Vec::new();
+                    Self::expect(lexer, Token::Paren('('))?;
+                    while lexer.peek() != Token::Paren(')') {
+                        let arg = self.parse_general_expression(lexer, ctx.reborrow())?;
+                        arguments.push(arg);
                     }
-                    let sub_expr = self.parse_general_expression(lexer, ctx.reborrow())?;
-                    components.push(sub_expr);
+                    let _ = lexer.next();
+                    crate::Expression::Call {
+                        name: name.to_owned(),
+                        arguments,
+                    }
+                } else {
+                    *lexer = backup;
+                    let ty = self.parse_type_decl(lexer, ctx.types)?;
+                    Self::expect(lexer, Token::Paren('('))?;
+                    let mut components = Vec::new();
+                    while lexer.peek() != Token::Paren(')') {
+                        if !components.is_empty() {
+                            Self::expect(lexer, Token::Separator(','))?;
+                        }
+                        let sub_expr = self.parse_general_expression(lexer, ctx.reborrow())?;
+                        components.push(sub_expr);
+                    }
+                    let _ = lexer.next();
+                    crate::Expression::Compose { ty, components }
                 }
-                let _ = lexer.next();
-                crate::Expression::Compose { ty, components }
             }
             other => return Err(Error::Unexpected(other)),
         };
diff --git a/src/lib.rs b/src/lib.rs
index e63c92f071..ee7a69787c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -202,6 +202,10 @@ pub enum Expression {
         //modifier,
         expr: Handle<Expression>,
     },
+    Call {
+        name: String,
+        arguments: Vec<Handle<Expression>>,
+    },
 }
 
 pub type Block = Vec<Statement>;