use clippy_utils::diagnostics::span_lint_and_then;

use clippy_utils::higher::VecArgs;

use clippy_utils::macros::root_macro_call_first_node;

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

use clippy_utils::{last_path_segment, sym};

use rustc_errors::Applicability;

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

use rustc_lint::{LateContext, LateLintPass};

use rustc_middle::ty;

use rustc_session::declare_lint_pass;

use rustc_span::{Span, Symbol};

declare_clippy_lint! {

/// ### What it does

/// Checks for reference-counted pointers (`Arc`, `Rc`, `rc::Weak`, and `sync::Weak`)

/// in `vec![elem; len]`

///

/// ### Why is this bad?

/// This will create `elem` once and clone it `len` times - doing so with `Arc`/`Rc`/`Weak`

/// is a bit misleading, as it will create references to the same pointer, rather

/// than different instances.

///

/// ### Example

/// ```no_run

/// let v = vec![std::sync::Arc::new("some data".to_string()); 100];

/// // or

/// let v = vec![std::rc::Rc::new("some data".to_string()); 100];

/// ```

/// Use instead:

/// ```no_run

/// // Initialize each value separately:

/// let mut data = Vec::with_capacity(100);

/// for _ in 0..100 {

/// data.push(std::rc::Rc::new("some data".to_string()));

/// }

///

/// // Or if you want clones of the same reference,

/// // Create the reference beforehand to clarify that

/// // it should be cloned for each value

/// let data = std::rc::Rc::new("some data".to_string());

/// let v = vec![data; 100];

/// ```

#[clippy::version = "1.63.0"]

pub RC_CLONE_IN_VEC_INIT,

suspicious,

"initializing reference-counted pointer in `vec![elem; len]`"

}

declare_lint_pass!(RcCloneInVecInit => [RC_CLONE_IN_VEC_INIT]);

impl LateLintPass<'_> for RcCloneInVecInit {

}

fn loop_init_suggestion(elem: &str, len: &str, indent: &str) -> String {

}

fn extract_suggestion(elem: &str, len: &str, indent: &str) -> String {

}

fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<'_>, len: &Expr<'_>, func_span: Span) {

}

/// Checks whether the given `expr` is a call to `Arc::new`, `Rc::new`, or evaluates to a `Weak`

fn ref_init(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(Symbol, Span)> {

}