feat: trait inheritance

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -3,7 +3,7 @@ use std::{
     rc::Rc,
 };
 
-use crate::{ast::ItemVisibility, hir_def::traits::ResolvedTraitBound, StructField};
+use crate::{ast::ItemVisibility, hir_def::traits::ResolvedTraitBound, StructField, TypeBindings};
 use crate::{
     ast::{
         BlockExpression, FunctionKind, GenericTypeArgs, Ident, NoirFunction, NoirStruct, Param,
@@ -1033,6 +1033,25 @@ impl<'context> Elaborator<'context> {
             return;
         };
 
+        if the_trait.trait_bounds.is_empty() {
+            return;
+        }
+
+        let impl_trait = the_trait.name.to_string();
+        let the_trait_file = the_trait.location.file;
+
+        let mut bindings = TypeBindings::new();
+        for (param, arg) in the_trait.generics.iter().zip(trait_impl.resolved_trait_generics.iter())
+        {
+            // Avoid binding t = t
+            if !arg.occurs(param.type_var.id()) {
+                bindings.insert(
+                    param.type_var.id(),
+                    (param.type_var.clone(), param.kind(), arg.clone()),
+                );
+            }
+        }
+
         // Note: we only check if the immediate parents are implemented, we don't check recursively.
         // Why? If a parent isn't implemented, we get an error. If a parent is implemented, we'll
         // do the same check for the parent, so this trait's parents parents will be checked, so the
@@ -1043,6 +1062,13 @@ impl<'context> Elaborator<'context> {
                 continue;
             };
 
+            let parent_trait_bound = ResolvedTraitBound {
+                trait_generics: parent_trait_bound
+                    .trait_generics
+                    .map(|typ| typ.substitute(&bindings)),
+                ..parent_trait_bound
+            };
+
             if self
                 .interner
                 .try_lookup_trait_implementation(
@@ -1053,17 +1079,14 @@ impl<'context> Elaborator<'context> {
                 )
                 .is_err()
             {
-                let mut the_trait = parent_trait.name.to_string();
-                if !parent_trait_bound.trait_generics.is_empty() {
-                    the_trait.push('<');
-                    the_trait.push_str(&parent_trait_bound.trait_generics.to_string());
-                    the_trait.push('>');
-                }
-
+                let missing_trait =
+                    format!("{}{}", parent_trait.name, parent_trait_bound.trait_generics);
                 self.push_err(ResolverError::TraitNotImplemented {
-                    the_trait,
-                    typ: trait_impl.object_type.to_string(),
+                    impl_trait: impl_trait.clone(),
+                    missing_trait,
+                    type_missing_trait: trait_impl.object_type.to_string(),
                     span: trait_impl.object_type.span,
+                    missing_trait_location: Location::new(parent_trait_bound.span, the_trait_file),
                 });
             }
         }

compiler/noirc_frontend/src/hir/resolution/errors.rs

@@ -1,6 +1,6 @@
 use acvm::FieldElement;
 pub use noirc_errors::Span;
-use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic};
+use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic, Location};
 use thiserror::Error;
 
 use crate::{
@@ -150,8 +150,14 @@ pub enum ResolverError {
     AttributeFunctionIsNotAPath { function: String, span: Span },
     #[error("Attribute function `{name}` is not in scope")]
     AttributeFunctionNotInScope { name: String, span: Span },
-    #[error("The trait `{the_trait}` is not implemented for `{typ}")]
-    TraitNotImplemented { the_trait: String, typ: String, span: Span },
+    #[error("The trait `{missing_trait}` is not implemented for `{type_missing_trait}")]
+    TraitNotImplemented {
+        impl_trait: String,
+        missing_trait: String,
+        type_missing_trait: String,
+        span: Span,
+        missing_trait_location: Location,
+    },
 }
 
 impl ResolverError {
@@ -581,12 +587,13 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             },
-            ResolverError::TraitNotImplemented { the_trait, typ, span} => {
-                Diagnostic::simple_error(
-                    format!("The trait `{the_trait}` is not implemented for `{typ}"),
-                    String::new(),
-                    *span,
-                )
+            ResolverError::TraitNotImplemented { impl_trait, missing_trait: the_trait, type_missing_trait: typ, span, missing_trait_location} => {
+                let mut diagnostic = Diagnostic::simple_error(
+                    format!("The trait bound `{typ}: {the_trait}` is not satisfied"), 
+                    format!("The trait `{the_trait}` is not implemented for `{typ}")
+                    , *span);
+                diagnostic.add_secondary_with_file(format!("required by this bound in `{impl_trait}"), missing_trait_location.span, missing_trait_location.file);
+                diagnostic
             },
         }
     }

compiler/noirc_frontend/src/tests.rs

@@ -4,6 +4,7 @@ mod bound_checks;
 mod imports;
 mod name_shadowing;
 mod references;
+mod traits;
 mod turbofish;
 mod unused_items;
 mod visibility;
@@ -3359,110 +3360,32 @@ fn error_if_attribute_not_in_scope() {
 }
 
 #[test]
-fn trait_inheritance() {
+fn arithmetic_generics_rounding_pass() {
     let src = r#"
-        pub trait Foo {
-            fn foo(self) -> Field;
-        }
-
-        pub trait Bar {
-            fn bar(self) -> Field;
-        }
-
-        pub trait Baz: Foo + Bar {
-            fn baz(self) -> Field;
-        }
-
-        pub fn foo<T>(baz: T) -> (Field, Field, Field) where T: Baz {
-            (baz.foo(), baz.bar(), baz.baz())
-        }
-
-        fn main() {}
-    "#;
-    assert_no_errors(src);
-}
-
-#[test]
-fn trait_inheritance_with_generics() {
-    let src = r#"
-        trait Foo<T> {
-            fn foo(self) -> T;
-        }
-
-        trait Bar<U>: Foo<U> {
-            fn bar(self);
-        }
-
-        pub fn foo<T>(x: T) -> i32 where T: Bar<i32> {
-            x.foo()
-        }
-
-        fn main() {}
-    "#;
-    assert_no_errors(src);
-}
-
-#[test]
-fn trait_inheritance_with_generics_2() {
-    let src = r#"
-        pub trait Foo<T> {
-            fn foo(self) -> T;
-        }
-
-        pub trait Bar<T, U>: Foo<T> {
-            fn bar(self) -> (T, U);
-        }
-
-        pub fn foo<T>(x: T) -> i32 where T: Bar<i32, i32> {
-            x.foo()
+        fn main() {
+            // 3/2*2 = 2
+            round::<3, 2>([1, 2]);
         }
 
-        fn main() {}
+        fn round<let N: u32, let M: u32>(_x: [Field; N / M * M]) {}
     "#;
-    assert_no_errors(src);
-}
 
-#[test]
-fn trait_inheritance_dependency_cycle() {
-    let src = r#"
-        trait Foo: Bar {}
-        trait Bar: Foo {}
-        fn main() {}
-    "#;
     let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
-
-    assert!(matches!(
-        errors[0].0,
-        CompilationError::ResolverError(ResolverError::DependencyCycle { .. })
-    ));
+    assert_eq!(errors.len(), 0);
 }
 
 #[test]
-fn trait_inheritance_missing_parent_implementation() {
+fn arithmetic_generics_rounding_fail() {
     let src = r#"
-        pub trait Foo {}
-
-        pub trait Bar: Foo {}
-
-        pub struct Struct {}
-
-        impl Bar for Struct {}
-
         fn main() {
-            let _ = Struct {}; // silence Struct never constructed warning
+            // Do not simplify N/M*M to just N
+            // This should be 3/2*2 = 2, not 3
+            round::<3, 2>([1, 2, 3]);
         }
+
+        fn round<let N: u32, let M: u32>(_x: [Field; N / M * M]) {}
     "#;
+
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
-
-    let CompilationError::ResolverError(ResolverError::TraitNotImplemented {
-        the_trait, typ, ..
-    }) = &errors[0].0
-    else {
-        panic!("Expected a TraitNotImplemented error, got {:?}", &errors[0].0);
-    };
-
-    assert_eq!(the_trait, "Foo");
-    assert_eq!(typ, "Struct");
 }