feat: swap endianness in-place in keccak implementation (noir-lang/no…

…ir#6128)

feat: (LSP) remove unused imports (noir-lang/noir#6129)
fix: handle parenthesized expressions in array length (noir-lang/noir#6132)
chore: remove bubble_up_constrains (noir-lang/noir#6127)
fix: Consider constants as used values to keep their rc ops (noir-lang/noir#6122)

.noir-sync-commit

@@ -1 +1 @@
-9f0b3971ee41e78241cbea4e3f81bac4edd5897d
+e3cdebe515e4dc4ee6e16e01bd8af25135939798

noir/noir-repo/compiler/noirc_frontend/src/ast/statement.rs

@@ -330,9 +330,13 @@ impl Display for UseTree {
 
         match &self.kind {
             UseTreeKind::Path(name, alias) => {
+                if !(self.prefix.segments.is_empty() && self.prefix.kind == PathKind::Plain) {
+                    write!(f, "::")?;
+                }
+
                 write!(f, "{name}")?;
 
-                while let Some(alias) = alias {
+                if let Some(alias) = alias {
                     write!(f, " as {alias}")?;
                 }
 

noir/noir-repo/compiler/noirc_frontend/src/ast/visitor.rs

@@ -271,7 +271,7 @@ pub trait Visitor {
         true
     }
 
-    fn visit_import(&mut self, _: &UseTree, _visibility: ItemVisibility) -> bool {
+    fn visit_import(&mut self, _: &UseTree, _: Span, _visibility: ItemVisibility) -> bool {
         true
     }
 
@@ -506,7 +506,7 @@ impl Item {
             }
             ItemKind::Trait(noir_trait) => noir_trait.accept(self.span, visitor),
             ItemKind::Import(use_tree, visibility) => {
-                if visitor.visit_import(use_tree, *visibility) {
+                if visitor.visit_import(use_tree, self.span, *visibility) {
                     use_tree.accept(visitor);
                 }
             }

noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs

@@ -499,7 +499,7 @@ impl DefCollector {
         crate_id: CrateId,
         errors: &mut Vec<(CompilationError, FileId)>,
     ) {
-        let unused_imports = context.def_interner.usage_tracker.unused_items().iter();
+        let unused_imports = context.def_interner.unused_items().iter();
         let unused_imports = unused_imports.filter(|(module_id, _)| module_id.krate == crate_id);
 
         errors.extend(unused_imports.flat_map(|(module_id, usage_tracker)| {

noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs

@@ -28,6 +28,7 @@ use crate::hir::type_check::generics::TraitGenerics;
 use crate::hir_def::traits::NamedType;
 use crate::macros_api::ModuleDefId;
 use crate::macros_api::UnaryOp;
+use crate::usage_tracker::UnusedItem;
 use crate::usage_tracker::UsageTracker;
 use crate::QuotedType;
 
@@ -2249,6 +2250,12 @@ impl NodeInterner {
     pub fn doc_comments(&self, id: ReferenceId) -> Option<&Vec<String>> {
         self.doc_comments.get(&id)
     }
+
+    pub fn unused_items(
+        &self,
+    ) -> &std::collections::HashMap<ModuleId, std::collections::HashMap<Ident, UnusedItem>> {
+        self.usage_tracker.unused_items()
+    }
 }
 
 impl Methods {

noir/noir-repo/noir_stdlib/src/hash/keccak.nr

@@ -35,40 +35,27 @@ pub(crate) fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 3
     block_bytes[message_size] = 1;
     block_bytes[real_blocks_bytes - 1] = 0x80;
 
-    // keccak lanes interpret memory as little-endian integers,
-    // means we need to swap our byte ordering
     let num_limbs = max_blocks * LIMBS_PER_BLOCK; //max_blocks_length / WORD_SIZE;
-    for i in 0..num_limbs {
-        let mut temp = [0; WORD_SIZE];
-        let word_size_times_i = WORD_SIZE * i;
-        for j in 0..WORD_SIZE {
-            temp[j] = block_bytes[word_size_times_i+j];
-        }
-        for j in 0..WORD_SIZE {
-            block_bytes[word_size_times_i + j] = temp[7 - j];
-        }
-    }
-
     let mut sliced_buffer = Vec::new();
     // populate a vector of 64-bit limbs from our byte array
     for i in 0..num_limbs {
-        let word_size_times_i = i * WORD_SIZE;
-        let ws_times_i_plus_7 = word_size_times_i + 7;
+        let limb_start = WORD_SIZE * i;
+
         let mut sliced = 0;
-        if (word_size_times_i + WORD_SIZE > max_blocks_length) {
-            let slice_size = max_blocks_length - word_size_times_i;
+        if (limb_start + WORD_SIZE > max_blocks_length) {
+            let slice_size = max_blocks_length - limb_start;
             let byte_shift = (WORD_SIZE - slice_size) * 8;
             let mut v = 1;
             for k in 0..slice_size {
-                sliced += v * (block_bytes[ws_times_i_plus_7-k] as Field);
+                sliced += v * (block_bytes[limb_start+k] as Field);
                 v *= 256;
             }
             let w = 1 << (byte_shift as u8);
             sliced *= w as Field;
         } else {
             let mut v = 1;
             for k in 0..WORD_SIZE {
-                sliced += v * (block_bytes[ws_times_i_plus_7-k] as Field);
+                sliced += v * (block_bytes[limb_start+k] as Field);
                 v *= 256;
             }
         }
@@ -156,4 +143,3 @@ mod tests {
         assert_eq(keccak256(input, 13), result);
     }
 }
-

noir/noir-repo/tooling/lsp/src/requests/code_action.rs

@@ -1,6 +1,7 @@
 use std::{
     collections::{BTreeMap, HashMap},
     future::{self, Future},
+    ops::Range,
 };
 
 use async_lsp::ResponseError;
@@ -11,7 +12,7 @@ use lsp_types::{
 };
 use noirc_errors::Span;
 use noirc_frontend::{
-    ast::{ConstructorExpression, NoirTraitImpl, Path, Visitor},
+    ast::{ConstructorExpression, ItemVisibility, NoirTraitImpl, Path, UseTree, Visitor},
     graph::CrateId,
     hir::def_map::{CrateDefMap, LocalModuleId, ModuleId},
     macros_api::NodeInterner,
@@ -28,7 +29,7 @@ use super::{process_request, to_lsp_location};
 mod fill_struct_fields;
 mod implement_missing_members;
 mod import_or_qualify;
-#[cfg(test)]
+mod remove_unused_import;
 mod tests;
 
 pub(crate) fn on_code_action_request(
@@ -43,7 +44,7 @@ pub(crate) fn on_code_action_request(
     let result = process_request(state, text_document_position_params, |args| {
         let path = PathString::from_path(uri.to_file_path().unwrap());
         args.files.get_file_id(&path).and_then(|file_id| {
-            utils::position_to_byte_index(args.files, file_id, &position).and_then(|byte_index| {
+            utils::range_to_byte_span(args.files, file_id, &params.range).and_then(|byte_range| {
                 let file = args.files.get_file(file_id).unwrap();
                 let source = file.source();
                 let (parsed_module, _errors) = noirc_frontend::parse_program(source);
@@ -53,7 +54,7 @@ pub(crate) fn on_code_action_request(
                     args.files,
                     file_id,
                     source,
-                    byte_index,
+                    byte_range,
                     args.crate_id,
                     args.def_maps,
                     args.interner,
@@ -71,7 +72,7 @@ struct CodeActionFinder<'a> {
     file: FileId,
     source: &'a str,
     lines: Vec<&'a str>,
-    byte_index: usize,
+    byte_range: Range<usize>,
     /// The module ID in scope. This might change as we traverse the AST
     /// if we are analyzing something inside an inline module declaration.
     module_id: ModuleId,
@@ -81,7 +82,9 @@ struct CodeActionFinder<'a> {
     nesting: usize,
     /// The line where an auto_import must be inserted
     auto_import_line: usize,
-    code_actions: Vec<CodeActionOrCommand>,
+    /// Text edits for the "Remove all unused imports" code action
+    unused_imports_text_edits: Vec<TextEdit>,
+    code_actions: Vec<CodeAction>,
 }
 
 impl<'a> CodeActionFinder<'a> {
@@ -91,7 +94,7 @@ impl<'a> CodeActionFinder<'a> {
         files: &'a FileMap,
         file: FileId,
         source: &'a str,
-        byte_index: usize,
+        byte_range: Range<usize>,
         krate: CrateId,
         def_maps: &'a BTreeMap<CrateId, CrateDefMap>,
         interner: &'a NodeInterner,
@@ -112,12 +115,13 @@ impl<'a> CodeActionFinder<'a> {
             file,
             source,
             lines: source.lines().collect(),
-            byte_index,
+            byte_range,
             module_id,
             def_maps,
             interner,
             nesting: 0,
             auto_import_line: 0,
+            unused_imports_text_edits: vec![],
             code_actions: vec![],
         }
     }
@@ -129,28 +133,38 @@ impl<'a> CodeActionFinder<'a> {
             return None;
         }
 
+        // We also suggest a single "Remove all the unused imports" code action that combines all of the
+        // "Remove unused imports" (similar to Rust Analyzer)
+        if self.unused_imports_text_edits.len() > 1 {
+            let text_edits = std::mem::take(&mut self.unused_imports_text_edits);
+            let code_action = self.new_quick_fix_multiple_edits(
+                "Remove all the unused imports".to_string(),
+                text_edits,
+            );
+            self.code_actions.push(code_action);
+        }
+
         let mut code_actions = std::mem::take(&mut self.code_actions);
-        code_actions.sort_by_key(|code_action| {
-            let CodeActionOrCommand::CodeAction(code_action) = code_action else {
-                panic!("We only gather code actions, never commands");
-            };
-            code_action.title.clone()
-        });
-
-        Some(code_actions)
+        code_actions.sort_by_key(|code_action| code_action.title.clone());
+
+        Some(code_actions.into_iter().map(CodeActionOrCommand::CodeAction).collect())
     }
 
-    fn new_quick_fix(&self, title: String, text_edit: TextEdit) -> CodeActionOrCommand {
+    fn new_quick_fix(&self, title: String, text_edit: TextEdit) -> CodeAction {
+        self.new_quick_fix_multiple_edits(title, vec![text_edit])
+    }
+
+    fn new_quick_fix_multiple_edits(&self, title: String, text_edits: Vec<TextEdit>) -> CodeAction {
         let mut changes = HashMap::new();
-        changes.insert(self.uri.clone(), vec![text_edit]);
+        changes.insert(self.uri.clone(), text_edits);
 
         let workspace_edit = WorkspaceEdit {
             changes: Some(changes),
             document_changes: None,
             change_annotations: None,
         };
 
-        CodeActionOrCommand::CodeAction(CodeAction {
+        CodeAction {
             title,
             kind: Some(CodeActionKind::QUICKFIX),
             diagnostics: None,
@@ -159,11 +173,12 @@ impl<'a> CodeActionFinder<'a> {
             is_preferred: None,
             disabled: None,
             data: None,
-        })
+        }
     }
 
     fn includes_span(&self, span: Span) -> bool {
-        span.start() as usize <= self.byte_index && self.byte_index <= span.end() as usize
+        let byte_range_span = Span::from(self.byte_range.start as u32..self.byte_range.end as u32);
+        span.intersects(&byte_range_span)
     }
 }
 
@@ -207,6 +222,12 @@ impl<'a> Visitor for CodeActionFinder<'a> {
         false
     }
 
+    fn visit_import(&mut self, use_tree: &UseTree, span: Span, visibility: ItemVisibility) -> bool {
+        self.remove_unused_import(use_tree, visibility, span);
+
+        true
+    }
+
     fn visit_path(&mut self, path: &Path) {
         self.import_or_qualify(path);
     }