fix: disable next ast item

crates/lint/src/inline_config.rs

@@ -1,5 +1,6 @@
-use solar_parse::{ast::Span, lexer::token::RawTokenKind};
-use std::{collections::HashMap, fmt, str::FromStr};
+use solar_ast::{visit::Visit, Item, SourceUnit};
+use solar_parse::ast::Span;
+use std::{collections::HashMap, fmt, marker::PhantomData, ops::ControlFlow, str::FromStr};
 
 /// An inline config item
 #[derive(Clone, Debug)]
@@ -80,14 +81,16 @@ impl InlineConfig {
     /// # Panics
     ///
     /// Panics if `items` is not sorted in ascending order of [`Span`]s.
-    pub fn new(
+    pub fn new<'ast>(
         items: impl IntoIterator<Item = (Span, InlineConfigItem)>,
         lints: &[&'static str],
+        ast: &'ast SourceUnit<'ast>,
         src: &str,
     ) -> (Self, Vec<(Vec<String>, Span)>) {
         let mut invalid_ids: Vec<(Vec<String>, Span)> = Vec::new();
         let mut disabled_ranges: HashMap<String, Vec<DisabledRange>> = HashMap::new();
         let mut disabled_blocks: HashMap<String, (usize, usize)> = HashMap::new();
+
         let mut prev_sp = Span::DUMMY;
         for (sp, item) in items {
             if cfg!(debug_assertions) {
@@ -96,37 +99,23 @@ impl InlineConfig {
             }
 
             match item {
-                // TODO: figure out why it doesn't work.
-                InlineConfigItem::DisableNextItem(ids) => {
-                    let lints = match validate_ids(&mut invalid_ids, lints, ids, sp) {
+                InlineConfigItem::DisableNextItem(lint) => {
+                    let lints = match validate_ids(&mut invalid_ids, lints, lint, sp) {
                         Some(lints) => lints,
                         None => continue,
                     };
 
-                    use RawTokenKind::*;
-                    let offset = sp.hi().to_usize();
-                    let mut idx = offset;
-                    let mut tokens = solar_parse::Cursor::new(&src[offset..])
-                        .map(|token| {
-                            let start = idx;
-                            idx += token.len as usize;
-                            (start, token)
-                        })
-                        .filter(|(_, t)| {
-                            !matches!(t.kind, LineComment { .. } | BlockComment { .. })
-                        })
-                        .skip_while(|(_, t)| matches!(t.kind, Whitespace));
-                    if let Some((mut start, _)) = tokens.next() {
-                        start += offset;
-                        let end = tokens
-                            .find(|(_, t)| !matches!(t.kind, Whitespace))
-                            .map(|(idx, _)| idx)
-                            .unwrap_or(src.len());
-                        let range = DisabledRange { start, end, loose: true };
+                    let comment_end = sp.hi().to_usize();
+
+                    if let Some(next_item) = NextItemFinder::new(comment_end).find(&ast) {
                         for lint in lints {
-                            disabled_ranges.entry(lint).or_default().push(range)
+                            disabled_ranges.entry(lint).or_default().push(DisabledRange {
+                                start: next_item.lo().to_usize(),
+                                end: next_item.hi().to_usize(),
+                                loose: false,
+                            });
                         }
-                    }
+                    };
                 }
                 InlineConfigItem::DisableLine(lint) => {
                     let lints = match validate_ids(&mut invalid_ids, lints, lint, sp) {
@@ -145,9 +134,12 @@ impl InlineConfig {
                         src[end_offset..].char_indices().skip_while(|(_, ch)| *ch != '\n');
                     let end =
                         end_offset + next_newline.next().map(|(idx, _)| idx).unwrap_or_default();
-                    let range = DisabledRange { start, end, loose: false };
                     for lint in lints {
-                        disabled_ranges.entry(lint).or_default().push(range)
+                        disabled_ranges.entry(lint).or_default().push(DisabledRange {
+                            start,
+                            end,
+                            loose: false,
+                        })
                     }
                 }
                 InlineConfigItem::DisableNextLine(ids) => {
@@ -165,9 +157,12 @@ impl InlineConfig {
                             .find(|(_, ch)| *ch == '\n')
                             .map(|(idx, _)| offset + idx + 1)
                             .unwrap_or(src.len());
-                        let range = DisabledRange { start, end, loose: false };
                         for lint in lints {
-                            disabled_ranges.entry(lint).or_default().push(range)
+                            disabled_ranges.entry(lint).or_default().push(DisabledRange {
+                                start,
+                                end,
+                                loose: false,
+                            })
                         }
                     }
                 }
@@ -208,8 +203,11 @@ impl InlineConfig {
         }
 
         for (lint, (start, _)) in disabled_blocks {
-            let range = DisabledRange { start, end: src.len(), loose: false };
-            disabled_ranges.entry(lint).or_default().push(range);
+            disabled_ranges.entry(lint).or_default().push(DisabledRange {
+                start,
+                end: src.len(),
+                loose: false,
+            });
         }
 
         (Self { disabled_ranges }, invalid_ids)
@@ -258,3 +256,45 @@ fn validate_ids(
         None
     }
 }
+
+/// An AST visitor that finds the first `Item` that starts after a given offset.
+#[derive(Debug, Default)]
+struct NextItemFinder<'ast> {
+    /// The offset to search after.
+    offset: usize,
+    /// The span of the found item, if any.
+    found_span: Option<Span>,
+    _pd: PhantomData<&'ast ()>,
+}
+
+impl<'ast> NextItemFinder<'ast> {
+    fn new(offset: usize) -> Self {
+        Self { offset, found_span: None, _pd: PhantomData }
+    }
+
+    /// Finds the next AST item which a span that begins after the `threashold`.
+    fn find(&mut self, ast: &'ast SourceUnit<'ast>) -> Option<Span> {
+        for item in ast.items.iter() {
+            if let ControlFlow::Break(()) = self.visit_item(item) {
+                break;
+            }
+        }
+
+        self.found_span
+    }
+}
+
+impl<'ast> Visit<'ast> for NextItemFinder<'ast> {
+    type BreakValue = ();
+
+    fn visit_item(&mut self, item: &'ast Item<'ast>) -> ControlFlow<Self::BreakValue> {
+        // Check if this item starts after the offset.
+        if item.span.lo().to_usize() > self.offset {
+            self.found_span = Some(item.span);
+            return ControlFlow::Break(());
+        }
+
+        // Otherwise, continue traversing inside this item.
+        self.walk_item(item)
+    }
+}

crates/lint/src/sol/mod.rs

@@ -6,7 +6,7 @@ use crate::{
 use foundry_compilers::{solc::SolcLanguage, ProjectPathsConfig};
 use foundry_config::lint::Severity;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use solar_ast::{visit::Visit, Arena};
+use solar_ast::{visit::Visit, Arena, SourceUnit};
 use solar_interface::{
     diagnostics::{self, DiagCtxt, JsonEmitter},
     Session, SourceMap,
@@ -77,6 +77,14 @@ impl SolidityLinter {
         let arena = Arena::new();
 
         let _ = sess.enter(|| -> Result<(), diagnostics::ErrorGuaranteed> {
+            // Initialize the parser, get the AST, and process the inline-config
+            let mut parser = solar_parse::Parser::from_file(sess, &arena, path)?;
+            let file = sess
+                .source_map()
+                .load_file(path)
+                .map_err(|e| sess.dcx.err(e.to_string()).emit())?;
+            let ast = parser.parse_file().map_err(|e| e.emit())?;
+
             // Declare all available passes and lints
             let mut passes_and_lints = Vec::new();
             passes_and_lints.extend(high::create_lint_passes());
@@ -117,16 +125,10 @@ impl SolidityLinter {
                 })
                 .collect();
 
-            // Initialize the parser, get the AST, and process the inline-config
-            let mut parser = solar_parse::Parser::from_file(sess, &arena, path)?;
-            let file = sess
-                .source_map()
-                .load_file(path)
-                .map_err(|e| sess.dcx.err(e.to_string()).emit())?;
+            // Process the inline-config
             let source = file.src.as_str();
             let comments = Comments::new(&file);
-            let ast = parser.parse_file().map_err(|e| e.emit())?;
-            let inline_config = parse_inline_config(sess, &comments, &lints, source);
+            let inline_config = parse_inline_config(sess, &comments, &lints, &ast, source);
 
             // Initialize and run the visitor
             let ctx = LintContext::new(sess, self.with_description, inline_config);
@@ -170,10 +172,11 @@ impl Linter for SolidityLinter {
     }
 }
 
-fn parse_inline_config(
+fn parse_inline_config<'ast>(
     sess: &Session,
     comments: &Comments,
     lints: &[&'static str],
+    ast: &'ast SourceUnit<'ast>,
     src: &str,
 ) -> InlineConfig {
     let items = comments.iter().filter_map(|comment| {
@@ -184,7 +187,7 @@ fn parse_inline_config(
         if let Some(suffix) = comment.suffix() {
             item = item.strip_suffix(suffix).unwrap_or(item);
         }
-        let item = item.trim_start().strip_prefix("forgelint:")?.trim();
+        let item = item.trim_start().strip_prefix("forge-lint:")?.trim();
         let span = comment.span;
         match item.parse::<InlineConfigItem>() {
             Ok(item) => Some((span, item)),
@@ -195,7 +198,7 @@ fn parse_inline_config(
         }
     });
 
-    let (inline_config, invalid_lints) = InlineConfig::new(items, lints, src);
+    let (inline_config, invalid_lints) = InlineConfig::new(items, lints, &ast, src);
 
     for (ids, span) in &invalid_lints {
         let msg = format!("unknown lint id: '{}'", ids.join("', '"));

crates/lint/testdata/Keccak256.sol

@@ -5,24 +5,24 @@ contract AsmKeccak256 {
     bytes32 constant OTHER_HASH = keccak256(1234);
 
     constructor(uint256 a, uint256 b) {
-        // forgelint: disable-next-line(asm-keccak256)
+        // forge-lint: disable-next-line(asm-keccak256)
         keccak256(abi.encodePacked(a, b));
 
-        keccak256(abi.encodePacked(a, b)); // forgelint: disable-line(asm-keccak256)
+        keccak256(abi.encodePacked(a, b)); // forge-lint: disable-line(asm-keccak256)
 
-        // forgelint: disable-start(asm-keccak256) ------
+        // forge-lint: disable-start(asm-keccak256) ------
         keccak256(abi.encodePacked(a, b)); //           |
                                            //           |
-        // forgelint: disable-start(asm-keccak256) ---  |
+        // forge-lint: disable-start(asm-keccak256) ---  |
         keccak256(abi.encodePacked(a, b)); //         | |
                                            //         | |
-        // forgelint: disable-end(asm-keccak256) -----  |
-        // forgelint: disable-end(asm-keccak256) --------
+        // forge-lint: disable-end(asm-keccak256) -----  |
+        // forge-lint: disable-end(asm-keccak256) --------
 
         keccak256(abi.encodePacked(a, b));
     }
 
-    // forgelint: disable-next-item(asm-keccak256)
+    // forge-lint: disable-next-item(asm-keccak256)
     function solidityHashDisabled(uint256 a, uint256 b) public view returns (bytes32) {
         bytes32 hash = keccak256(a);
         return keccak256(abi.encodePacked(a, b));
@@ -42,3 +42,20 @@ contract AsmKeccak256 {
         }
     }
 }
+
+// forge-lint: disable-next-item(asm-keccak256)
+contract OtherAsmKeccak256 {
+    function contratDisabledHash(uint256 a, uint256 b) public view returns (bytes32) {
+        return keccak256(abi.encodePacked(a, b));
+    }
+
+    function contratDisabledHash2(uint256 a, uint256 b) public view returns (bytes32) {
+        return keccak256(abi.encodePacked(a, b));
+    }
+}
+
+contract YetAnotherAsmKeccak256 {
+    function nonDisabledHash(uint256 a, uint256 b) public view returns (bytes32) {
+        return keccak256(abi.encodePacked(a, b)); //~NOTE: hash using inline assembly to save gas
+    }
+}

crates/lint/testdata/Keccak256.stderr

@@ -21,3 +21,12 @@ note[asm-keccak256]: hash using inline assembly to save gas
    |                ---------
    |
    = help: https://book.getfoundry.sh/reference/forge/forge-lint#asm-keccak256
+
+note[asm-keccak256]: hash using inline assembly to save gas
+  --> ROOT/testdata/Keccak256.sol:LL:CC
+   |
+59 |         return keccak256(abi.encodePacked(a, b));
+   |                ---------
+   |
+   = help: https://book.getfoundry.sh/reference/forge/forge-lint#asm-keccak256
+