Arrange ci.

Author: jmjoy

.github/workflows/ci.yml

@@ -42,18 +42,25 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
 
-      - name: Install Rust
+      - name: Install Rust Nightly
         uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly
           override: true
-          components: rustfmt, clippy
+          components: rustfmt
+
+      - name: Install Rust Stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+          components: rustfmt
 
       - name: Cargo fmt
         uses: actions-rs/cargo@v1
         with:
           command: fmt
-          args: --all -- --check
+          args: +nightly --all -- --check
 
       - name: Cargo build
         uses: actions-rs/cargo@v1

examples/hello/src/lib.rs

@@ -1,19 +1,12 @@
 use phper::{
     arrays::Array,
-    c_str_ptr,
-    classes::{Class, StdClass, This},
-    functions::{create_zend_arg_info, Argument},
+    classes::{StdClass, This},
+    functions::Argument,
     ini::Policy,
-    modules::{read_global_module, write_global_module, Module, ModuleArgs},
+    modules::{Module, ModuleArgs},
     php_get_module,
-    sys::{
-        php_info_print_table_end, php_info_print_table_row, php_info_print_table_start,
-        zend_function_entry, OnUpdateBool, PHP_INI_SYSTEM,
-    },
-    values::{ExecuteData, SetVal, Val},
-    Throwable,
+    values::{SetVal, Val},
 };
-use std::{fs::OpenOptions, io::Write};
 
 fn module_init(_args: ModuleArgs) -> bool {
     true

phper-test/src/lib.rs

@@ -1,16 +1,16 @@
 use once_cell::sync::OnceCell;
 use std::{
-    env, ffi::OsStr, fmt::Debug, fs::read_to_string, io::Write, path::Path, process::Command,
+    env,
+    ffi::{OsStr, OsString},
+    fmt::Debug,
+    fs::read_to_string,
+    io::Write,
+    path::{Path, PathBuf},
+    process::Command,
 };
 use tempfile::NamedTempFile;
-use std::ffi::OsString;
-use std::path::PathBuf;
-use std::error::Error;
-
-pub fn test_php_scripts(
-    exe_path: impl AsRef<Path>,
-    scripts: &[impl AsRef<Path>],
-) {
+
+pub fn test_php_scripts(exe_path: impl AsRef<Path>, scripts: &[impl AsRef<Path>]) {
     let context = php_context();
 
     let lib_path = get_lib_path(exe_path);
@@ -115,8 +115,12 @@ fn execute_command<S: AsRef<OsStr> + Debug>(argv: &[S]) -> String {
 
 fn get_lib_path(exe_path: impl AsRef<Path>) -> PathBuf {
     let exe_path = exe_path.as_ref();
-    let exe_stem = exe_path.file_stem().expect("failed to get current exe stem");
-    let target_dir = exe_path.parent().expect("failed to get current exe directory");
+    let exe_stem = exe_path
+        .file_stem()
+        .expect("failed to get current exe stem");
+    let target_dir = exe_path
+        .parent()
+        .expect("failed to get current exe directory");
 
     let mut ext_name = OsString::new();
     ext_name.push("lib");

phper/src/arrays.rs

@@ -2,7 +2,6 @@ use crate::{sys::*, values::Val};
 use std::{
     mem::zeroed,
     ops::{Deref, DerefMut},
-    ptr::null_mut,
 };
 
 pub struct Array {

phper/src/classes.rs

@@ -1,17 +1,14 @@
 use crate::{
-    functions::{invoke, Argument, Callable, FunctionEntity, FunctionEntry, Method},
+    functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
     sys::*,
     values::{SetVal, Val},
 };
 use once_cell::sync::OnceCell;
 use std::{
     mem::zeroed,
     os::raw::c_int,
-    ptr::{null, null_mut},
-    sync::{
-        atomic::{AtomicPtr, Ordering},
-        Arc, Once, RwLock,
-    },
+    ptr::null_mut,
+    sync::atomic::{AtomicPtr, Ordering},
 };
 
 pub trait Class: Send + Sync {
@@ -58,7 +55,7 @@ impl StdClass {
     }
 
     pub fn extends(&mut self, name: impl ToString) {
-        let mut name = name.to_string();
+        let name = name.to_string();
         self.parent = Some(name);
     }
 }

phper/src/errors.rs

@@ -1,14 +1,6 @@
-use crate::{
-    classes::{ClassEntity, ClassEntry},
-    modules::{read_global_module, write_global_module},
-    Error::Other,
-};
+use crate::{classes::ClassEntity, modules::read_global_module, Error::Other};
 use anyhow::anyhow;
-use once_cell::sync::Lazy;
-use std::{
-    cell::RefCell, error, ffi::FromBytesWithNulError, io, ptr::null_mut, str::Utf8Error,
-    sync::atomic::AtomicPtr,
-};
+use std::{error, ffi::FromBytesWithNulError, io, str::Utf8Error};
 
 pub type Result<T> = std::result::Result<T, self::Error>;
 

phper/src/functions.rs

@@ -1,16 +1,12 @@
 use crate::{
     classes::{ClassEntry, This},
-    errors::Throwable,
-    ini::create_ini_entry_ex,
     sys::*,
     values::{ExecuteData, SetVal, Val},
 };
 use std::{
-    cell::Cell,
-    ffi::CStr,
-    mem::{size_of, transmute, zeroed},
-    os::raw::{c_char, c_int},
-    ptr::{null, null_mut},
+    mem::zeroed,
+    os::raw::c_char,
+    ptr::null,
     sync::atomic::{AtomicPtr, Ordering},
 };
 
@@ -51,6 +47,7 @@ pub(crate) enum Callable {
 
 #[repr(transparent)]
 pub struct FunctionEntry {
+    #[allow(dead_code)]
     inner: zend_function_entry,
 }
 
@@ -88,9 +85,9 @@ impl FunctionEntity {
             ));
         }
 
-        infos.push(unsafe { zeroed::<zend_internal_arg_info>() });
+        infos.push(zeroed::<zend_internal_arg_info>());
 
-        let mut last_arg_info = unsafe { zeroed::<zend_internal_arg_info>() };
+        let mut last_arg_info = zeroed::<zend_internal_arg_info>();
         last_arg_info.name = ((&self.handler) as *const _ as *mut i8).cast();
         infos.push(last_arg_info);
 

phper/src/ini.rs

@@ -1,15 +1,12 @@
 use crate::sys::{
-    phper_zend_ini_mh, zend_ini_entry, zend_ini_entry_def, zend_string, OnUpdateBool, OnUpdateLong,
-    OnUpdateReal, OnUpdateString, PHP_INI_ALL, PHP_INI_PERDIR, PHP_INI_SYSTEM, PHP_INI_USER,
+    phper_zend_ini_mh, zend_ini_entry_def, OnUpdateBool, OnUpdateLong, OnUpdateReal,
+    OnUpdateString, PHP_INI_ALL, PHP_INI_PERDIR, PHP_INI_SYSTEM, PHP_INI_USER,
 };
 use std::{
-    cell::Cell,
     ffi::CStr,
-    mem::{size_of, transmute},
-    os::raw::{c_char, c_int, c_void},
+    os::raw::{c_char, c_void},
     ptr::null_mut,
     str,
-    sync::atomic::AtomicPtr,
 };
 
 type OnModify = phper_zend_ini_mh;

phper/src/modules.rs

@@ -1,23 +1,20 @@
 use crate::{
     c_str_ptr,
-    classes::{Class, ClassEntity, ClassEntry, StdClass},
-    functions::{create_zend_arg_info, invoke, Argument, Callable, Function, FunctionEntity},
+    classes::{Class, ClassEntity, StdClass},
+    functions::{Argument, Callable, Function, FunctionEntity},
     ini::{IniEntity, IniValue, Policy, StrPtrBox},
     sys::*,
     EXCEPTION_CLASS_NAME,
 };
 use once_cell::sync::Lazy;
 use std::{
     borrow::BorrowMut,
-    cell::{Cell, RefCell, RefMut},
+    cell::RefCell,
     collections::HashMap,
-    ffi::CStr,
-    mem::{forget, size_of, transmute, zeroed},
-    ops::DerefMut,
-    os::raw::{c_char, c_int, c_uchar, c_uint, c_ushort, c_void},
+    mem::{size_of, zeroed},
+    os::raw::{c_int, c_uchar, c_uint, c_ushort},
     ptr::{null, null_mut},
-    sync::{atomic::AtomicPtr, Arc, Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard},
-    thread::LocalKey,
+    sync::RwLock,
 };
 
 static GLOBAL_MODULE: Lazy<RwLock<Module>> = Lazy::new(Default::default);
@@ -293,7 +290,7 @@ impl Module {
         Self::STR_INI_ENTITIES
             .with(|entities| Self::push_ini_entry(&mut entries, &mut *entities.borrow_mut()));
 
-        entries.push(unsafe { zeroed::<zend_ini_entry_def>() });
+        entries.push(zeroed::<zend_ini_entry_def>());
 
         Box::into_raw(entries.into_boxed_slice()).cast()
     }
@@ -315,6 +312,7 @@ impl Module {
 }
 
 pub struct ModuleArgs {
+    #[allow(dead_code)]
     r#type: c_int,
     module_number: c_int,
 }

phper/src/values.rs

@@ -1,23 +1,5 @@
-use crate::{
-    arrays::Array,
-    c_str_ptr,
-    classes::{This, Visibility},
-    errors::Throwable,
-    sys::*,
-};
-use std::{
-    borrow::Cow,
-    cell::Cell,
-    ffi::{c_void, CStr},
-    io::empty,
-    mem::{size_of, zeroed},
-    os::raw::{c_char, c_int},
-    ptr::null_mut,
-    slice,
-    slice::from_raw_parts,
-    str,
-    sync::atomic::Ordering,
-};
+use crate::{arrays::Array, errors::Throwable, sys::*};
+use std::{mem::zeroed, os::raw::c_int, slice::from_raw_parts, str, sync::atomic::Ordering};
 
 #[repr(transparent)]
 pub struct ExecuteData {