Include async functions in the len_without_is_empty

Author: mladedav

clippy_lints/src/len_zero.rs

@@ -6,6 +6,12 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{
+    def::Res,
+    PrimTy,
+    QPath,
+    TypeBindingKind,
+    lang_items::LangItem,
+    GenericBound,
     def_id::DefId, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, ImplItem, ImplItemKind, ImplicitSelfKind, Item,
     ItemKind, Mutability, Node, TraitItemRef, TyKind, UnOp,
 };
@@ -256,7 +262,87 @@ enum LenOutput<'tcx> {
     Option(DefId),
     Result(DefId, Ty<'tcx>),
 }
-fn parse_len_output<'tcx>(cx: &LateContext<'_>, sig: FnSig<'tcx>) -> Option<LenOutput<'tcx>> {
+
+fn extract_future_output<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: Ty<'tcx>,
+) -> Option<Res> {
+
+    if let ty::Alias(_, alias_ty) = ty.kind() {
+        let def_id = alias_ty.def_id;
+        let hir_map = cx.tcx.hir();
+        let item = hir_map.get_if_local(def_id);
+        let item = item.unwrap();
+
+        if let Node::Item(item) = item {
+            if let ItemKind::OpaqueTy(opaque) = &item.kind {
+                let bounds = opaque.bounds;
+                let bound = &bounds[0];
+                if let GenericBound::LangItemTrait(item, _, _, generic_args) = bound {
+                    if item != &LangItem::Future {
+                        return None;
+                    }
+
+                    let bindings = generic_args.bindings;
+                    if bindings.len() != 1 {
+                        return None;
+                    }
+
+                    let binding = &bindings[0];
+                    let kind = &binding.kind;
+
+                    if let TypeBindingKind::Equality{term: rustc_hir::Term::Ty(term_ty) } = kind {
+                        if let TyKind::Path(QPath::Resolved(_, path)) = &term_ty.kind {
+                            let segments = &path.segments;
+                            let segment = &segments[0];
+                            let res = segment.res;
+
+                            return Some(res);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return None;
+}
+
+// fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'tcx Ty<'tcx>> {
+//     if_chain! {
+//         if let Some(segment) = trait_ref.path.segments.last();
+//         if let Some(args) = segment.args;
+//         if args.bindings.len() == 1;
+//         let binding = &args.bindings[0];
+//         if binding.ident.name == sym::Output;
+//         if let TypeBindingKind::Equality { term: Term::Ty(output) } = binding.kind;
+//         then {
+//             return Some(output);
+//         }
+//     }
+
+//     None
+// }
+
+fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<LenOutput<'tcx>> {
+
+    if let Some(res) = extract_future_output(cx, sig.output()) {
+
+        if matches!(res, Res::PrimTy(PrimTy::Uint(_))) || matches!(res, Res::PrimTy(PrimTy::Int(_))) {
+                return Some(LenOutput::Integral);
+        }
+
+        if let Res::Def(_, def_id) = res {
+            if cx.tcx.is_diagnostic_item(sym::Option, def_id) {
+                return Some(LenOutput::Option(def_id));
+            } else if cx.tcx.is_diagnostic_item(sym::Result, def_id) {
+                return Some(LenOutput::Result(def_id, cx.tcx.ty_error()));
+            }
+        }
+
+        panic!();
+    }
+
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
         ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) => {
@@ -271,7 +357,19 @@ fn parse_len_output<'tcx>(cx: &LateContext<'_>, sig: FnSig<'tcx>) -> Option<LenO
 }
 
 impl<'tcx> LenOutput<'tcx> {
-    fn matches_is_empty_output(self, ty: Ty<'tcx>) -> bool {
+    fn matches_is_empty_output(self,
+        cx: &LateContext<'tcx>,
+        ty: Ty<'tcx>) -> bool {
+
+        if let Some(future_output) = extract_future_output(cx, ty) {
+            return match (self, future_output) {
+                (_, Res::PrimTy(PrimTy::Bool)) => true,
+                (Self::Option(_), Res::Def(_, def_id)) if cx.tcx.is_diagnostic_item(sym::Option, def_id) => true,
+                (Self::Result(_, _), Res::Def(_, def_id)) if cx.tcx.is_diagnostic_item(sym::Result, def_id) => true,
+                _ => false,
+            }
+        }
+
         match (self, ty.kind()) {
             (_, &ty::Bool) => true,
             (Self::Option(id), &ty::Adt(adt, subs)) if id == adt.did() => subs.type_at(0).is_bool(),
@@ -301,9 +399,14 @@ impl<'tcx> LenOutput<'tcx> {
 }
 
 /// Checks if the given signature matches the expectations for `is_empty`
-fn check_is_empty_sig<'tcx>(sig: FnSig<'tcx>, self_kind: ImplicitSelfKind, len_output: LenOutput<'tcx>) -> bool {
+fn check_is_empty_sig<'tcx>(
+        cx: &LateContext<'tcx>,
+        sig: FnSig<'tcx>,
+        self_kind: ImplicitSelfKind,
+        len_output: LenOutput<'tcx>
+) -> bool {
     match &**sig.inputs_and_output {
-        [arg, res] if len_output.matches_is_empty_output(*res) => {
+        [arg, res] if len_output.matches_is_empty_output(cx, *res) => {
             matches!(
                 (arg.kind(), self_kind),
                 (ty::Ref(_, _, Mutability::Not), ImplicitSelfKind::ImmRef)
@@ -352,6 +455,7 @@ fn check_for_is_empty<'tcx>(
         Some(is_empty)
             if !(is_empty.fn_has_self_parameter
                 && check_is_empty_sig(
+                    cx,
                     cx.tcx.fn_sig(is_empty.def_id).subst_identity().skip_binder(),
                     self_kind,
                     output,

tests/ui/len_without_is_empty.rs

@@ -282,6 +282,69 @@ impl AsyncLen {
     }
 }
 
+// issue #7232
+pub struct AsyncLenWithoutIsEmpty;
+impl AsyncLenWithoutIsEmpty {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> usize {
+        usize::from(!self.async_task().await)
+    }
+}
+
+// issue #7232
+pub struct AsyncOptionLenWithoutIsEmpty;
+impl AsyncOptionLenWithoutIsEmpty {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> Option<usize> {
+        None
+    }
+}
+
+// issue #7232
+pub struct AsyncResultLenWithoutIsEmpty;
+impl AsyncResultLenWithoutIsEmpty {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> Result<usize, ()> {
+        Err(())
+    }
+}
+
+// issue #7232
+pub struct AsyncOptionLen;
+impl AsyncOptionLen {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> Result<usize, ()> {
+        Err(())
+    }
+
+    pub async fn is_empty(&self) -> bool {
+        true
+    }
+}
+
+pub struct AsyncLenSyncIsEmpty;
+impl AsyncLenSyncIsEmpty {
+    pub async fn len(&self) -> u32 {
+        0
+    }
+
+    pub fn is_empty(&self) -> bool {
+        true
+    }
+}
+
 // issue #9520
 pub struct NonStandardLenAndIsEmptySignature;
 impl NonStandardLenAndIsEmptySignature {

tests/ui/len_without_is_empty.stderr

@@ -119,5 +119,23 @@ LL |     pub fn len(&self) -> Result<usize, ()> {
    |
    = help: use a custom `Error` type instead
 
-error: aborting due to 12 previous errors
+error: struct `AsyncLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:292:5
+   |
+LL |     pub async fn len(&self) -> usize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: struct `AsyncOptionLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:304:5
+   |
+LL |     pub async fn len(&self) -> Option<usize> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: struct `AsyncResultLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:316:5
+   |
+LL |     pub async fn len(&self) -> Result<usize, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 15 previous errors