use std::time::Duration;

use clippy_config::Conf;

use clippy_utils::consts::{ConstEvalCtxt, Constant};

use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg, span_lint_and_then};

use clippy_utils::msrvs::{self, Msrv};

use clippy_utils::res::{MaybeDef, MaybeTypeckRes};

use clippy_utils::sugg::Sugg;

use clippy_utils::sym;

use rustc_errors::Applicability;

use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};

use rustc_lint::{LateContext, LateLintPass};

use rustc_middle::ty::Ty;

use rustc_session::impl_lint_pass;

use rustc_span::SyntaxContext;

declare_clippy_lint! {

/// ### What it does

/// Lints subtraction between `Instant::now()` and another `Instant`.

///

/// ### Why is this bad?

/// It is easy to accidentally write `prev_instant - Instant::now()`, which will always be 0ns

/// as `Instant` subtraction saturates.

///

/// `prev_instant.elapsed()` also more clearly signals intention.

///

/// ### Example

/// ```no_run

/// use std::time::Instant;

/// let prev_instant = Instant::now();

/// let duration = Instant::now() - prev_instant;

/// ```

/// Use instead:

/// ```no_run

/// use std::time::Instant;

/// let prev_instant = Instant::now();

/// let duration = prev_instant.elapsed();

/// ```

#[clippy::version = "1.65.0"]

pub MANUAL_INSTANT_ELAPSED,

pedantic,

"subtraction between `Instant::now()` and previous `Instant`"

}

declare_clippy_lint! {

/// ### What it does

/// Lints subtraction between an `Instant` and a `Duration`, or between two `Duration` values.

///

/// ### Why is this bad?

/// Unchecked subtraction could cause underflow on certain platforms, leading to

/// unintentional panics.

///

/// ### Example

/// ```no_run

/// # use std::time::{Instant, Duration};

/// let time_passed = Instant::now() - Duration::from_secs(5);

/// let dur1 = Duration::from_secs(3);

/// let dur2 = Duration::from_secs(5);

/// let diff = dur1 - dur2;

/// ```

///

/// Use instead:

/// ```no_run

/// # use std::time::{Instant, Duration};

/// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));

/// let dur1 = Duration::from_secs(3);

/// let dur2 = Duration::from_secs(5);

/// let diff = dur1.checked_sub(dur2);

/// ```

#[clippy::version = "1.67.0"]

pub UNCHECKED_TIME_SUBTRACTION,

pedantic,

"finds unchecked subtraction involving 'Duration' or 'Instant'"

}

impl_lint_pass!(UncheckedTimeSubtraction => [

MANUAL_INSTANT_ELAPSED,

UNCHECKED_TIME_SUBTRACTION,

]);

pub struct UncheckedTimeSubtraction {

msrv: Msrv,

}

impl UncheckedTimeSubtraction {

pub fn new(conf: &'static Conf) -> Self {

Self { msrv: conf.msrv }

}

}

impl LateLintPass<'_> for UncheckedTimeSubtraction {

fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {

let (lhs, rhs) = match expr.kind {

ExprKind::Binary(op, lhs, rhs) if matches!(op.node, BinOpKind::Sub,) => (lhs, rhs),

ExprKind::MethodCall(_, lhs, [rhs], _) if cx.ty_based_def(expr).is_diag_item(cx, sym::sub) => (lhs, rhs),

_ => return,

};

let typeck = cx.typeck_results();

let lhs_name = typeck.expr_ty(lhs).opt_diag_name(cx);

let rhs_name = typeck.expr_ty(rhs).opt_diag_name(cx);

if lhs_name == Some(sym::Instant) {

// Instant::now() - instant

if is_instant_now_call(cx, lhs) && rhs_name == Some(sym::Instant) {

print_manual_instant_elapsed_sugg(cx, expr, rhs);

}

// instant - duration

else if rhs_name == Some(sym::Duration)

&& !expr.span.from_expansion()

&& self.msrv.meets(cx, msrvs::TRY_FROM)

{

print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);

}

}

// duration - duration

else if lhs_name == Some(sym::Duration)

&& rhs_name == Some(sym::Duration)

&& !expr.span.from_expansion()

&& self.msrv.meets(cx, msrvs::TRY_FROM)

{

let const_eval = ConstEvalCtxt::new(cx);

let ctxt = expr.span.ctxt();

if let Some(lhs) = const_eval_duration(&const_eval, lhs, ctxt)

&& let Some(rhs) = const_eval_duration(&const_eval, rhs, ctxt)

{

if lhs >= rhs {

// If the duration subtraction can be proven to not underflow, then we don't lint

return;

}

span_lint_and_note(

cx,

UNCHECKED_TIME_SUBTRACTION,

expr.span,

"unchecked subtraction of two `Duration` that will underflow",

None,

"if this is intentional, consider allowing the lint",

);

return;

}

print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);

}

}

}

fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {

if let ExprKind::Call(fn_expr, []) = expr_block.kind

&& cx.ty_based_def(fn_expr).is_diag_item(cx, sym::instant_now)

{

true

} else {

false

}

}

/// Returns true if this subtraction is part of a chain like `(a - b) - c`

fn is_chained_time_subtraction(cx: &LateContext<'_>, lhs: &Expr<'_>) -> bool {

if let ExprKind::Binary(op, inner_lhs, inner_rhs) = &lhs.kind

&& matches!(op.node, BinOpKind::Sub)

{

let typeck = cx.typeck_results();

let left_ty = typeck.expr_ty(inner_lhs);

let right_ty = typeck.expr_ty(inner_rhs);

is_time_type(cx, left_ty) && is_time_type(cx, right_ty)

} else {

false

}

}

/// Returns true if the type is Duration or Instant

fn is_time_type(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {

matches!(ty.opt_diag_name(cx), Some(sym::Duration | sym::Instant))

}

fn print_manual_instant_elapsed_sugg(cx: &LateContext<'_>, expr: &Expr<'_>, rhs: &Expr<'_>) {

let mut applicability = Applicability::MachineApplicable;

let sugg = Sugg::hir_with_context(cx, rhs, expr.span.ctxt(), "<instant>", &mut applicability);

span_lint_and_sugg(

cx,

MANUAL_INSTANT_ELAPSED,

expr.span,

"manual implementation of `Instant::elapsed`",

"try",

format!("{}.elapsed()", sugg.maybe_paren()),

applicability,

);

}

fn print_unchecked_duration_subtraction_sugg(

cx: &LateContext<'_>,

left_expr: &Expr<'_>,

right_expr: &Expr<'_>,

expr: &Expr<'_>,

) {

span_lint_and_then(

cx,

UNCHECKED_TIME_SUBTRACTION,

expr.span,

"unchecked subtraction of a `Duration`",

|diag| {

// For chained subtraction, like `(dur1 - dur2) - dur3` or `(instant - dur1) - dur2`,

// avoid suggestions

if !is_chained_time_subtraction(cx, left_expr) {

let mut applicability = Applicability::MachineApplicable;

let left_sugg = Sugg::hir_with_context(cx, left_expr, expr.span.ctxt(), "<left>", &mut applicability);

let right_sugg =

Sugg::hir_with_context(cx, right_expr, expr.span.ctxt(), "<right>", &mut applicability);

diag.span_suggestion(

expr.span,

"try",

format!("{}.checked_sub({}).unwrap()", left_sugg.maybe_paren(), right_sugg),

applicability,

);

}

},

);

}

fn const_eval_duration(const_eval: &ConstEvalCtxt<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> Option<Duration> {

if let ExprKind::Call(func, args) = expr.kind

&& let ExprKind::Path(QPath::TypeRelative(_, func_name)) = func.kind

{

macro_rules! try_parse_duration {

(($( $name:ident : $var:ident ( $ty:ty ) ),+ $(,)?) -> $ctor:ident ( $($args:tt)* )) => {{

let [$( $name ),+] = args else { return None };

$(

let Some(Constant::$var(v)) = const_eval.eval_local($name, ctxt) else { return None };

let $name = <$ty>::try_from(v).ok()?;

)+

Some(Duration::$ctor($($args)*))

}};

}

return match func_name.ident.name {

sym::new => try_parse_duration! { (secs: Int(u64), nanos: Int(u32)) -> new(secs, nanos) },

sym::from_nanos => try_parse_duration! { (nanos: Int(u64)) -> from_nanos(nanos) },

sym::from_nanos_u128 => try_parse_duration! { (nanos: Int(u128)) -> from_nanos_u128(nanos) },

sym::from_micros => try_parse_duration! { (micros: Int(u64)) -> from_micros(micros) },

sym::from_millis => try_parse_duration! { (millis: Int(u64)) -> from_millis(millis) },

sym::from_secs => try_parse_duration! { (secs: Int(u64)) -> from_secs(secs) },

sym::from_secs_f32 => try_parse_duration! { (secs: F32(f32)) -> from_secs_f32(secs) },

sym::from_secs_f64 => try_parse_duration! { (secs: F64(f64)) -> from_secs_f64(secs) },

sym::from_mins => try_parse_duration! { (mins: Int(u64)) -> from_mins(mins) },

sym::from_hours => {

try_parse_duration! { (hours: Int(u64)) -> from_hours(hours) }

},

sym::from_days => {

try_parse_duration! { (days: Int(u64)) -> from_hours(days * 24) }

},

sym::from_weeks => {

try_parse_duration! { (weeks: Int(u64)) -> from_hours(weeks * 24 * 7) }

},

_ => None,

};

}

None

}