feat: Implement traits - first prototype

crates/nargo_cli/tests/compile_tests_data/fail/dup_trait_declaration.nr

@@ -0,0 +1,26 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+impl Default for Foo {
+    fn default(x: Field,y: Field) -> Self {
+        Self { bar: x, array: [x,y] }
+    }
+}
+
+// Duplicate trait declarations should not compile
+trait Default {
+    fn default(x: Field) -> Self;
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/dup_trait_implementation.nr

@@ -0,0 +1,30 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+// Duplicate trait implementations should not compile
+impl Default for Foo {
+    fn default(x: Field,y: Field) -> Self {
+        Self { bar: x, array: [x,y] }
+    }
+}
+
+// Duplicate trait implementations should not compile
+impl Default for Foo {
+    fn default(x: Field, y: Field) -> Self {
+        Self { bar: y, array: [y,x] }
+    }
+}
+
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/impl_struct_not_trait.nr

@@ -0,0 +1,23 @@
+use dep::std;
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+struct Default {
+    x: Field,
+    z: Field, 
+}
+
+// Default is struct not a trait
+impl Default for Foo {
+    fn default(x: Field, y: Field) -> Self {
+        Self { bar: x, array: [x,y] }
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/trait_implementation_wrong_parameter.nr

@@ -0,0 +1,21 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+impl Default for Foo {
+    fn default(x: Field) -> Self {
+        Self { bar: x, array: [x, x] }
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/trait_not_exists.nr

@@ -0,0 +1,18 @@
+use dep::std;
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+// Default trait does not exist
+impl Default for Foo {
+    fn default(x: Field, y: Field) -> Self {
+        Self { bar: x, array: [x,y] }
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/trait_wrong_method_name.nr

@@ -0,0 +1,22 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+// wrong trait name method should not compile
+impl Default for Foo {
+    fn default_wrong_name(x: Field, y: Field) -> Self {
+        Self { bar: x, array: [x,y] }
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default_wrong_name(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/trait_wrong_method_return_type.nr

@@ -0,0 +1,21 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+impl Default for Foo {
+    fn default(x: Field, y: Field) -> Field {
+        x
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/trait_wrong_parameter.nr

@@ -0,0 +1,21 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+impl Default for Foo {
+    fn default(x: Field, y: Foo) -> Self {
+        Self { bar: x, array: [x, y.bar] }
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/compile_tests_data/fail/trait_wrong_parameters_count.nr

@@ -0,0 +1,21 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+impl Default for Foo {
+    fn default(x: Field) -> Self {
+        Self { bar: x, array: [x, x] }
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/test_data/traits/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "traits"
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data/traits/Prover.toml

@@ -0,0 +1,2 @@
+x = "5"
+y = "1"

crates/nargo_cli/tests/test_data/traits/src/main.nr

@@ -0,0 +1,21 @@
+use dep::std;
+
+trait Default {
+    fn default(x: Field, y: Field) -> Self;
+}
+
+struct Foo {
+    bar: Field,
+    array: [Field; 2],
+}
+
+impl Default for Foo {
+    fn default(x: Field,y: Field) -> Self {
+        Self { bar: x, array: [x,y] }
+    }
+}
+
+fn main(x: Field, y: Field) {
+    let first = Foo::default(x,y);
+    assert(first.bar == x);
+}

crates/nargo_cli/tests/test_data/traits/target/main.json

@@ -0,0 +1 @@
+{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":[155,194,60,97,194,4,0],"proving_key":null,"verification_key":null}

crates/noirc_frontend/src/ast/traits.rs

@@ -3,14 +3,16 @@ use std::fmt::Display;
 use iter_extended::vecmap;
 use noirc_errors::Span;
 
-use crate::{Ident, NoirFunction, UnresolvedGenerics, UnresolvedType};
+use crate::{BlockExpression, Expression, Ident, NoirFunction, UnresolvedGenerics, UnresolvedType};
 
 /// AST node for trait definitions:
 /// `trait name<generics> { ... items ... }`
 #[derive(Clone, Debug)]
 pub struct NoirTrait {
     pub name: Ident,
     pub generics: Vec<Ident>,
+    pub where_clause: Vec<TraitConstraint>,
+    pub span: Span,
     pub items: Vec<TraitItem>,
 }
 
@@ -24,6 +26,12 @@ pub enum TraitItem {
         parameters: Vec<(Ident, UnresolvedType)>,
         return_type: UnresolvedType,
         where_clause: Vec<TraitConstraint>,
+        body: Option<BlockExpression>,
+    },
+    Constant {
+        name: Ident,
+        typ: UnresolvedType,
+        default_value: Option<Expression>,
     },
     Type {
         name: Ident,
@@ -68,6 +76,7 @@ pub struct TraitConstraint {
 #[derive(Clone, Debug)]
 pub enum TraitImplItem {
     Function(NoirFunction),
+    Constant(Ident, UnresolvedType, Expression),
     Type { name: Ident, alias: UnresolvedType },
 }
 
@@ -110,7 +119,7 @@ impl Display for NoirTrait {
 impl Display for TraitItem {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            TraitItem::Function { name, generics, parameters, return_type, where_clause } => {
+            TraitItem::Function { name, generics, parameters, return_type, where_clause, body } => {
                 let generics = vecmap(generics, |generic| generic.to_string());
                 let parameters = vecmap(parameters, |(name, typ)| format!("{name}: {typ}"));
                 let where_clause = vecmap(where_clause, ToString::to_string);
@@ -121,9 +130,25 @@ impl Display for TraitItem {
 
                 write!(
                     f,
-                    "fn {name}<{}>({}) -> {} where {};",
+                    "fn {name}<{}>({}) -> {} where {}",
                     generics, parameters, return_type, where_clause
-                )
+                )?;
+
+                if let Some(body) = body {
+                    write!(f, "{}", body)
+                } else {
+                    write!(f, ";")
+                }
+            }
+            TraitItem::Constant { name, typ, default_value } => {
+                // TODO: Shall we use `comptime` or `const` here?
+                write!(f, "comptime {}: {}", name, typ)?;
+
+                if let Some(default_value) = default_value {
+                    write!(f, "{};", default_value)
+                } else {
+                    write!(f, ";")
+                }
             }
             TraitItem::Type { name } => write!(f, "type {name};"),
         }
@@ -159,7 +184,11 @@ impl Display for TraitImplItem {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             TraitImplItem::Function(function) => function.fmt(f),
-            TraitImplItem::Type { name, alias } => write!(f, "type {name} = {alias}"),
+            TraitImplItem::Type { name, alias } => write!(f, "type {name} = {alias};"),
+            // TODO: Should we use `comptime` or `const` here?
+            TraitImplItem::Constant(name, typ, value) => {
+                write!(f, "comptime {}: {} = {};", name, typ, value)
+            }
         }
     }
 }