Migrate workspace to Rust 2024 edition

Cargo.toml

@@ -2,7 +2,7 @@
 name = "adblock"
 version = "0.12.4"
 authors = ["Anton Lazarev <alazarev@brave.com>", "Andrius Aucinas"]
-edition = "2021"
+edition = "2024"
 
 description = "Native Rust module for Adblock Plus syntax (e.g. EasyList, EasyPrivacy) filter parsing and matching."
 repository = "https://github.com/brave/adblock-rust/"

benches/bench_memory.rs

@@ -8,9 +8,9 @@ use serde::{Deserialize, Serialize};
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::sync::atomic::{AtomicUsize, Ordering};
 
+use adblock::Engine;
 use adblock::request::Request;
 use adblock::resources::Resource;
-use adblock::Engine;
 
 #[path = "../tests/test_utils.rs"]
 mod test_utils;
@@ -73,39 +73,47 @@ impl MemoryTracker {
 
 unsafe impl GlobalAlloc for MemoryTracker {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        let ret = self.internal.alloc(layout);
-        if !ret.is_null() {
-            self.allocations_count.fetch_add(1, Ordering::SeqCst);
-            self.allocated.fetch_add(layout.size(), Ordering::SeqCst);
-            self.update_max_allocated(self.current_usage());
+        unsafe {
+            let ret = self.internal.alloc(layout);
+            if !ret.is_null() {
+                self.allocations_count.fetch_add(1, Ordering::SeqCst);
+                self.allocated.fetch_add(layout.size(), Ordering::SeqCst);
+                self.update_max_allocated(self.current_usage());
+            }
+            ret
         }
-        ret
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        self.internal.dealloc(ptr, layout);
-        self.allocated.fetch_sub(layout.size(), Ordering::SeqCst);
+        unsafe {
+            self.internal.dealloc(ptr, layout);
+            self.allocated.fetch_sub(layout.size(), Ordering::SeqCst);
+        }
     }
 
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        let ret = self.internal.realloc(ptr, layout, new_size);
-        if !ret.is_null() {
-            self.allocations_count.fetch_add(1, Ordering::SeqCst);
-            self.allocated.fetch_sub(layout.size(), Ordering::SeqCst);
-            self.allocated.fetch_add(new_size, Ordering::SeqCst);
-            self.update_max_allocated(self.current_usage());
+        unsafe {
+            let ret = self.internal.realloc(ptr, layout, new_size);
+            if !ret.is_null() {
+                self.allocations_count.fetch_add(1, Ordering::SeqCst);
+                self.allocated.fetch_sub(layout.size(), Ordering::SeqCst);
+                self.allocated.fetch_add(new_size, Ordering::SeqCst);
+                self.update_max_allocated(self.current_usage());
+            }
+            ret
         }
-        ret
     }
 
     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        let ret = self.internal.alloc_zeroed(layout);
-        if !ret.is_null() {
-            self.allocations_count.fetch_add(1, Ordering::SeqCst);
-            self.allocated.fetch_add(layout.size(), Ordering::SeqCst);
-            self.update_max_allocated(self.current_usage());
+        unsafe {
+            let ret = self.internal.alloc_zeroed(layout);
+            if !ret.is_null() {
+                self.allocations_count.fetch_add(1, Ordering::SeqCst);
+                self.allocated.fetch_add(layout.size(), Ordering::SeqCst);
+                self.update_max_allocated(self.current_usage());
+            }
+            ret
         }
-        ret
     }
 }
 

benches/bench_redirect_performance.rs

@@ -6,8 +6,7 @@ use adblock::filters::network::{NetworkFilter, NetworkFilterMask, NetworkFilterM
 use adblock::request::Request;
 use adblock::resources::Resource;
 
-const DEFAULT_LISTS_URL: &str =
-    "https://raw.githubusercontent.com/brave/adblock-resources/master/filter_lists/list_catalog.json";
+const DEFAULT_LISTS_URL: &str = "https://raw.githubusercontent.com/brave/adblock-resources/master/filter_lists/list_catalog.json";
 
 async fn get_all_filters() -> Vec<String> {
     use futures::FutureExt;

benches/bench_regex.rs

@@ -1,6 +1,6 @@
 use criterion::*;
 
-use regex::{bytes::Regex as BytesRegex, Regex, RegexSet};
+use regex::{Regex, RegexSet, bytes::Regex as BytesRegex};
 
 fn bench_simple_regexes(c: &mut Criterion) {
     let mut group = c.benchmark_group("regex");

examples/deserialization.rs

@@ -1,11 +1,11 @@
-use adblock::{request::Request, Engine};
+use adblock::{Engine, request::Request};
 
 use serde::Deserialize;
 
 use std::collections::HashMap;
 use std::fs::File;
-use std::io::prelude::*;
 use std::io::BufReader;
+use std::io::prelude::*;
 
 #[allow(non_snake_case)]
 #[derive(Debug, Deserialize)]

examples/example.rs

@@ -1,7 +1,7 @@
 use adblock::{
+    Engine,
     lists::{FilterSet, ParseOptions},
     request::Request,
-    Engine,
 };
 
 fn main() {

examples/generate-dat.rs

@@ -1,4 +1,4 @@
-use adblock::{request::Request, Engine};
+use adblock::{Engine, request::Request};
 
 use std::fs::File;
 use std::io::prelude::*;

examples/use-dat.rs

@@ -1,4 +1,4 @@
-use adblock::{request::Request, Engine};
+use adblock::{Engine, request::Request};
 
 use std::fs::File;
 use std::io::prelude::*;

fuzz/Cargo.toml

@@ -3,7 +3,7 @@ name = "adblock-fuzz"
 version = "0.0.0"
 authors = ["Automatically generated"]
 publish = false
-edition = "2021"
+edition = "2024"
 
 [package.metadata]
 cargo-fuzz = true

fuzz/fuzz_targets/parse_filter_hosts.rs

@@ -1,7 +1,7 @@
 #![no_main]
 #![allow(unused_must_use)] // workaround for "error: unused `Result` that must be used"
 
-use adblock::lists::{parse_filter, FilterFormat, ParseOptions};
+use adblock::lists::{FilterFormat, ParseOptions, parse_filter};
 use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|data: &[u8]| {

js/Cargo.toml

@@ -2,7 +2,7 @@
 name = "adblock-rs"
 version = "0.12.4"
 authors = ["Anton Lazarev <alazarev@brave.com>", "Andrius Aucinas"]
-edition = "2021"
+edition = "2024"
 license = "MPL-2.0"
 exclude = ["artifacts.json", "index.node"]
 

js/src/lib.rs

@@ -1,9 +1,9 @@
+use adblock::Engine as EngineInternal;
 use adblock::lists::{
     FilterFormat, FilterListMetadata, FilterSet as FilterSetInternal, ParseOptions, RuleTypes,
 };
-use adblock::resources::resource_assembler::assemble_web_accessible_resources;
 use adblock::resources::Resource;
-use adblock::Engine as EngineInternal;
+use adblock::resources::resource_assembler::assemble_web_accessible_resources;
 use neon::prelude::*;
 use neon::types::buffer::TypedArray as _;
 use serde::{Deserialize, Serialize};
@@ -74,7 +74,7 @@ impl FilterSet {
     ) -> Result<(), adblock::lists::FilterParseError> {
         self.0.borrow_mut().add_filter(filter, opts)
     }
-    fn into_content_blocking(
+    fn content_blocking_rules(
         &self,
     ) -> Result<(Vec<adblock::content_blocking::CbRule>, Vec<String>), ()> {
         self.0.borrow().clone().into_content_blocking()
@@ -139,15 +139,15 @@ struct ContentBlockingConversionResult {
 fn filter_set_into_content_blocking(mut cx: FunctionContext) -> JsResult<JsValue> {
     let this = cx.argument::<JsBox<FilterSet>>(0)?;
 
-    match this.into_content_blocking() {
+    match this.content_blocking_rules() {
         Ok((cb_rules, filters_used)) => {
             let r = ContentBlockingConversionResult {
                 content_blocking_rules: cb_rules,
                 filters_used,
             };
             json_ffi::to_js(&mut cx, &r)
         }
-        Err(_) => return Ok(JsUndefined::new(&mut cx).upcast()),
+        Err(_) => Ok(JsUndefined::new(&mut cx).upcast()),
     }
 }
 
@@ -200,10 +200,9 @@ fn engine_check(mut cx: FunctionContext) -> JsResult<JsValue> {
         Err(e) => cx.throw_error(e.to_string())?,
     };
 
-    let result = if let Ok(engine) = this.0.lock() {
-        engine.check_network_request(&request)
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    let result = match this.0.lock() {
+        Ok(engine) => engine.check_network_request(&request),
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
     if debug {
         json_ffi::to_js(&mut cx, &result)
@@ -224,10 +223,9 @@ fn engine_hidden_class_id_selectors(mut cx: FunctionContext) -> JsResult<JsValue
     let exceptions_arg = cx.argument::<JsValue>(3)?;
     let exceptions: std::collections::HashSet<String> = json_ffi::from_js(&mut cx, exceptions_arg)?;
 
-    let result = if let Ok(engine) = this.0.lock() {
-        engine.hidden_class_id_selectors(&classes, &ids, &exceptions)
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    let result = match this.0.lock() {
+        Ok(engine) => engine.hidden_class_id_selectors(&classes, &ids, &exceptions),
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
     json_ffi::to_js(&mut cx, &result)
 }
@@ -237,20 +235,18 @@ fn engine_url_cosmetic_resources(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let url: String = cx.argument::<JsString>(1)?.value(&mut cx);
 
-    let result = if let Ok(engine) = this.0.lock() {
-        engine.url_cosmetic_resources(&url)
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    let result = match this.0.lock() {
+        Ok(engine) => engine.url_cosmetic_resources(&url),
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
     json_ffi::to_js(&mut cx, &result)
 }
 
 fn engine_serialize(mut cx: FunctionContext) -> JsResult<JsArrayBuffer> {
     let this = cx.argument::<JsBox<Engine>>(0)?;
-    let serialized = if let Ok(engine) = this.0.lock() {
-        engine.serialize().to_vec()
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    let serialized = match this.0.lock() {
+        Ok(engine) => engine.serialize().to_vec(),
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
 
     // initialise new Array Buffer in the JS context
@@ -266,7 +262,7 @@ fn engine_deserialize(mut cx: FunctionContext) -> JsResult<JsNull> {
     let serialized_handle = cx.argument::<JsArrayBuffer>(1)?;
 
     if let Ok(mut engine) = this.0.lock() {
-        let _result = engine.deserialize(&serialized_handle.as_slice(&mut cx));
+        let _result = engine.deserialize(serialized_handle.as_slice(&cx));
     }
 
     Ok(JsNull::new(&mut cx))
@@ -277,10 +273,9 @@ fn engine_enable_tag(mut cx: FunctionContext) -> JsResult<JsNull> {
 
     let tag: String = cx.argument::<JsString>(1)?.value(&mut cx);
 
-    if let Ok(mut engine) = this.0.lock() {
-        engine.enable_tags(&[&tag])
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    match this.0.lock() {
+        Ok(mut engine) => engine.enable_tags(&[&tag]),
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
     Ok(JsNull::new(&mut cx))
 }
@@ -291,10 +286,9 @@ fn engine_use_resources(mut cx: FunctionContext) -> JsResult<JsNull> {
     let resources_arg = cx.argument::<JsValue>(1)?;
     let resources: Vec<Resource> = json_ffi::from_js(&mut cx, resources_arg)?;
 
-    if let Ok(mut engine) = this.0.lock() {
-        engine.use_resources(resources)
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    match this.0.lock() {
+        Ok(mut engine) => engine.use_resources(resources),
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
     Ok(JsNull::new(&mut cx))
 }
@@ -304,21 +298,21 @@ fn engine_tag_exists(mut cx: FunctionContext) -> JsResult<JsBoolean> {
 
     let tag: String = cx.argument::<JsString>(1)?.value(&mut cx);
 
-    let result = if let Ok(engine) = this.0.lock() {
-        engine.tag_exists(&tag)
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    let result = match this.0.lock() {
+        Ok(engine) => engine.tag_exists(&tag),
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
     Ok(cx.boolean(result))
 }
 
 fn engine_clear_tags(mut cx: FunctionContext) -> JsResult<JsNull> {
     let this = cx.argument::<JsBox<Engine>>(0)?;
 
-    if let Ok(mut engine) = this.0.lock() {
-        engine.use_tags(&[]);
-    } else {
-        cx.throw_error("Failed to acquire lock on engine")?
+    match this.0.lock() {
+        Ok(mut engine) => {
+            engine.use_tags(&[]);
+        }
+        _ => cx.throw_error("Failed to acquire lock on engine")?,
     };
     Ok(JsNull::new(&mut cx))
 }
@@ -346,13 +340,13 @@ fn ublock_resources(mut cx: FunctionContext) -> JsResult<JsValue> {
     };
 
     let mut resources = assemble_web_accessible_resources(
-        &Path::new(&web_accessible_resource_dir),
-        &Path::new(&redirect_resources_path),
+        Path::new(&web_accessible_resource_dir),
+        Path::new(&redirect_resources_path),
     );
     if let Some(scriptlets_path) = scriptlets_path {
         #[allow(deprecated)]
         resources.extend(
-            adblock::resources::resource_assembler::assemble_scriptlet_resources(&Path::new(
+            adblock::resources::resource_assembler::assemble_scriptlet_resources(Path::new(
                 &scriptlets_path,
             )),
         );