michael/mlua
michael
/
mlua
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix clippy warnings

This commit is contained in:
Alex Orlenko 2023-02-07 22:43:48 +00:00
parent f5182e0584
commit b790b525c1
No known key found for this signature in database
GPG Key ID: 4C150C250863B96D
8 changed files with 40 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
build/find_normal.rs
View File

@ -8,7 +8,7 @@ fn get_env_var(name: &str) -> String {
match env::var(name) {
Ok(val) => val,
Err(env::VarError::NotPresent) => String::new(),
Err(err) => panic!("cannot get {}: {}", name, err),
Err(err) => panic!("cannot get {name}: {err}"),
}
}
@ -37,8 +37,8 @@ pub fn probe_lua() -> Option<PathBuf> {
if get_env_var("LUA_LINK") == "static" {
link_lib = "static=";
};
println!("cargo:rustc-link-search=native={}", lib_dir);
println!("cargo:rustc-link-lib={}{}", link_lib, lua_lib);
println!("cargo:rustc-link-search=native={lib_dir}");
println!("cargo:rustc-link-lib={link_lib}{lua_lib}");
}
return Some(PathBuf::from(include_dir));
}
@ -72,7 +72,7 @@ pub fn probe_lua() -> Option<PathBuf> {
.probe(alt_probe);
}
lua.unwrap_or_else(|_| panic!("cannot find Lua {} using `pkg-config`", ver))
lua.unwrap_or_else(|_| panic!("cannot find Lua {ver} using `pkg-config`"))
.include_paths
.get(0)
.cloned()

2
mlua_derive/src/token.rs
View File

@ -59,7 +59,7 @@ fn parse_pos(span: &Span) -> Option<(usize, usize)> {
static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"bytes\(([0-9]+)\.\.([0-9]+)\)").unwrap());
match RE.captures(&format!("{:?}", span)) {
match RE.captures(&format!("{span:?}")) {
Some(caps) => match (caps.get(1), caps.get(2)) {
(Some(start), Some(end)) => Some((
match start.as_str().parse() {

32
src/error.rs
View File

@ -185,17 +185,17 @@ pub type Result<T> = StdResult<T, Error>;
impl fmt::Display for Error {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
Error::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {}", message),
Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {}", msg),
Error::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {message}"),
Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {msg}"),
Error::MemoryError(ref msg) => {
write!(fmt, "memory error: {}", msg)
write!(fmt, "memory error: {msg}")
}
#[cfg(any(feature = "lua53", feature = "lua52"))]
Error::GarbageCollectorError(ref msg) => {
write!(fmt, "garbage collector error: {}", msg)
write!(fmt, "garbage collector error: {msg}")
}
Error::SafetyError(ref msg) => {
write!(fmt, "safety error: {}", msg)
write!(fmt, "safety error: {msg}")
},
Error::MemoryLimitNotAvailable => {
write!(fmt, "setting memory limit is not available")
@ -217,17 +217,17 @@ impl fmt::Display for Error {
"too many arguments to Function::bind"
),
Error::ToLuaConversionError { from, to, ref message } => {
write!(fmt, "error converting {} to Lua {}", from, to)?;
write!(fmt, "error converting {from} to Lua {to}")?;
match *message {
None => Ok(()),
Some(ref message) => write!(fmt, " ({})", message),
Some(ref message) => write!(fmt, " ({message})"),
}
}
Error::FromLuaConversionError { from, to, ref message } => {
write!(fmt, "error converting Lua {} to {}", from, to)?;
write!(fmt, "error converting Lua {from} to {to}")?;
match *message {
None => Ok(()),
Some(ref message) => write!(fmt, " ({})", message),
Some(ref message) => write!(fmt, " ({message})"),
}
}
Error::CoroutineInactive => write!(fmt, "cannot resume inactive coroutine"),
@ -235,12 +235,12 @@ impl fmt::Display for Error {
Error::UserDataDestructed => write!(fmt, "userdata has been destructed"),
Error::UserDataBorrowError => write!(fmt, "userdata already mutably borrowed"),
Error::UserDataBorrowMutError => write!(fmt, "userdata already borrowed"),
Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {} is restricted", method),
Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {method} is restricted"),
Error::MetaMethodTypeError { ref method, type_name, ref message } => {
write!(fmt, "metamethod {} has unsupported type {}", method, type_name)?;
write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
match *message {
None => Ok(()),
Some(ref message) => write!(fmt, " ({})", message),
Some(ref message) => write!(fmt, " ({message})"),
}
}
Error::MismatchedRegistryKey => {
@ -267,20 +267,20 @@ impl fmt::Display for Error {
} else {
writeln!(fmt, "{}", traceback.trim_end())?;
}
write!(fmt, "caused by: {}", cause)
write!(fmt, "caused by: {cause}")
}
Error::PreviouslyResumedPanic => {
write!(fmt, "previously resumed panic returned again")
}
#[cfg(feature = "serialize")]
Error::SerializeError(ref err) => {
write!(fmt, "serialize error: {}", err)
write!(fmt, "serialize error: {err}")
},
#[cfg(feature = "serialize")]
Error::DeserializeError(ref err) => {
write!(fmt, "deserialize error: {}", err)
write!(fmt, "deserialize error: {err}")
},
Error::ExternalError(ref err) => write!(fmt, "{}", err),
Error::ExternalError(ref err) => write!(fmt, "{err}"),
}
}
}

19
src/ffi/mod.rs
View File

@ -73,17 +73,18 @@ pub const SYS_MIN_ALIGN: usize = 4;
// by C modules in unsafe mode
#[cfg(not(feature = "luau"))]
pub(crate) fn keep_lua_symbols() {
let mut symbols: Vec<*const extern "C" fn()> = Vec::new();
symbols.push(lua_atpanic as _);
symbols.push(lua_isuserdata as _);
symbols.push(lua_tocfunction as _);
symbols.push(luaL_loadstring as _);
symbols.push(luaL_openlibs as _);
let mut _symbols: Vec<*const extern "C" fn()> = vec![
lua_atpanic as _,
lua_isuserdata as _,
lua_tocfunction as _,
luaL_loadstring as _,
luaL_openlibs as _,
];
#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
{
symbols.push(lua_getglobal as _);
symbols.push(lua_setglobal as _);
symbols.push(luaL_setfuncs as _);
_symbols.push(lua_getglobal as _);
_symbols.push(lua_setglobal as _);
_symbols.push(luaL_setfuncs as _);
}
}

4
src/hook.rs
View File

@ -162,9 +162,9 @@ impl<'lua> Debug<'lua> {
#[cfg(not(feature = "luau"))]
let stack = DebugStack {
num_ups: (*self.ar.get()).nups as i32,
num_ups: (*self.ar.get()).nups as _,
#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
num_params: (*self.ar.get()).nparams as i32,
num_params: (*self.ar.get()).nparams as _,
#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
is_vararg: (*self.ar.get()).isvararg != 0,
};

3
src/lua.rs
View File

@ -3382,8 +3382,7 @@ unsafe fn ref_stack_pop(extra: &mut ExtraData) -> c_int {
// It is a user error to create enough references to exhaust the Lua max stack size for
// the ref thread.
panic!(
"cannot create a Lua reference, out of auxiliary stack space (used {} slots)",
top
"cannot create a Lua reference, out of auxiliary stack space (used {top} slots)"
);
}
extra.ref_stack_size += inc;

4
src/luau.rs
View File

@ -102,11 +102,11 @@ fn lua_require(lua: &Lua, name: Option<StdString>) -> Result<Value> {
break;
}
}
let source = source.ok_or_else(|| Error::RuntimeError(format!("cannot find '{}'", name)))?;
let source = source.ok_or_else(|| Error::RuntimeError(format!("cannot find '{name}'")))?;
let value = lua
.load(&source)
.set_name(&format!("={}", source_name))
.set_name(&format!("={source_name}"))
.set_mode(ChunkMode::Text)
.call::<_, Value>(())?;

8
src/util.rs
View File

@ -844,7 +844,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
// Depending on how the API is used and what error types scripts are given, it may
// be possible to make this consume arbitrary amounts of memory (for example, some
// kind of recursive error structure?)
let _ = write!(&mut (*err_buf), "{}", error);
let _ = write!(&mut (*err_buf), "{error}");
Ok(err_buf)
}
Some(WrappedFailure::Panic(Some(ref panic))) => {
@ -855,9 +855,9 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
ffi::lua_pop(state, 2);
if let Some(msg) = panic.downcast_ref::<&str>() {
let _ = write!(&mut (*err_buf), "{}", msg);
let _ = write!(&mut (*err_buf), "{msg}");
} else if let Some(msg) = panic.downcast_ref::<String>() {
let _ = write!(&mut (*err_buf), "{}", msg);
let _ = write!(&mut (*err_buf), "{msg}");
} else {
let _ = write!(&mut (*err_buf), "<panic>");
};
@ -1006,7 +1006,7 @@ pub(crate) unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> Stri
let v = ffi::lua_tovector(state, index);
mlua_debug_assert!(!v.is_null(), "vector is null");
let (x, y, z) = (*v, *v.add(1), *v.add(2));
format!("vector({},{},{})", x, y, z)
format!("vector({x},{y},{z})")
}
ffi::LUA_TSTRING => {
let mut size = 0;