remove non multidef calls

2025-09-23 12:18:44 +00:00 · 2020-03-31 16:05:49 +02:00 · 2020-03-31 16:05:49 +02:00 · f00338bcbe
commit f00338bcbe
parent 6d65801b9b
13 changed files with 170 additions and 140 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -24,6 +24,12 @@ version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7825f6833612eb2414095684fcf6c635becf3ce97fe48cf6421321e93bfbd53c"

+[[package]]
+name = "arrayref"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+
 [[package]]
 name = "arrayvec"
 version = "0.4.12"
@ -161,6 +167,16 @@ dependencies = [
 "constant_time_eq",
 ]

+[[package]]
+name = "block-buffer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
+dependencies = [
+ "arrayref",
+ "byte-tools 0.2.0",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.7.3"
@ -168,9 +184,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
 dependencies = [
 "block-padding",
- "byte-tools",
+ "byte-tools 0.3.1",
 "byteorder",
- "generic-array",
+ "generic-array 0.12.3",
 ]

 [[package]]
@ -179,7 +195,7 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
 dependencies = [
- "byte-tools",
+ "byte-tools 0.3.1",
 ]

 [[package]]
@ -200,6 +216,12 @@ version = "3.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5fb8038c1ddc0a5f73787b130f4cc75151e96ed33e417fde765eb5a81e3532f4"

+[[package]]
+name = "byte-tools"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
+
 [[package]]
 name = "byte-tools"
 version = "0.3.1"
@ -423,13 +445,22 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3304d19798a8e067e48d8e69b2c37f0b5e9b4e462504ad9e27e9f3fce02bba8"

+[[package]]
+name = "digest"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
+dependencies = [
+ "generic-array 0.9.0",
+]
+
 [[package]]
 name = "digest"
 version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
 dependencies = [
- "generic-array",
+ "generic-array 0.12.3",
 ]

 [[package]]
@ -555,6 +586,15 @@ dependencies = [
 "num_cpus",
 ]

+[[package]]
+name = "generic-array"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
+dependencies = [
+ "typenum",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.12.3"
@ -904,9 +944,9 @@ checksum = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"

 [[package]]
 name = "pest"
-version = "2.1.2"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e4fb201c5c22a55d8b24fef95f78be52738e5e1361129be1b5e862ecdb6894a"
+checksum = "933085deae3f32071f135d799d75667b63c8dc1f4537159756e3d4ceab41868c"
 dependencies = [
 "ucd-trie",
 ]
@ -926,9 +966,9 @@ dependencies = [

 [[package]]
 name = "pest_derive"
-version = "2.1.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
+checksum = "b76f477146419bc539a63f4ef40e902166cb43b3e51cecc71d9136fd12c567e7"
 dependencies = [
 "pest",
 "pest_generator",
@ -936,22 +976,22 @@ dependencies = [

 [[package]]
 name = "pest_generator"
-version = "2.1.1"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b9fcf299b5712d06ee128a556c94709aaa04512c4dffb8ead07c5c998447fc0"
+checksum = "3ebee4e9680be4fd162e6f3394ae4192a6b60b1e4d17d845e631f0c68d1a3386"
 dependencies = [
 "pest",
 "pest_meta",
- "proc-macro2 1.0.8",
- "quote 1.0.2",
- "syn 1.0.14",
+ "proc-macro2 0.4.30",
+ "quote 0.6.13",
+ "syn 0.14.9",
 ]

 [[package]]
 name = "pest_meta"
-version = "2.1.2"
+version = "2.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df43fd99896fd72c485fe47542c7b500e4ac1e8700bf995544d1317a60ded547"
+checksum = "1f6d5f6f0e6082578c86af197d780dc38328e3f768cec06aac9bc46d714e8221"
 dependencies = [
 "maplit",
 "pest",
@ -1184,7 +1224,7 @@ dependencies = [
 "bellman_ce 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2-rfc_bellman_edition",
 "byteorder",
- "digest",
+ "digest 0.8.1",
 "rand 0.4.6",
 "serde",
 "serde_derive",
@ -1259,14 +1299,14 @@ dependencies = [

 [[package]]
 name = "sha-1"
-version = "0.8.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
+checksum = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
 dependencies = [
- "block-buffer",
- "digest",
+ "block-buffer 0.3.3",
+ "byte-tools 0.2.0",
+ "digest 0.7.6",
 "fake-simd",
- "opaque-debug",
 ]

 [[package]]
@ -1275,8 +1315,8 @@ version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "27044adfd2e1f077f649f59deb9490d3941d674002f7d062870a60ebe9bd47a0"
 dependencies = [
- "block-buffer",
- "digest",
+ "block-buffer 0.7.3",
+ "digest 0.8.1",
 "fake-simd",
 "opaque-debug",
 ]
--- a/zokrates_core/src/absy/from_ast.rs
+++ b/zokrates_core/src/absy/from_ast.rs
@ -5,7 +5,6 @@ use zokrates_pest_ast as pest;

 impl<'ast, T: Field> From<pest::File<'ast>> for absy::Module<'ast, T> {
    fn from(prog: pest::File<'ast>) -> absy::Module<T> {
-        println!("{:#?}", prog);
        absy::Module::with_symbols(
            prog.structs
                .into_iter()
--- a/zokrates_core/src/flatten/mod.rs
+++ b/zokrates_core/src/flatten/mod.rs
@ -964,17 +964,6 @@ impl<'ast, T: Field> Flattener<'ast, T> {
            //     )[0]
            // .clone()
            ,
-            UExpressionInner::FunctionCall(key, param_expressions) => {
-                let exprs_flattened = self.flatten_function_call(
-                    symbols,
-                    statements_flattened,
-                    key.id,
-                    vec![Type::Uint(target_bitwidth)],
-                    param_expressions,
-                );
-                assert!(exprs_flattened.len() == 1); // outside of MultipleDefinition, FunctionCalls must return a single value
-                exprs_flattened[0].clone()
-            }
            UExpressionInner::Xor(box left, box right) => {
                let left_from = left.metadata.clone().unwrap().bitwidth.unwrap();
                let right_from = right.metadata.clone().unwrap().bitwidth.unwrap();
@ -1431,17 +1420,6 @@ impl<'ast, T: Field> Flattener<'ast, T> {
                    alternative,
                )[0]
            .clone(),
-            FieldElementExpression::FunctionCall(key, param_expressions) => {
-                let exprs_flattened = self.flatten_function_call(
-                    symbols,
-                    statements_flattened,
-                    key.id,
-                    vec![Type::FieldElement],
-                    param_expressions,
-                );
-                assert!(exprs_flattened.len() == 1); // outside of MultipleDefinition, FunctionCalls must return a single value
-                exprs_flattened[0].clone().get_field_unchecked()
-            }
        }
    }

--- a/zokrates_core/src/static_analysis/flatten_complex_types.rs
+++ b/zokrates_core/src/static_analysis/flatten_complex_types.rs
@ -505,14 +505,7 @@ pub fn fold_field_expression<'ast, T: Field>(
            let alt = f.fold_field_expression(alt);
            zir::FieldElementExpression::IfElse(box cond, box cons, box alt)
        }
-        typed_absy::FieldElementExpression::FunctionCall(key, exps) => {
-            let exps = exps
-                .into_iter()
-                .flat_map(|e| f.fold_expression(e))
-                .collect();
-            let key = f.fold_function_key(key);
-            zir::FieldElementExpression::FunctionCall(key, exps)
-        }
+        typed_absy::FieldElementExpression::FunctionCall(key, exps) => unreachable!(),
        typed_absy::FieldElementExpression::Member(box s, id) => {
            let members = s.ty().clone();

@ -717,14 +710,7 @@ pub fn fold_uint_expression_inner<'ast, T: Field>(

            zir::UExpressionInner::Not(box e)
        }
-        typed_absy::UExpressionInner::FunctionCall(key, exps) => {
-            let exps: Vec<_> = exps
-                .into_iter()
-                .flat_map(|e| f.fold_expression(e))
-                .collect();
-            let key = f.fold_function_key(key);
-            zir::UExpressionInner::FunctionCall(key, exps)
-        }
+        typed_absy::UExpressionInner::FunctionCall(key, exps) => unreachable!(),
        typed_absy::UExpressionInner::Select(box array, box index) => {
            let array = f.fold_array_expression(array);
            let index = f.fold_field_expression(index);
--- a/zokrates_core/src/static_analysis/inline.rs
+++ b/zokrates_core/src/static_analysis/inline.rs
@ -17,7 +17,7 @@
 //! where any call in `main` must be to `_SHA_256_ROUND` or `_UNPACK`

 use std::collections::HashMap;
-use typed_absy::types::{FunctionKey, StructMember, Type};
+use typed_absy::types::{ArrayType, FunctionKey, StructMember, Type};
 use typed_absy::{folder::*, *};
 use zokrates_field::field::Field;

@ -186,7 +186,15 @@ impl<'ast, T: Field> Inliner<'ast, T> {
                Ok(res)
            }
            // if the function is a flat symbol, replace the call with a call to the local function we provide so it can be inlined in flattening
-            TypedFunctionSymbol::Flat(embed) => Err((embed.key::<T>(), expressions)),
+            TypedFunctionSymbol::Flat(embed) => {
+                // increase the number of calls for this function by one
+                let count = self
+                    .call_count
+                    .entry((self.module_id.clone(), embed.key::<T>().clone()))
+                    .and_modify(|i| *i += 1)
+                    .or_insert(1);
+                Err((embed.key::<T>(), expressions))
+            }
        }
    }

@ -255,7 +263,21 @@ impl<'ast, T: Field> Folder<'ast, T> for Inliner<'ast, T> {
                        _ => unreachable!(),
                    },
                    Err((key, expressions)) => {
-                        FieldElementExpression::FunctionCall(key, expressions)
+                        let tys = key.signature.outputs.clone();
+                        let id = Identifier {
+                            id: CoreIdentifier::Call(key.clone()),
+                            version: *self
+                                .call_count
+                                .get(&(self.module_id.clone(), key.clone()))
+                                .unwrap(),
+                            stack: self.stack.clone(),
+                        };
+                        self.statement_buffer
+                            .push(TypedStatement::MultipleDefinition(
+                                vec![Variable::with_id_and_type(id.clone(), tys[0].clone())],
+                                TypedExpressionList::FunctionCall(key, expressions, tys),
+                            ));
+                        FieldElementExpression::Identifier(id)
                    }
                }
            }
@ -277,7 +299,23 @@ impl<'ast, T: Field> Folder<'ast, T> for Inliner<'ast, T> {
                        TypedExpression::Boolean(e) => e,
                        _ => unreachable!(),
                    },
-                    Err((key, expressions)) => BooleanExpression::FunctionCall(key, expressions),
+                    Err((key, expressions)) => {
+                        let tys = key.signature.outputs.clone();
+                        let id = Identifier {
+                            id: CoreIdentifier::Call(key.clone()),
+                            version: *self
+                                .call_count
+                                .get(&(self.module_id.clone(), key.clone()))
+                                .unwrap(),
+                            stack: self.stack.clone(),
+                        };
+                        self.statement_buffer
+                            .push(TypedStatement::MultipleDefinition(
+                                vec![Variable::with_id_and_type(id.clone(), tys[0].clone())],
+                                TypedExpressionList::FunctionCall(key, expressions, tys),
+                            ));
+                        BooleanExpression::Identifier(id)
+                    }
                }
            }
            e => fold_boolean_expression(self, e),
@ -300,7 +338,23 @@ impl<'ast, T: Field> Folder<'ast, T> for Inliner<'ast, T> {
                        TypedExpression::Array(e) => e.into_inner(),
                        _ => unreachable!(),
                    },
-                    Err((key, expressions)) => ArrayExpressionInner::FunctionCall(key, expressions),
+                    Err((key, expressions)) => {
+                        let tys = key.signature.outputs.clone();
+                        let id = Identifier {
+                            id: CoreIdentifier::Call(key.clone()),
+                            version: *self
+                                .call_count
+                                .get(&(self.module_id.clone(), key.clone()))
+                                .unwrap(),
+                            stack: self.stack.clone(),
+                        };
+                        self.statement_buffer
+                            .push(TypedStatement::MultipleDefinition(
+                                vec![Variable::with_id_and_type(id.clone(), tys[0].clone())],
+                                TypedExpressionList::FunctionCall(key, expressions, tys),
+                            ));
+                        ArrayExpressionInner::Identifier(id)
+                    }
                }
            }
            // default
@ -323,7 +377,21 @@ impl<'ast, T: Field> Folder<'ast, T> for Inliner<'ast, T> {
                        _ => unreachable!(),
                    },
                    Err((key, expressions)) => {
-                        StructExpressionInner::FunctionCall(key, expressions)
+                        let tys = key.signature.outputs.clone();
+                        let id = Identifier {
+                            id: CoreIdentifier::Call(key.clone()),
+                            version: *self
+                                .call_count
+                                .get(&(self.module_id.clone(), key.clone()))
+                                .unwrap(),
+                            stack: self.stack.clone(),
+                        };
+                        self.statement_buffer
+                            .push(TypedStatement::MultipleDefinition(
+                                vec![Variable::with_id_and_type(id.clone(), tys[0].clone())],
+                                TypedExpressionList::FunctionCall(key, expressions, tys),
+                            ));
+                        StructExpressionInner::Identifier(id)
                    }
                }
            }
--- a/zokrates_core/src/static_analysis/mod.rs
+++ b/zokrates_core/src/static_analysis/mod.rs
@ -36,6 +36,8 @@ impl<'ast, T: Field> TypedProgram<'ast, T> {
        // inline
        let r = Inliner::inline(r);

+        println!("{}", r);
+
        // propagate
        let r = Propagator::propagate(r);

--- a/zokrates_core/src/static_analysis/propagation.rs
+++ b/zokrates_core/src/static_analysis/propagation.rs
@ -453,6 +453,7 @@ impl<'ast, T: Field> Folder<'ast, T> for Propagator<'ast, T> {
                    (a, i) => UExpressionInner::Select(box a.annotate(inner_type, size), box i),
                }
            }
+            //UintExpressionInner::FunctionCall(key, arguments) => unreachable!("Function call outside of multidef"),
            e => fold_uint_expression_inner(self, bitwidth, e),
        }
    }
@ -608,6 +609,9 @@ impl<'ast, T: Field> Folder<'ast, T> for Propagator<'ast, T> {
                    inner => FieldElementExpression::Member(box inner.annotate(members), m),
                }
            }
+            FieldElementExpression::FunctionCall(key, arguments) => {
+                unreachable!("Function call outside of multidef")
+            }
            e => fold_field_expression(self, e),
        }
    }
@ -710,7 +714,9 @@ impl<'ast, T: Field> Folder<'ast, T> for Propagator<'ast, T> {
                    inner => ArrayExpressionInner::Member(box inner.annotate(members), m),
                }
            }
-            ArrayExpressionInner::FunctionCall(key, arguments) => unimplemented!(),
+            ArrayExpressionInner::FunctionCall(key, arguments) => {
+                unreachable!("Function call outside of multidef")
+            }
            e => fold_array_expression_inner(self, ty, size, e),
        }
    }
@ -813,6 +819,9 @@ impl<'ast, T: Field> Folder<'ast, T> for Propagator<'ast, T> {
                    inner => StructExpressionInner::Member(box inner.annotate(members), m),
                }
            }
+            StructExpressionInner::FunctionCall(key, arguments) => {
+                unreachable!("Function call outside of multidef")
+            }
            e => fold_struct_expression_inner(self, ty, e),
        }
    }
@ -1017,6 +1026,9 @@ impl<'ast, T: Field> Folder<'ast, T> for Propagator<'ast, T> {
                    inner => BooleanExpression::Member(box inner.annotate(members), m),
                }
            }
+            BooleanExpression::FunctionCall(key, arguments) => {
+                unreachable!("Function call outside of multidef")
+            }
            e => fold_boolean_expression(self, e),
        }
    }
--- a/zokrates_core/src/static_analysis/uint_optimizer.rs
+++ b/zokrates_core/src/static_analysis/uint_optimizer.rs
@ -462,24 +462,6 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> {
                    ),
                })
            }
-            FunctionCall(key, arguments) => {
-                if key.signature == FlatEmbed::U32FromBits.signature::<T>().into() {
-                    FunctionCall(
-                        key,
-                        arguments
-                            .into_iter()
-                            .map(|a| self.fold_expression(a))
-                            .collect(),
-                    )
-                    .annotate(32)
-                    .metadata(UMetadata {
-                        bitwidth: Some(32),
-                        should_reduce: Some(false),
-                    })
-                } else {
-                    unreachable!("oi")
-                }
-            }
            e => fold_uint_expression_inner(self, range, e).annotate(range),
        };

@ -521,20 +503,20 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> {
                ZirExpressionList::FunctionCall(key, arguments, ty) => match key.clone().id {
                    "_U32_FROM_BITS" => {
                        assert_eq!(lhs.len(), 1);
-                        let expr = UExpressionInner::FunctionCall(
-                            key.clone(),
-                            arguments
-                                .clone()
-                                .into_iter()
-                                .map(|a| self.fold_expression(a))
-                                .collect(),
-                        )
-                        .annotate(32)
-                        .metadata(UMetadata {
-                            bitwidth: Some(32),
-                            should_reduce: Some(true),
-                        });
-                        self.register(lhs[0].clone(), ZirExpression::Uint(expr));
+                        // let expr = UExpressionInner::FunctionCall(
+                        //     key.clone(),
+                        //     arguments
+                        //         .clone()
+                        //         .into_iter()
+                        //         .map(|a| self.fold_expression(a))
+                        //         .collect(),
+                        // )
+                        // .annotate(32)
+                        // .metadata(UMetadata {
+                        //     bitwidth: Some(32),
+                        //     should_reduce: Some(true),
+                        // });
+                        // self.register(lhs[0].clone(), ZirExpression::Uint(expr));
                        vec![ZirStatement::MultipleDefinition(
                            lhs,
                            ZirExpressionList::FunctionCall(key, arguments, ty),
--- a/zokrates_core/src/typed_absy/identifier.rs
+++ b/zokrates_core/src/typed_absy/identifier.rs
@ -6,6 +6,7 @@ use typed_absy::TypedModuleId;
 pub enum CoreIdentifier<'ast> {
    Source(&'ast str),
    Internal(&'static str, usize),
+    Call(FunctionKey<'ast>),
 }

 impl<'ast> fmt::Display for CoreIdentifier<'ast> {
@ -13,6 +14,7 @@ impl<'ast> fmt::Display for CoreIdentifier<'ast> {
        match self {
            CoreIdentifier::Source(s) => write!(f, "{}", s),
            CoreIdentifier::Internal(s, i) => write!(f, "#INTERNAL#_{}_{}", s, i),
+            CoreIdentifier::Call(k) => write!(f, "{}", k.to_slug()),
        }
    }
 }
--- a/zokrates_core/src/zir/folder.rs
+++ b/zokrates_core/src/zir/folder.rs
@ -180,10 +180,6 @@ pub fn fold_field_expression<'ast, T: Field, F: Folder<'ast, T>>(
            let alt = f.fold_field_expression(alt);
            FieldElementExpression::IfElse(box cond, box cons, box alt)
        }
-        FieldElementExpression::FunctionCall(key, exps) => {
-            let exps = exps.into_iter().map(|e| f.fold_expression(e)).collect();
-            FieldElementExpression::FunctionCall(key, exps)
-        }
    }
 }

@ -318,10 +314,6 @@ pub fn fold_uint_expression_inner<'ast, T: Field, F: Folder<'ast, T>>(

            UExpressionInner::Not(box e)
        }
-        UExpressionInner::FunctionCall(key, exps) => {
-            let exps = exps.into_iter().map(|e| f.fold_expression(e)).collect();
-            UExpressionInner::FunctionCall(key, exps)
-        }
        UExpressionInner::IfElse(box cond, box cons, box alt) => {
            let cond = f.fold_boolean_expression(cond);
            let cons = f.fold_uint_expression(cons);
--- a/zokrates_core/src/zir/mod.rs
+++ b/zokrates_core/src/zir/mod.rs
@ -376,7 +376,6 @@ pub enum FieldElementExpression<'ast, T: Field> {
        Box<FieldElementExpression<'ast, T>>,
        Box<FieldElementExpression<'ast, T>>,
    ),
-    FunctionCall(FunctionKey<'ast>, Vec<ZirExpression<'ast, T>>),
 }

 /// An expression of type `bool`
@ -477,16 +476,6 @@ impl<'ast, T: Field> fmt::Display for FieldElementExpression<'ast, T> {
                    condition, consequent, alternative
                )
            }
-            FieldElementExpression::FunctionCall(ref k, ref p) => {
-                write!(f, "{}(", k.id,)?;
-                for (i, param) in p.iter().enumerate() {
-                    write!(f, "{}", param)?;
-                    if i < p.len() - 1 {
-                        write!(f, ", ")?;
-                    }
-                }
-                write!(f, ")")
-            }
        }
    }
 }
@ -510,16 +499,6 @@ impl<'ast, T: Field> fmt::Display for UExpression<'ast, T> {
                "if {} then {} else {} fi",
                condition, consequent, alternative
            ),
-            UExpressionInner::FunctionCall(ref k, ref p) => {
-                write!(f, "{}(", k.id,)?;
-                for (i, param) in p.iter().enumerate() {
-                    write!(f, "{}", param)?;
-                    if i < p.len() - 1 {
-                        write!(f, ", ")?;
-                    }
-                }
-                write!(f, ")")
-            }
        }
    }
 }
@ -572,11 +551,6 @@ impl<'ast, T: Field> fmt::Debug for FieldElementExpression<'ast, T> {
                    condition, consequent, alternative
                )
            }
-            FieldElementExpression::FunctionCall(ref i, ref p) => {
-                write!(f, "FunctionCall({:?}, (", i)?;
-                f.debug_list().entries(p.iter()).finish()?;
-                write!(f, ")")
-            }
        }
    }
 }
--- a/zokrates_core/src/zir/uint.rs
+++ b/zokrates_core/src/zir/uint.rs
@ -97,7 +97,6 @@ pub enum UExpressionInner<'ast, T: Field> {
        Box<UExpression<'ast, T>>,
        Box<FieldElementExpression<'ast, T>>,
    ),
-    FunctionCall(FunctionKey<'ast>, Vec<ZirExpression<'ast, T>>),
    Not(Box<UExpression<'ast, T>>),
    IfElse(
        Box<BooleanExpression<'ast, T>>,
--- a/zokrates_parser/src/zokrates.pest
+++ b/zokrates_parser/src/zokrates.pest
@ -1,7 +1,3 @@
-/**
-* ZoKrates Grammar
-* Author: Jacob Eberhardt, Thibaut Schaeffer
-*/

 file = { SOI ~ NEWLINE* ~ import_directive* ~ NEWLINE* ~ ty_struct_definition* ~ NEWLINE* ~ function_definition* ~ EOI }