pest implicit number type

Cargo.lock

@@ -528,6 +528,7 @@ dependencies = [
  "snarkos-errors",
  "snarkos-gadgets",
  "snarkos-models",
+ "snarkos-utilities",
  "thiserror",
 ]
 

benchmark/simple.leo

@@ -1,29 +1,5 @@
-circuit PedersenHash {
+function main() {
+  let g: group = 123456789;
 
-  parameters: group[1]
 
-  static function new(parameters: group[1]) -> Self {
-    return Self { parameters: parameters }
-  }
-
-  function hash(bits: bool[1]) -> group {
-    let mut digest: group = 0group;
-
-    for i in 0..1 {
-      let base: group = if bits[i] ? parameters[i] : 0group;
-      digest += base;
-    }
-
-    return digest
-  }
-}
-
-function main() -> group {
-  let parameters = [0group; 1];
-  let pedersen = PedersenHash::new(parameters);
-
-  let input: bool[1] = [true];
-  let output = pedersen.hash(input);
-
-  return output
 }

compiler/Cargo.toml

@@ -10,6 +10,7 @@ snarkos-curves = { path = "../../snarkOS/curves", version = "0.8.0" }
 snarkos-errors = { path = "../../snarkOS/errors", version = "0.8.0" }
 snarkos-gadgets = { path = "../../snarkOS/gadgets", version = "0.8.0" }
 snarkos-models = { path = "../../snarkOS/models", version = "0.8.0" }
+snarkos-utilities = { path = "../../snarkOS/utilities", version = "0.8.0" }
 
 thiserror = { version = "1.0" }
 from-pest = { version = "0.3.1" }

compiler/src/ast.rs

@@ -247,6 +247,20 @@ impl<'ast> fmt::Display for Number<'ast> {
     }
 }
 
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::value_implicit))]
+pub struct NumberImplicit<'ast> {
+    pub number: Number<'ast>,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}
+
+impl<'ast> fmt::Display for NumberImplicit<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.number)
+    }
+}
+
 #[derive(Clone, Debug, FromPest, PartialEq)]
 #[pest_ast(rule(Rule::value_integer))]
 pub struct Integer<'ast> {
@@ -314,6 +328,7 @@ pub enum Value<'ast> {
     Field(Field<'ast>),
     Group(Group<'ast>),
     Boolean(Boolean<'ast>),
+    Implicit(NumberImplicit<'ast>),
 }
 
 impl<'ast> Value<'ast> {
@@ -323,6 +338,7 @@ impl<'ast> Value<'ast> {
             Value::Field(value) => &value.span,
             Value::Group(value) => &value.span,
             Value::Boolean(value) => &value.span,
+            Value::Implicit(value) => &value.span,
         }
     }
 }
@@ -334,6 +350,7 @@ impl<'ast> fmt::Display for Value<'ast> {
             Value::Field(ref value) => write!(f, "{}", value),
             Value::Group(ref value) => write!(f, "{}", value),
             Value::Boolean(ref value) => write!(f, "{}", value),
+            Value::Implicit(ref value) => write!(f, "{}", value),
         }
     }
 }

compiler/src/leo.pest

@@ -89,11 +89,12 @@ type_list = _{(_type ~ ("," ~ _type)*)?}
 /// Values
 
 value_number = @{ "0" | ASCII_NONZERO_DIGIT ~ ASCII_DIGIT* }
+value_implicit = { value_number }
 value_integer = { value_number ~ type_integer? }
 value_field = { value_number ~ type_field }
 value_group = { value_number ~ type_group }
 value_boolean = { "true" | "false" }
-value = { value_field | value_group | value_boolean | value_integer }
+value = { value_field | value_group | value_boolean | value_integer | value_implicit }
 expression_primitive = { value | identifier }
 
 /// Variables + Mutability

compiler/src/types_from.rs

@@ -124,8 +124,13 @@ impl<'ast, F: Field + PrimeField, G: Group> From<ast::Field<'ast>> for types::Ex
 /// pest ast -> types::Group
 
 impl<'ast, F: Field + PrimeField, G: Group> From<ast::Group<'ast>> for types::Expression<F, G> {
-    fn from(_group: ast::Group<'ast>) -> Self {
-        types::Expression::GroupElement(G::zero())
+    fn from(group: ast::Group<'ast>) -> Self {
+        use std::str::FromStr;
+
+        let scalar = G::ScalarField::from_str(&group.number.value).unwrap_or_default();
+        let point = G::default().mul(&scalar);
+
+        types::Expression::GroupElement(point)
     }
 }
 
@@ -142,6 +147,16 @@ impl<'ast, F: Field + PrimeField, G: Group> From<ast::Boolean<'ast>> for types::
     }
 }
 
+/// pest ast -> types::NumberImplicit
+
+impl<'ast, F: Field + PrimeField, G: Group> From<ast::NumberImplicit<'ast>>
+    for types::Expression<F, G>
+{
+    fn from(_number: ast::NumberImplicit<'ast>) -> Self {
+        unimplemented!()
+    }
+}
+
 /// pest ast -> types::Expression
 
 impl<'ast, F: Field + PrimeField, G: Group> From<ast::Value<'ast>> for types::Expression<F, G> {
@@ -151,6 +166,7 @@ impl<'ast, F: Field + PrimeField, G: Group> From<ast::Value<'ast>> for types::Ex
             ast::Value::Field(field) => types::Expression::from(field),
             ast::Value::Group(group) => types::Expression::from(group),
             ast::Value::Boolean(bool) => types::Expression::from(bool),
+            ast::Value::Implicit(value) => types::Expression::from(value),
         }
     }
 }