use clippy_utils::diagnostics::span_lint_and_then;

use clippy_utils::get_parent_as_impl;

use clippy_utils::source::snippet;

use clippy_utils::ty::{deref_chain, get_adt_inherent_method, implements_trait, make_normalized_projection};

use rustc_ast::Mutability;

use rustc_errors::Applicability;

use rustc_hir::{FnRetTy, ImplItemKind, ImplicitSelfKind, ItemKind, TyKind};

use rustc_lint::{LateContext, LateLintPass, LintContext};

use rustc_middle::ty::{self, Ty};

use rustc_session::declare_lint_pass;

use rustc_span::sym;

declare_clippy_lint! {

/// ### What it does

/// Looks for `iter` and `iter_mut` methods without an associated `IntoIterator for (&|&mut) Type` implementation.

///

/// ### Why is this bad?

/// It's not bad, but having them is idiomatic and allows the type to be used in for loops directly

/// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.

///

/// ### Limitations

/// This lint focuses on providing an idiomatic API. Therefore, it will only

/// lint on types which are accessible outside of the crate. For internal types,

/// the `IntoIterator` trait can be implemented on demand if it is actually needed.

///

/// ### Example

/// ```no_run

/// struct MySlice<'a>(&'a [u8]);

/// impl<'a> MySlice<'a> {

/// pub fn iter(&self) -> std::slice::Iter<'a, u8> {

/// self.0.iter()

/// }

/// }

/// ```

/// Use instead:

/// ```no_run

/// struct MySlice<'a>(&'a [u8]);

/// impl<'a> MySlice<'a> {

/// pub fn iter(&self) -> std::slice::Iter<'a, u8> {

/// self.0.iter()

/// }

/// }

/// impl<'a> IntoIterator for &MySlice<'a> {

/// type Item = &'a u8;

/// type IntoIter = std::slice::Iter<'a, u8>;

/// fn into_iter(self) -> Self::IntoIter {

/// self.iter()

/// }

/// }

/// ```

#[clippy::version = "1.75.0"]

pub ITER_WITHOUT_INTO_ITER,

pedantic,

"implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"

}

declare_clippy_lint! {

/// ### What it does

/// This is the opposite of the `iter_without_into_iter` lint.

/// It looks for `IntoIterator for (&|&mut) Type` implementations without an inherent `iter` or `iter_mut` method

/// on the type or on any of the types in its `Deref` chain.

///

/// ### Why is this bad?

/// It's not bad, but having them is idiomatic and allows the type to be used in iterator chains

/// by just calling `.iter()`, instead of the more awkward `<&Type>::into_iter` or `(&val).into_iter()` syntax

/// in case of ambiguity with another `IntoIterator` impl.

///

/// ### Limitations

/// This lint focuses on providing an idiomatic API. Therefore, it will only

/// lint on types which are accessible outside of the crate. For internal types,

/// these methods can be added on demand if they are actually needed. Otherwise,

/// it would trigger the [`dead_code`] lint for the unused method.

///

/// [`dead_code`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#dead-code

///

/// ### Example

/// ```no_run

/// struct MySlice<'a>(&'a [u8]);

/// impl<'a> IntoIterator for &MySlice<'a> {

/// type Item = &'a u8;

/// type IntoIter = std::slice::Iter<'a, u8>;

/// fn into_iter(self) -> Self::IntoIter {

/// self.0.iter()

/// }

/// }

/// ```

/// Use instead:

/// ```no_run

/// struct MySlice<'a>(&'a [u8]);

/// impl<'a> MySlice<'a> {

/// pub fn iter(&self) -> std::slice::Iter<'a, u8> {

/// self.into_iter()

/// }

/// }

/// impl<'a> IntoIterator for &MySlice<'a> {

/// type Item = &'a u8;

/// type IntoIter = std::slice::Iter<'a, u8>;

/// fn into_iter(self) -> Self::IntoIter {

/// self.0.iter()

/// }

/// }

/// ```

#[clippy::version = "1.75.0"]

pub INTO_ITER_WITHOUT_ITER,

pedantic,

"implementing `IntoIterator for (&|&mut) Type` without an inherent `iter(_mut)` method"

}

declare_lint_pass!(IterWithoutIntoIter => [ITER_WITHOUT_INTO_ITER, INTO_ITER_WITHOUT_ITER]);

/// Checks if a given type is nameable in a trait (impl).

/// RPIT is stable, but impl Trait in traits is not (yet), so when we have

/// a function such as `fn iter(&self) -> impl IntoIterator`, we can't

/// suggest `type IntoIter = impl IntoIterator`.

fn is_nameable_in_impl_trait(ty: &rustc_hir::Ty<'_>) -> bool {

!matches!(ty.kind, TyKind::OpaqueDef(..))

}

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

}

impl LateLintPass<'_> for IterWithoutIntoIter {

}