feat: Impls with generics

crates/nargo/tests/test_data/generics/src/main.nr

@@ -8,10 +8,33 @@ fn foo<T>(bar: Bar<T>) {
     constrain bar.one == bar.two;
 }
 
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        constrain first.limbs != second.limbs;
+        first
+    }
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        constrain first.limbs != second.limbs;
+        second
+    }
+}
+
 fn main(x: Field, y: Field) {
     let bar1: Bar<Field> = Bar { one: x, two: y, other: 0 };
     let bar2 = Bar { one: x, two: y, other: [0] };
 
     foo(bar1);
     foo(bar2);
+
+    // Test generic impls
+    let int1 = BigInt { limbs: [1] };
+    let int2 = BigInt { limbs: [2] };
+    let BigInt { limbs } = int1.second(int2).first(int1);
+    constrain limbs == int2.limbs;
 }

crates/noirc_driver/src/lib.rs

@@ -3,7 +3,7 @@ use acvm::acir::circuit::Circuit;
 use acvm::Language;
 use fm::FileType;
 use noirc_abi::Abi;
-use noirc_errors::{DiagnosableError, ReportedError, Reporter};
+use noirc_errors::{reporter, ReportedError};
 use noirc_evaluator::create_circuit;
 use noirc_frontend::graph::{CrateId, CrateName, CrateType, LOCAL_CRATE};
 use noirc_frontend::hir::def_map::CrateDefMap;
@@ -47,14 +47,7 @@ impl Driver {
     pub fn file_compiles(&mut self) -> bool {
         let mut errs = vec![];
         CrateDefMap::collect_defs(LOCAL_CRATE, &mut self.context, &mut errs);
-        for errors in &errs {
-            Reporter::with_diagnostics(
-                Some(errors.file_id),
-                &self.context.file_manager,
-                &errors.errors,
-                false,
-            );
-        }
+        reporter::report_all(&self.context.file_manager, &errs, false);
         errs.is_empty()
     }
 
@@ -135,17 +128,8 @@ impl Driver {
     pub fn check_crate(&mut self, allow_warnings: bool) -> Result<(), ReportedError> {
         let mut errs = vec![];
         CrateDefMap::collect_defs(LOCAL_CRATE, &mut self.context, &mut errs);
-        let mut error_count = 0;
-        for errors in &errs {
-            error_count += Reporter::with_diagnostics(
-                Some(errors.file_id),
-                &self.context.file_manager,
-                &errors.errors,
-                allow_warnings,
-            );
-        }
-
-        Reporter::finish(error_count)
+        let error_count = reporter::report_all(&self.context.file_manager, &errs, allow_warnings);
+        reporter::finish_report(error_count)
     }
 
     pub fn compute_abi(&self) -> Option<Abi> {
@@ -207,12 +191,10 @@ impl Driver {
             Err(err) => {
                 // The FileId here will be the file id of the file with the main file
                 // Errors will be shown at the call site without a stacktrace
-                let file_id = err.location.map(|loc| loc.file);
-                let error = &[err.to_diagnostic()];
+                let file = err.location.map(|loc| loc.file);
                 let files = &self.context.file_manager;
-
-                let error_count = Reporter::with_diagnostics(file_id, files, error, allow_warnings);
-                Reporter::finish(error_count)?;
+                let error = reporter::report(files, &err.into(), file, allow_warnings);
+                reporter::finish_report(error as u32)?;
                 Err(ReportedError)
             }
         }

crates/noirc_errors/src/lib.rs

@@ -1,19 +1,25 @@
 mod position;
-mod reporter;
-
+pub mod reporter;
 pub use position::{Location, Position, Span, Spanned};
-pub use reporter::*;
-
-pub trait DiagnosableError {
-    fn to_diagnostic(&self) -> CustomDiagnostic;
-}
+pub use reporter::{CustomDiagnostic, DiagnosticKind};
 
 /// Returned when the Reporter finishes after reporting errors
 #[derive(Copy, Clone)]
 pub struct ReportedError;
 
 #[derive(Debug, PartialEq, Eq)]
-pub struct CollectedErrors {
+pub struct FileDiagnostic {
     pub file_id: fm::FileId,
-    pub errors: Vec<CustomDiagnostic>,
+    pub diagnostic: CustomDiagnostic,
+}
+
+/// Extension trait just to enable the syntax err.in_file(..) for CustomDiagnostic
+pub trait IntoFileDiagnostic {
+    fn in_file(self, id: fm::FileId) -> FileDiagnostic;
+}
+
+impl IntoFileDiagnostic for CustomDiagnostic {
+    fn in_file(self, file_id: fm::FileId) -> FileDiagnostic {
+        FileDiagnostic { file_id, diagnostic: self }
+    }
 }

crates/noirc_errors/src/reporter.rs

@@ -1,10 +1,9 @@
-use crate::{ReportedError, Span};
+use crate::{FileDiagnostic, ReportedError, Span};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use codespan_reporting::term;
 use codespan_reporting::term::termcolor::{
     Color, ColorChoice, ColorSpec, StandardStream, WriteColor,
 };
-use fm::FileId;
 use std::io::Write;
 
 #[derive(Debug, PartialEq, Eq)]
@@ -64,6 +63,10 @@ impl CustomDiagnostic {
     pub fn add_secondary(&mut self, message: String, span: Span) {
         self.secondaries.push(CustomLabel::new(message, span));
     }
+
+    fn is_error(&self) -> bool {
+        matches!(self.kind, DiagnosticKind::Error)
+    }
 }
 
 impl std::fmt::Display for CustomDiagnostic {
@@ -94,71 +97,72 @@ impl CustomLabel {
     }
 }
 
-pub struct Reporter;
-
-impl Reporter {
-    /// Writes the given diagnostics to stderr and returns the count
-    /// of diagnostics that were errors.
-    pub fn with_diagnostics(
-        file_id: Option<FileId>,
-        files: &fm::FileManager,
-        diagnostics: &[CustomDiagnostic],
-        allow_warnings: bool,
-    ) -> usize {
-        let mut error_count = 0;
-
-        // Convert each Custom Diagnostic into a diagnostic
-        let diagnostics = diagnostics.iter().map(|cd| {
-            let diagnostic = match (cd.kind, allow_warnings) {
-                (DiagnosticKind::Warning, true) => Diagnostic::warning(),
-                _ => {
-                    error_count += 1;
-                    Diagnostic::error()
-                }
-            };
-
-            let secondary_labels = if let Some(f_id) = file_id {
-                cd.secondaries
-                    .iter()
-                    .map(|sl| {
-                        let start_span = sl.span.start() as usize;
-                        let end_span = sl.span.end() as usize + 1;
-
-                        Label::secondary(f_id.as_usize(), start_span..end_span)
-                            .with_message(&sl.message)
-                    })
-                    .collect()
-            } else {
-                Vec::new()
-            };
-            diagnostic
-                .with_message(&cd.message)
-                .with_labels(secondary_labels)
-                .with_notes(cd.notes.clone())
-        });
+/// Writes the given diagnostics to stderr and returns the count
+/// of diagnostics that were errors.
+pub fn report_all(
+    files: &fm::FileManager,
+    diagnostics: &[FileDiagnostic],
+    allow_warnings: bool,
+) -> u32 {
+    diagnostics
+        .iter()
+        .map(|error| report(files, &error.diagnostic, Some(error.file_id), allow_warnings) as u32)
+        .sum()
+}
 
-        let writer = StandardStream::stderr(ColorChoice::Always);
-        let config = codespan_reporting::term::Config::default();
+/// Report the given diagnostic, and return true if it was an error
+pub fn report(
+    files: &fm::FileManager,
+    custom_diagnostic: &CustomDiagnostic,
+    file: Option<fm::FileId>,
+    allow_warnings: bool,
+) -> bool {
+    let writer = StandardStream::stderr(ColorChoice::Always);
+    let config = codespan_reporting::term::Config::default();
 
-        for diagnostic in diagnostics {
-            term::emit(&mut writer.lock(), &config, files.as_simple_files(), &diagnostic).unwrap();
-        }
+    let diagnostic = convert_diagnostic(custom_diagnostic, file, allow_warnings);
+    term::emit(&mut writer.lock(), &config, files.as_simple_files(), &diagnostic).unwrap();
 
-        error_count
-    }
+    !allow_warnings || custom_diagnostic.is_error()
+}
+
+fn convert_diagnostic(
+    cd: &CustomDiagnostic,
+    file: Option<fm::FileId>,
+    allow_warnings: bool,
+) -> Diagnostic<usize> {
+    let diagnostic = match (cd.kind, allow_warnings) {
+        (DiagnosticKind::Warning, true) => Diagnostic::warning(),
+        _ => Diagnostic::error(),
+    };
+
+    let secondary_labels = if let Some(file_id) = file {
+        cd.secondaries
+            .iter()
+            .map(|sl| {
+                let start_span = sl.span.start() as usize;
+                let end_span = sl.span.end() as usize + 1;
+                Label::secondary(file_id.as_usize(), start_span..end_span).with_message(&sl.message)
+            })
+            .collect()
+    } else {
+        vec![]
+    };
+
+    diagnostic.with_message(&cd.message).with_labels(secondary_labels).with_notes(cd.notes.clone())
+}
 
-    pub fn finish(error_count: usize) -> Result<(), ReportedError> {
-        if error_count != 0 {
-            let writer = StandardStream::stderr(ColorChoice::Always);
-            let mut writer = writer.lock();
+pub fn finish_report(error_count: u32) -> Result<(), ReportedError> {
+    if error_count != 0 {
+        let writer = StandardStream::stderr(ColorChoice::Always);
+        let mut writer = writer.lock();
 
-            writer.set_color(ColorSpec::new().set_fg(Some(Color::Red))).unwrap();
-            writeln!(&mut writer, "error: aborting due to {error_count} previous errors").unwrap();
-            writer.reset().ok(); // Ignore any IO errors, we're exiting at this point anyway
+        writer.set_color(ColorSpec::new().set_fg(Some(Color::Red))).unwrap();
+        writeln!(&mut writer, "error: aborting due to {error_count} previous errors").unwrap();
+        writer.reset().ok();
 
-            Err(ReportedError)
-        } else {
-            Ok(())
-        }
+        Err(ReportedError)
+    } else {
+        Ok(())
     }
 }

crates/noirc_evaluator/src/errors.rs

@@ -1,4 +1,4 @@
-use noirc_errors::{CustomDiagnostic as Diagnostic, DiagnosableError, Location};
+use noirc_errors::{CustomDiagnostic as Diagnostic, Location};
 use thiserror::Error;
 
 #[derive(Debug)]
@@ -64,11 +64,11 @@ impl RuntimeErrorKind {
     }
 }
 
-impl DiagnosableError for RuntimeError {
-    fn to_diagnostic(&self) -> Diagnostic {
+impl From<RuntimeError> for Diagnostic {
+    fn from(error: RuntimeError) -> Diagnostic {
         let span =
-            if let Some(loc) = self.location { loc.span } else { noirc_errors::Span::new(0..0) };
-        match &self.kind {
+            if let Some(loc) = error.location { loc.span } else { noirc_errors::Span::new(0..0) };
+        match &error.kind {
             RuntimeErrorKind::ArrayOutOfBounds { index, bound } => Diagnostic::simple_error(
                 "index out of bounds".to_string(),
                 format!("out of bounds error, index is {index} but length is {bound}"),

crates/noirc_frontend/src/ast/expression.rs

@@ -26,6 +26,8 @@ pub enum ExpressionKind {
     Error,
 }
 
+pub type UnresolvedGenerics = Vec<Ident>;
+
 impl ExpressionKind {
     pub fn into_path(self) -> Option<Path> {
         match self {
@@ -306,7 +308,7 @@ pub struct Lambda {
 pub struct FunctionDefinition {
     pub name: Ident,
     pub attribute: Option<Attribute>, // XXX: Currently we only have one attribute defined. If more attributes are needed per function, we can make this a vector and make attribute definition more expressive
-    pub generics: Vec<Ident>,
+    pub generics: UnresolvedGenerics,
     pub parameters: Vec<(Pattern, UnresolvedType, noirc_abi::AbiVisibility)>,
     pub body: BlockExpression,
     pub span: Span,

crates/noirc_frontend/src/ast/mod.rs

@@ -18,7 +18,7 @@ use iter_extended::vecmap;
 /// The parser parses types as 'UnresolvedType's which
 /// require name resolution to resolve any type names used
 /// for structs within, but are otherwise identical to Types.
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum UnresolvedType {
     FieldElement(CompTime),
     Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>), // [4]Witness = Array(4, Witness)
@@ -43,7 +43,7 @@ pub enum UnresolvedType {
 /// The precursor to TypeExpression, this is the type that the parser allows
 /// to be used in the length position of an array type. Only constants, variables,
 /// and numeric binary operators are allowed here.
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum UnresolvedTypeExpression {
     Variable(Path),
     Constant(u64, Span),

crates/noirc_frontend/src/ast/structure.rs

@@ -1,6 +1,7 @@
 use std::fmt::Display;
 
-use crate::{Ident, NoirFunction, Path, UnresolvedType};
+use crate::{Ident, NoirFunction, UnresolvedGenerics, UnresolvedType};
+use iter_extended::vecmap;
 use noirc_errors::Span;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -24,13 +25,18 @@ impl NoirStruct {
 
 #[derive(Clone, Debug)]
 pub struct NoirImpl {
-    pub type_path: Path,
+    pub object_type: UnresolvedType,
+    pub type_span: Span,
+    pub generics: UnresolvedGenerics,
     pub methods: Vec<NoirFunction>,
 }
 
 impl Display for NoirStruct {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "struct {} {{", self.name)?;
+        let generics = vecmap(&self.generics, |generic| generic.to_string());
+        let generics = if generics.is_empty() { "".into() } else { generics.join(", ") };
+
+        writeln!(f, "struct {}{} {{", self.name, generics)?;
 
         for (name, typ) in self.fields.iter() {
             writeln!(f, "    {name}: {typ},")?;
@@ -42,7 +48,10 @@ impl Display for NoirStruct {
 
 impl Display for NoirImpl {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "impl {} {{", self.type_path)?;
+        let generics = vecmap(&self.generics, |generic| generic.to_string());
+        let generics = if generics.is_empty() { "".into() } else { generics.join(", ") };
+
+        writeln!(f, "impl{} {} {{", generics, self.object_type)?;
 
         for method in self.methods.iter() {
             let method = method.to_string();