fix clippy warnings (#333)

Signed-off-by: qupeng <qupeng@pingcap.com>

src/compaction_filter.rs

@@ -21,7 +21,7 @@ pub trait CompactionFilter {
 #[repr(C)]
 pub struct CompactionFilterProxy {
     name: CString,
-    filter: Box<CompactionFilter>,
+    filter: Box<dyn CompactionFilter>,
 }
 
 extern "C" fn name(filter: *mut c_void) -> *const c_char {
@@ -69,7 +69,7 @@ impl Drop for CompactionFilterHandle {
 pub unsafe fn new_compaction_filter(
     c_name: CString,
     ignore_snapshots: bool,
-    f: Box<CompactionFilter>,
+    f: Box<dyn CompactionFilter>,
 ) -> Result<CompactionFilterHandle, String> {
     let proxy = Box::into_raw(Box::new(CompactionFilterProxy {
         name: c_name,

src/event_listener.rs

@@ -183,7 +183,7 @@ pub trait EventListener: Send + Sync {
 
 extern "C" fn destructor(ctx: *mut c_void) {
     unsafe {
-        Box::from_raw(ctx as *mut Box<EventListener>);
+        Box::from_raw(ctx as *mut Box<dyn EventListener>);
     }
 }
 
@@ -194,7 +194,12 @@ extern "C" fn on_flush_completed(
     _: *mut DBInstance,
     info: *const DBFlushJobInfo,
 ) {
-    let (ctx, info) = unsafe { (&*(ctx as *mut Box<EventListener>), mem::transmute(&*info)) };
+    let (ctx, info) = unsafe {
+        (
+            &*(ctx as *mut Box<dyn EventListener>),
+            mem::transmute(&*info),
+        )
+    };
     ctx.on_flush_completed(info);
 }
 
@@ -203,7 +208,12 @@ extern "C" fn on_compaction_completed(
     _: *mut DBInstance,
     info: *const DBCompactionJobInfo,
 ) {
-    let (ctx, info) = unsafe { (&*(ctx as *mut Box<EventListener>), mem::transmute(&*info)) };
+    let (ctx, info) = unsafe {
+        (
+            &*(ctx as *mut Box<dyn EventListener>),
+            mem::transmute(&*info),
+        )
+    };
     ctx.on_compaction_completed(info);
 }
 
@@ -212,17 +222,27 @@ extern "C" fn on_external_file_ingested(
     _: *mut DBInstance,
     info: *const DBIngestionInfo,
 ) {
-    let (ctx, info) = unsafe { (&*(ctx as *mut Box<EventListener>), mem::transmute(&*info)) };
+    let (ctx, info) = unsafe {
+        (
+            &*(ctx as *mut Box<dyn EventListener>),
+            mem::transmute(&*info),
+        )
+    };
     ctx.on_external_file_ingested(info);
 }
 
 extern "C" fn on_stall_conditions_changed(ctx: *mut c_void, info: *const DBWriteStallInfo) {
-    let (ctx, info) = unsafe { (&*(ctx as *mut Box<EventListener>), mem::transmute(&*info)) };
+    let (ctx, info) = unsafe {
+        (
+            &*(ctx as *mut Box<dyn EventListener>),
+            mem::transmute(&*info),
+        )
+    };
     ctx.on_stall_conditions_changed(info);
 }
 
 pub fn new_event_listener<L: EventListener>(l: L) -> *mut DBEventListener {
-    let p: Box<EventListener> = Box::new(l);
+    let p: Box<dyn EventListener> = Box::new(l);
     unsafe {
         crocksdb_ffi::crocksdb_eventlistener_create(
             Box::into_raw(Box::new(p)) as *mut c_void,

src/main.rs

@@ -107,7 +107,7 @@ fn custom_merge() {
         }
     }
     let opts = DBOptions::new();
-    DB::destroy(&opts, path).is_ok();
+    let _ = DB::destroy(&opts, path).is_ok();
 }
 
 #[cfg(test)]

src/rocksdb_options.rs

@@ -451,7 +451,7 @@ impl ReadOptions {
         }
     }
 
-    pub fn set_table_filter(&mut self, filter: Box<TableFilter>) {
+    pub fn set_table_filter(&mut self, filter: Box<dyn TableFilter>) {
         unsafe {
             let f = Box::into_raw(Box::new(filter));
             crocksdb_ffi::crocksdb_readoptions_set_table_filter(
@@ -1179,7 +1179,7 @@ impl ColumnFamilyOptions {
         &mut self,
         name: S,
         ignore_snapshots: bool,
-        filter: Box<CompactionFilter>,
+        filter: Box<dyn CompactionFilter>,
     ) -> Result<(), String>
     where
         S: Into<Vec<u8>>,
@@ -1201,7 +1201,7 @@ impl ColumnFamilyOptions {
     pub fn add_table_properties_collector_factory(
         &mut self,
         fname: &str,
-        factory: Box<TablePropertiesCollectorFactory>,
+        factory: Box<dyn TablePropertiesCollectorFactory>,
     ) {
         unsafe {
             let f = new_table_properties_collector_factory(fname, factory);
@@ -1472,7 +1472,7 @@ impl ColumnFamilyOptions {
     pub fn set_prefix_extractor<S>(
         &mut self,
         name: S,
-        transform: Box<SliceTransform>,
+        transform: Box<dyn SliceTransform>,
     ) -> Result<(), String>
     where
         S: Into<Vec<u8>>,
@@ -1497,7 +1497,7 @@ impl ColumnFamilyOptions {
     pub fn set_memtable_insert_hint_prefix_extractor<S>(
         &mut self,
         name: S,
-        transform: Box<SliceTransform>,
+        transform: Box<dyn SliceTransform>,
     ) -> Result<(), String>
     where
         S: Into<Vec<u8>>,

src/slice_transform.rs

@@ -40,7 +40,7 @@ pub trait SliceTransform {
 #[repr(C)]
 pub struct SliceTransformProxy {
     name: CString,
-    transform: Box<SliceTransform>,
+    transform: Box<dyn SliceTransform>,
 }
 
 extern "C" fn name(transform: *mut c_void) -> *const c_char {
@@ -86,7 +86,7 @@ extern "C" fn in_range(transform: *mut c_void, key: *const u8, key_len: size_t)
 
 pub unsafe fn new_slice_transform(
     c_name: CString,
-    f: Box<SliceTransform>,
+    f: Box<dyn SliceTransform>,
 ) -> Result<*mut DBSliceTransform, String> {
     let proxy = Box::into_raw(Box::new(SliceTransformProxy {
         name: c_name,

src/table_filter.rs

@@ -27,13 +27,13 @@ pub trait TableFilter {
 
 pub extern "C" fn table_filter(ctx: *mut c_void, props: *const DBTableProperties) -> c_int {
     unsafe {
-        let filter = &*(ctx as *mut Box<TableFilter>);
+        let filter = &*(ctx as *mut Box<dyn TableFilter>);
         filter.table_filter(mem::transmute(&*props)) as c_int
     }
 }
 
 pub extern "C" fn destroy_table_filter(filter: *mut c_void) {
     unsafe {
-        Box::from_raw(filter as *mut Box<TableFilter>);
+        Box::from_raw(filter as *mut Box<dyn TableFilter>);
     }
 }

src/table_properties_collector.rs

@@ -35,11 +35,11 @@ pub trait TablePropertiesCollector {
 
 struct TablePropertiesCollectorHandle {
     name: CString,
-    rep: Box<TablePropertiesCollector>,
+    rep: Box<dyn TablePropertiesCollector>,
 }
 
 impl TablePropertiesCollectorHandle {
-    fn new(name: &str, rep: Box<TablePropertiesCollector>) -> TablePropertiesCollectorHandle {
+    fn new(name: &str, rep: Box<dyn TablePropertiesCollector>) -> TablePropertiesCollectorHandle {
         TablePropertiesCollectorHandle {
             name: CString::new(name).unwrap(),
             rep: rep,
@@ -97,7 +97,7 @@ pub extern "C" fn finish(handle: *mut c_void, props: *mut DBUserCollectedPropert
 
 pub unsafe fn new_table_properties_collector(
     cname: &str,
-    collector: Box<TablePropertiesCollector>,
+    collector: Box<dyn TablePropertiesCollector>,
 ) -> *mut DBTablePropertiesCollector {
     let handle = TablePropertiesCollectorHandle::new(cname, collector);
     crocksdb_ffi::crocksdb_table_properties_collector_create(

src/table_properties_collector_factory.rs

@@ -20,18 +20,18 @@ use table_properties_collector::{new_table_properties_collector, TableProperties
 /// Internals create a new `TablePropertiesCollector` for each new table.
 pub trait TablePropertiesCollectorFactory {
     /// Has to be thread-safe.
-    fn create_table_properties_collector(&mut self, cf: u32) -> Box<TablePropertiesCollector>;
+    fn create_table_properties_collector(&mut self, cf: u32) -> Box<dyn TablePropertiesCollector>;
 }
 
 struct TablePropertiesCollectorFactoryHandle {
     name: CString,
-    rep: Box<TablePropertiesCollectorFactory>,
+    rep: Box<dyn TablePropertiesCollectorFactory>,
 }
 
 impl TablePropertiesCollectorFactoryHandle {
     fn new(
         name: &str,
-        rep: Box<TablePropertiesCollectorFactory>,
+        rep: Box<dyn TablePropertiesCollectorFactory>,
     ) -> TablePropertiesCollectorFactoryHandle {
         TablePropertiesCollectorFactoryHandle {
             name: CString::new(name).unwrap(),
@@ -66,7 +66,7 @@ extern "C" fn create_table_properties_collector(
 
 pub unsafe fn new_table_properties_collector_factory(
     fname: &str,
-    factory: Box<TablePropertiesCollectorFactory>,
+    factory: Box<dyn TablePropertiesCollectorFactory>,
 ) -> *mut DBTablePropertiesCollectorFactory {
     let handle = TablePropertiesCollectorFactoryHandle::new(fname, factory);
     crocksdb_ffi::crocksdb_table_properties_collector_factory_create(

tests/cases/test_rocksdb_options.rs

@@ -15,7 +15,6 @@ use rocksdb::crocksdb_ffi::{
     CompactionPriority, DBCompressionType, DBInfoLogLevel as InfoLogLevel, DBRateLimiterMode,
     DBStatisticsHistogramType as HistogramType, DBStatisticsTickerType as TickerType,
 };
-use rocksdb::rocksdb::MemoryAllocator;
 use rocksdb::{
     BlockBasedOptions, Cache, ColumnFamilyOptions, CompactOptions, DBOptions, Env,
     FifoCompactionOptions, IndexType, LRUCacheOptions, ReadOptions, SeekKey, SliceTransform,

tests/cases/test_table_properties.rs

@@ -132,7 +132,7 @@ impl ExampleFactory {
 }
 
 impl TablePropertiesCollectorFactory for ExampleFactory {
-    fn create_table_properties_collector(&mut self, _: u32) -> Box<TablePropertiesCollector> {
+    fn create_table_properties_collector(&mut self, _: u32) -> Box<dyn TablePropertiesCollector> {
         Box::new(ExampleCollector::new())
     }
 }

tests/cases/test_titan.rs

@@ -82,7 +82,7 @@ impl TablePropertiesCollector for TitanCollector {
 struct TitanCollectorFactory {}
 
 impl TablePropertiesCollectorFactory for TitanCollectorFactory {
-    fn create_table_properties_collector(&mut self, _: u32) -> Box<TablePropertiesCollector> {
+    fn create_table_properties_collector(&mut self, _: u32) -> Box<dyn TablePropertiesCollector> {
         Box::new(TitanCollector::default())
     }
 }