use clippy_utils::ty::get_iterator_item_ty;

use hir::ExprKind;

use rustc_lint::{LateContext, LintContext};

use super::{ITER_FILTER_IS_OK, ITER_FILTER_IS_SOME};

use clippy_utils::diagnostics::span_lint_and_sugg;

use clippy_utils::source::{indent_of, reindent_multiline};

use clippy_utils::{get_parent_expr, is_trait_method, peel_blocks, span_contains_comment, sym};

use rustc_errors::Applicability;

use rustc_hir as hir;

use rustc_hir::QPath;

use rustc_span::Span;

use rustc_span::symbol::{Ident, Symbol};

///

/// Returns true if the expression is a method call to `method_name`

/// e.g. `a.method_name()` or `Option::method_name`.

///

/// The type-checker verifies for us that the method accepts the right kind of items

/// (e.g. `Option::is_some` accepts `Option<_>`), so we don't need to check that.

///

/// How to capture each case:

///

/// `.filter(|a| { std::option::Option::is_some(a) })`

/// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ <- this is a closure, getting unwrapped and

/// recursively checked.

/// `std::option::Option::is_some(a)`

/// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ <- this is a call. It unwraps to a path with

/// `QPath::TypeRelative`. Since this is a type relative path, we need to check the method name, the

/// type, and that the parameter of the closure is passed in the call. This part is the dual of

/// `receiver.method_name()` below.

///

/// `filter(std::option::Option::is_some);`

/// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ <- this is a type relative path, like above, we check the

/// type and the method name.

///

/// `filter(|a| a.is_some());`

/// ^^^^^^^^^^^^^^^ <- this is a method call inside a closure,

/// we check that the parameter of the closure is the receiver of the method call and don't allow

/// any other parameters.

fn is_method(

}

fn parent_is_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {

}

enum FilterType {

IsSome,

IsOk,

}

/// Returns the `FilterType` of the expression if it is a filter over an Iter<Option> or

/// Iter<Result> with the parent expression not being a map, and not having a comment in the span of

/// the filter. If it is not a filter over an Iter<Option> or Iter<Result> then it returns None

///

/// How this is done:

/// 1. we know that this is invoked in a method call with `filter` as the method name via `mod.rs`

/// 2. we check that we are in a trait method. Therefore we are in an `(x as

/// Iterator).filter({filter_arg})` method call.

/// 3. we check that the parent expression is not a map. This is because we don't want to lint

/// twice, and we already have a specialized lint for that.

/// 4. we check that the span of the filter does not contain a comment.

/// 5. we get the type of the `Item` in the `Iterator`, and compare against the type of Option and

/// Result.

/// 6. we finally check the contents of the filter argument to see if it is a call to `is_some` or

/// `is_ok`.

/// 7. if all of the above are true, then we return the `FilterType`

fn expression_type(

}

pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir::Expr<'_>, filter_span: Span) {

}