itsscb/askama
1
0
Fork 0
mirror of https://github.com/askama-rs/askama.git synced 2025-09-28 05:21:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use if-let-chains

Browse Source 
I ran `cargo +nightly clippy --all-targets --fix  -- -D warnings` and
made only tiny manual improvements.
This commit is contained in:
René Kijewski 2025-07-13 22:27:59 +02:00
parent 79d8f8886b
commit f201285ede
10 changed files with 90 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
askama/src/filters/json.rs
View File

@ -195,10 +195,10 @@ where
fn get_escaped(byte: u8) -> Option<[AsciiChar; 2]> {
const _: () = assert!(CHAR_RANGE < 32);
if let MIN_CHAR..=MAX_CHAR = byte {
if (1u32 << (byte - MIN_CHAR)) & BITS != 0 {
return Some(TABLE.0[(byte - MIN_CHAR) as usize]);
}
if let MIN_CHAR..=MAX_CHAR = byte
&& (1u32 << (byte - MIN_CHAR)) & BITS != 0
{
return Some(TABLE.0[(byte - MIN_CHAR) as usize]);
}
None
}

10
askama/src/helpers.rs
View File

@ -90,11 +90,11 @@ where
{
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if let Some(func) = self.func.take() {
if let Err(err) = func(f) {
self.err.set(Some(err));
return Err(fmt::Error);
}
if let Some(func) = self.func.take()
&& let Err(err) = func(f)
{
self.err.set(Some(err));
return Err(fmt::Error);
}
Ok(())
}

16
askama_derive/src/generator/expr.rs
View File

@ -673,14 +673,14 @@ impl<'a> Generator<'a, '_> {
for (i, part) in path.iter().copied().enumerate() {
if i > 0 {
buf.write("::");
} else if let Some(enum_ast) = self.input.enum_ast {
if part == "Self" {
let this = &enum_ast.ident;
let (_, generics, _) = enum_ast.generics.split_for_impl();
let generics = generics.as_turbofish();
buf.write(quote!(#this #generics));
continue;
}
} else if let Some(enum_ast) = self.input.enum_ast
&& part == "Self"
{
let this = &enum_ast.ident;
let (_, generics, _) = enum_ast.generics.split_for_impl();
let generics = generics.as_turbofish();
buf.write(quote!(#this #generics));
continue;
}
buf.write(part);
}

20
askama_derive/src/generator/filter.rs
View File

@ -562,17 +562,17 @@ impl<'a> Generator<'a, '_> {
) -> Result<DisplayWrap, CompileError> {
ensure_filter_has_feature_alloc(ctx, "format", node)?;
ensure_no_named_arguments(ctx, "format", args, node)?;
if !args.is_empty() {
if let Expr::StrLit(ref fmt) = *args[0] {
buf.write("askama::helpers::alloc::format!(");
self.visit_str_lit(buf, fmt);
if args.len() > 1 {
buf.write(',');
self.visit_args(ctx, buf, &args[1..])?;
}
buf.write(')');
return Ok(DisplayWrap::Unwrapped);
if !args.is_empty()
&& let Expr::StrLit(ref fmt) = *args[0]
{
buf.write("askama::helpers::alloc::format!(");
self.visit_str_lit(buf, fmt);
if args.len() > 1 {
buf.write(',');
self.visit_args(ctx, buf, &args[1..])?;
}
buf.write(')');
return Ok(DisplayWrap::Unwrapped);
}
Err(ctx.generate_error(
r#"use `format` filter like `"a={} b={}"|format(a, b)`"#,

22
askama_derive/src/generator/node.rs
View File

@ -1585,17 +1585,17 @@ fn macro_call_ensure_arg_count(
}
_ => Some(pos),
};
if let Some(pos) = pos {
if mem::take(&mut args[pos]).is_none() {
// This argument was already passed, so error.
return Err(ctx.generate_error(
format_args!(
"argument `{}` was passed more than once when calling macro `{}`",
def.args[pos].0, def.name,
),
call.span(),
));
}
if let Some(pos) = pos
&& mem::take(&mut args[pos]).is_none()
{
// This argument was already passed, so error.
return Err(ctx.generate_error(
format_args!(
"argument `{}` was passed more than once when calling macro `{}`",
def.args[pos].0, def.name,
),
call.span(),
));
}
}

8
askama_derive/src/integration.rs
View File

@ -386,10 +386,10 @@ where
A: FnMut(&mut S) -> &mut Option<T>,
{
let dest = access(dest);
if dest.is_none() {
if let Some(parent) = access(parent) {
*dest = Some(parent.clone());
}
if dest.is_none()
&& let Some(parent) = access(parent)
{
*dest = Some(parent.clone());
}
}

8
askama_derive/src/lib.rs
View File

@ -331,10 +331,10 @@ pub(crate) fn build_template(
build_template_enum(buf, ast, enum_args, vars_args, has_default_impl)
}
};
if let Err(err) = &mut result {
if err.span.is_none() {
err.span = err_span;
}
if let Err(err) = &mut result
&& err.span.is_none()
{
err.span = err_span;
}
result
}

41
askama_parser/src/expr.rs
View File

@ -71,10 +71,10 @@ fn check_expr<'a>(expr: &WithSpan<'a, Expr<'a>>, allowed: Allowed) -> ParseResul
}
}
Expr::Path(path) => {
if let &[name] = path.as_slice() {
if !crate::can_be_variable_name(name) {
return err_reserved_identifier(name);
}
if let &[name] = path.as_slice()
&& !crate::can_be_variable_name(name)
{
return err_reserved_identifier(name);
}
Ok(())
}
@ -996,25 +996,24 @@ impl<'a> Suffix<'a> {
const THREE_CHARS: &[&str] = &["<<=", ">>=", "...", "..="];
// need to check long to short
if let Some((head, tail)) = i.split_at_checked(3) {
if THREE_CHARS.contains(&head) {
*i = tail;
return Ok(());
}
if let Some((head, tail)) = i.split_at_checked(3)
&& THREE_CHARS.contains(&head)
{
*i = tail;
return Ok(());
}
if let Some((head, tail)) = i.split_at_checked(2) {
if TWO_CHARS.contains(&head) {
*i = tail;
return Ok(());
}
if let Some((head, tail)) = i.split_at_checked(2)
&& TWO_CHARS.contains(&head)
{
*i = tail;
return Ok(());
}
if let Some((head, tail)) = i.split_at_checked(1) {
if let [head] = head.as_bytes() {
if ONE_CHAR.contains(head) {
*i = tail;
return Ok(());
}
}
if let Some((head, tail)) = i.split_at_checked(1)
&& let [head] = head.as_bytes()
&& ONE_CHAR.contains(head)
{
*i = tail;
return Ok(());
}
fail(i)
}

40
askama_parser/src/node.rs
View File

@ -42,12 +42,12 @@ impl<'a> Node<'a> {
let result = match (|i: &mut _| Self::many(i, s)).parse_next(i) {
Ok(result) => result,
Err(err) => {
if let ErrMode::Backtrack(err) | ErrMode::Cut(err) = &err {
if err.message.is_none() {
*i = start;
if let Some(mut span) = err.span.as_suffix_of(i) {
opt(|i: &mut _| unexpected_tag(i, s)).parse_next(&mut span)?;
}
if let ErrMode::Backtrack(err) | ErrMode::Cut(err) = &err
&& err.message.is_none()
{
*i = start;
if let Some(mut span) = err.span.as_suffix_of(i) {
opt(|i: &mut _| unexpected_tag(i, s)).parse_next(&mut span)?;
}
}
return Err(err);
@ -216,12 +216,12 @@ fn cut_node<'a, O>(
move |i: &mut &'a str| {
let start = *i;
let result = inner.parse_next(i);
if let Err(ErrMode::Cut(err) | ErrMode::Backtrack(err)) = &result {
if err.message.is_none() {
*i = start;
if let Some(mut span) = err.span.as_suffix_of(i) {
opt(|i: &mut _| unexpected_raw_tag(kind, i)).parse_next(&mut span)?;
}
if let Err(ErrMode::Cut(err) | ErrMode::Backtrack(err)) = &result
&& err.message.is_none()
{
*i = start;
if let Some(mut span) = err.span.as_suffix_of(i) {
opt(|i: &mut _| unexpected_raw_tag(kind, i)).parse_next(&mut span)?;
}
}
result
@ -414,14 +414,14 @@ impl<'a> CondTest<'a> {
ws(|i: &mut _| {
let start = *i;
let mut expr = Expr::parse(i, s.level, false)?;
if let Expr::BinOp(v) = &mut expr.inner {
if matches!(v.rhs.inner, Expr::Var("set" | "let")) {
let _level_guard = s.level.nest(i)?;
*i = v.rhs.span.as_suffix_of(start).unwrap();
let start_span = Span::from(*i);
let new_right = Self::parse_cond(i, s)?;
v.rhs.inner = Expr::LetCond(Box::new(WithSpan::new(new_right, start_span)));
}
if let Expr::BinOp(v) = &mut expr.inner
&& matches!(v.rhs.inner, Expr::Var("set" | "let"))
{
let _level_guard = s.level.nest(i)?;
*i = v.rhs.span.as_suffix_of(start).unwrap();
let start_span = Span::from(*i);
let new_right = Self::parse_cond(i, s)?;
v.rhs.inner = Expr::LetCond(Box::new(WithSpan::new(new_right, start_span)));
}
Ok(expr)
}),

8
askama_parser/src/target.rs
View File

@ -165,10 +165,10 @@ impl<'a> Target<'a> {
*i,
);
}
if let Target::Rest(ref s) = rest.0 {
if s.inner.is_some() {
return cut_error!("`@ ..` cannot be used in struct", s.span);
}
if let Target::Rest(ref s) = rest.0
&& s.inner.is_some()
{
return cut_error!("`@ ..` cannot be used in struct", s.span);
}
return Ok((rest.1, rest.0));
}