feat: merge and sort imports (#6322)

# Description

## Problem

Manually arranging imports is time consuming.

## Summary

Added two new configurations, `reorder_imports` (true by default) and
`imports_granularity` (`Preserve` by default), similar to the ones found
in rustfmt. With the default configuration imports are reorganized
alphabetically but not merged.

While implementing this I bumped into one code in the test programs like
this:

```noir
use foo;
use foo::bar;
```

Merging those in Rust ends up like this:

```noir
use foo::{bar, self};
```

We don't have `self` in imports, so I had two choices:
1. Try to leave the above unmodified.
2. Implement `self` in imports.

It turned out that implement `self` in imports is very easy: when we
desugar imports, if the last segment is "self" we just remove it. Then
`use foo::self` is desugared into `use foo`.

## Additional Context

None.

## Documentation

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <[email protected]>

Author: asterite

compiler/noirc_frontend/src/ast/statement.rs

@@ -373,7 +373,9 @@ impl UseTree {
 
         match self.kind {
             UseTreeKind::Path(name, alias) => {
-                vec![ImportStatement { visibility, path: prefix.join(name), alias }]
+                // Desugar `use foo::{self}` to `use foo`
+                let path = if name.0.contents == "self" { prefix } else { prefix.join(name) };
+                vec![ImportStatement { visibility, path, alias }]
             }
             UseTreeKind::List(trees) => {
                 let trees = trees.into_iter();

compiler/noirc_frontend/src/parser/parser/use_tree.rs

@@ -66,6 +66,14 @@ impl<'a> Parser<'a> {
     fn parse_use_tree_in_list(&mut self) -> Option<UseTree> {
         let start_span = self.current_token_span;
 
+        // Special case: "self" cannot be followed by anything else
+        if self.eat_self() {
+            return Some(UseTree {
+                prefix: Path { segments: Vec::new(), kind: PathKind::Plain, span: start_span },
+                kind: UseTreeKind::Path(Ident::new("self".to_string(), start_span), None),
+            });
+        }
+
         let use_tree = self.parse_use_tree_without_kind(
             start_span,
             PathKind::Plain,
@@ -250,4 +258,11 @@ mod tests {
         let (_, errors) = parse_program(src);
         assert!(!errors.is_empty());
     }
+
+    #[test]
+    fn errors_on_double_colon_after_self() {
+        let src = "use foo::{self::bar};";
+        let (_, errors) = parse_program(src);
+        assert!(!errors.is_empty());
+    }
 }

compiler/noirc_frontend/src/tests.rs

@@ -3389,3 +3389,25 @@ fn arithmetic_generics_rounding_fail() {
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
 }
+
+#[test]
+fn uses_self_in_import() {
+    let src = r#"
+    mod moo {
+        pub mod bar {
+            pub fn foo() -> i32 {
+                1
+            }
+        }
+    }
+
+    use moo::bar::{self};
+
+    pub fn baz() -> i32 {
+        bar::foo()
+    }
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}

noir_stdlib/src/array/check_shuffle.nr

@@ -59,8 +59,8 @@ where
 }
 
 mod test {
-    use super::check_shuffle;
     use crate::cmp::Eq;
+    use super::check_shuffle;
 
     struct CompoundStruct {
         a: bool,

noir_stdlib/src/bigint.nr

@@ -1,5 +1,5 @@
-use crate::ops::{Add, Sub, Mul, Div};
 use crate::cmp::Eq;
+use crate::ops::{Add, Div, Mul, Sub};
 
 global bn254_fq = &[
     0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,

noir_stdlib/src/cmp.nr

@@ -537,7 +537,7 @@ where
 }
 
 mod cmp_tests {
-    use crate::cmp::{min, max};
+    use crate::cmp::{max, min};
 
     #[test]
     fn sanity_check_min() {

noir_stdlib/src/collections/map.nr

@@ -1,8 +1,8 @@
 use crate::cmp::Eq;
-use crate::option::Option;
-use crate::default::Default;
-use crate::hash::{Hash, Hasher, BuildHasher};
 use crate::collections::bounded_vec::BoundedVec;
+use crate::default::Default;
+use crate::hash::{BuildHasher, Hash, Hasher};
+use crate::option::Option;
 
 // We use load factor alpha_max = 0.75.
 // Upon exceeding it, assert will fail in order to inform the user

noir_stdlib/src/collections/umap.nr

@@ -1,7 +1,7 @@
 use crate::cmp::Eq;
-use crate::option::Option;
 use crate::default::Default;
-use crate::hash::{Hash, Hasher, BuildHasher};
+use crate::hash::{BuildHasher, Hash, Hasher};
+use crate::option::Option;
 
 // An unconstrained hash table with open addressing and quadratic probing.
 // Note that "unconstrained" here means that almost all operations on this

noir_stdlib/src/ec/consts/te.nr

@@ -1,5 +1,5 @@
-use crate::ec::tecurve::affine::Point as TEPoint;
 use crate::ec::tecurve::affine::Curve as TECurve;
+use crate::ec::tecurve::affine::Point as TEPoint;
 
 pub struct BabyJubjub {
     pub curve: TECurve,

noir_stdlib/src/ec/montcurve.nr

@@ -3,16 +3,16 @@ pub mod affine {
     // Points are represented by two-dimensional Cartesian coordinates.
     // All group operations are induced by those of the corresponding Twisted Edwards curve.
     // See e.g. <https://eprint.iacr.org/2017/212.pdf> for details on the correspondences.
+    use crate::cmp::Eq;
+    use crate::ec::is_square;
     use crate::ec::montcurve::curvegroup;
+    use crate::ec::safe_inverse;
+    use crate::ec::sqrt;
     use crate::ec::swcurve::affine::Curve as SWCurve;
     use crate::ec::swcurve::affine::Point as SWPoint;
     use crate::ec::tecurve::affine::Curve as TECurve;
     use crate::ec::tecurve::affine::Point as TEPoint;
-    use crate::ec::is_square;
-    use crate::ec::safe_inverse;
-    use crate::ec::sqrt;
     use crate::ec::ZETA;
-    use crate::cmp::Eq;
 
     // Curve specification
     pub struct Curve { // Montgomery Curve configuration (ky^2 = x^3 + j*x^2 + x)
@@ -222,12 +222,12 @@ pub mod curvegroup {
     // Points are represented by three-dimensional projective (homogeneous) coordinates.
     // All group operations are induced by those of the corresponding Twisted Edwards curve.
     // See e.g. <https://eprint.iacr.org/2017/212.pdf> for details on the correspondences.
+    use crate::cmp::Eq;
     use crate::ec::montcurve::affine;
     use crate::ec::swcurve::curvegroup::Curve as SWCurve;
     use crate::ec::swcurve::curvegroup::Point as SWPoint;
     use crate::ec::tecurve::curvegroup::Curve as TECurve;
     use crate::ec::tecurve::curvegroup::Point as TEPoint;
-    use crate::cmp::Eq;
 
     pub struct Curve { // Montgomery Curve configuration (ky^2 z = x*(x^2 + j*x*z + z*z))
         pub j: Field,