impl<'a> Parser<'a> {         } else if inedible.contains(&self.token.kind) {             // leave it in the input             Ok(false)+        } else if self.token.kind == token::Eof {+            self.expected_one_of_not_found(edible, inedible)         } else if self.last_unexpected_token_span == Some(self.token.span) {

+use rustc_hir::{Arm, Expr, ExprKind, Node};+use rustc_span::sym;++use crate::{+    lints::{DropCopyDiag, DropRefDiag, ForgetCopyDiag, ForgetRefDiag},+    LateContext, LateLintPass, LintContext,+};++declare_lint! {+    /// The `drop_ref` lint checks for calls to `std::mem::drop` with a reference+    /// instead of an owned value.+    ///+    /// ### Example+    ///+    /// ```rust+    /// # fn operation_that_requires_mutex_to_be_unlocked() {} // just to make it compile+    /// # let mutex = std::sync::Mutex::new(1); // just to make it compile+    /// let mut lock_guard = mutex.lock();+    /// std::mem::drop(&lock_guard); // Should have been drop(lock_guard), mutex+    /// // still locked+    /// operation_that_requires_mutex_to_be_unlocked();+    /// ```+    ///+    /// {{produces}}+    ///+    /// ### Explanation+    ///+    /// Calling `drop` on a reference will only drop the+    /// reference itself, which is a no-op. It will not call the `drop` method (from+    /// the `Drop` trait implementation) on the underlying referenced value, which+    /// is likely what was intended.+    pub DROP_REF,+    Warn,+    "calls to `std::mem::drop` with a reference instead of an owned value"+}++declare_lint! {+    /// The `forget_ref` lint checks for calls to `std::mem::forget` with a reference+    /// instead of an owned value.+    ///+    /// ### Example+    ///+    /// ```rust+    /// let x = Box::new(1);+    /// std::mem::forget(&x); // Should have been forget(x), x will still be dropped+    /// ```+    ///+    /// {{produces}}+    ///+    /// ### Explanation+    ///+    /// Calling `forget` on a reference will only forget the+    /// reference itself, which is a no-op. It will not forget the underlying+    /// referenced value, which is likely what was intended.+    pub FORGET_REF,+    Warn,+    "calls to `std::mem::forget` with a reference instead of an owned value"+}++declare_lint! {+    /// The `drop_copy` lint checks for calls to `std::mem::drop` with a value+    /// that derives the Copy trait.+    ///+    /// ### Example+    ///+    /// ```rust+    /// let x: i32 = 42; // i32 implements Copy+    /// std::mem::drop(x); // A copy of x is passed to the function, leaving the+    ///                    // original unaffected+    /// ```+    ///+    /// {{produces}}+    ///+    /// ### Explanation+    ///+    /// Calling `std::mem::drop` [does nothing for types that+    /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the+    /// value will be copied and moved into the function on invocation.+    pub DROP_COPY,+    Warn,+    "calls to `std::mem::drop` with a value that implements Copy"+}++declare_lint! {+    /// The `forget_copy` lint checks for calls to `std::mem::forget` with a value+    /// that derives the Copy trait.+    ///+    /// ### Example+    ///+    /// ```rust+    /// let x: i32 = 42; // i32 implements Copy+    /// std::mem::forget(x); // A copy of x is passed to the function, leaving the+    ///                      // original unaffected+    /// ```+    ///+    /// {{produces}}+    ///+    /// ### Explanation+    ///+    /// Calling `std::mem::forget` [does nothing for types that+    /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the+    /// value will be copied and moved into the function on invocation.+    ///+    /// An alternative, but also valid, explanation is that Copy types do not+    /// implement the Drop trait, which means they have no destructors. Without a+    /// destructor, there is nothing for `std::mem::forget` to ignore.+    pub FORGET_COPY,+    Warn,+    "calls to `std::mem::forget` with a value that implements Copy"+}++declare_lint_pass!(DropForgetUseless => [DROP_REF, FORGET_REF, DROP_COPY, FORGET_COPY]);++impl<'tcx> LateLintPass<'tcx> for DropForgetUseless {+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {+        if let ExprKind::Call(path, [arg]) = expr.kind+            && let ExprKind::Path(ref qpath) = path.kind+            && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()+            && let Some(fn_name) = cx.tcx.get_diagnostic_name(def_id)+        {+            let arg_ty = cx.typeck_results().expr_ty(arg);+            let is_copy = arg_ty.is_copy_modulo_regions(cx.tcx, cx.param_env);+            let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr);+            match fn_name {+                sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => {+                    cx.emit_spanned_lint(DROP_REF, expr.span, DropRefDiag { arg_ty, label: arg.span });+                },+                sym::mem_forget if arg_ty.is_ref() => {+                    cx.emit_spanned_lint(FORGET_REF, expr.span, ForgetRefDiag { arg_ty, label: arg.span });+                },+                sym::mem_drop if is_copy && !drop_is_single_call_in_arm => {+                    cx.emit_spanned_lint(DROP_COPY, expr.span, DropCopyDiag { arg_ty, label: arg.span });+                }+                sym::mem_forget if is_copy => {+                    cx.emit_spanned_lint(FORGET_COPY, expr.span, ForgetCopyDiag { arg_ty, label: arg.span });+                }+                _ => return,+            };+        }+    }+}++// dropping returned value of a function like in the following snippet is considered idiomatic, see+// clippy#9482 for examples match <var> {+//     <pat> => drop(fn_with_side_effect_and_returning_some_value()),+//     ..+// }

 pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static         _ => elf::ELFOSABI_NONE,     };     let abi_version = 0;+    // check bti protection+    let mut check_cfprotection = false;+    let mut pr_type: u32 = 0;+    if architecture == Architecture::X86_64+        && matches!(+            sess.opts.unstable_opts.cf_protection,+            rustc_session::config::CFProtection::Branch | rustc_session::config::CFProtection::Full+        )+    {+        check_cfprotection = true;+        pr_type = 0xc0000002;+    }+    if architecture == Architecture::Aarch64 && sess.opts.unstable_opts.branch_protection.is_some()+    {+        check_cfprotection = true;+        pr_type = 0xc0000000;+    }+    if check_cfprotection && binary_format == BinaryFormat::Elf {+        let segment: Vec<u8> = file.segment_name(StandardSegment::Data).to_vec();+        let name: Vec<u8> = b".note.gnu.property".to_vec();+        let kind = SectionKind::Note;+        let section = file.add_section(segment, name, kind);+        let mut data: Vec<u8> = Vec::new();+        let n_namsz: u32 = 4; // Size of the n_name field+        let n_descsz: u32 = 16; // Size of the n_desc field+        let n_type: u32 = NT_GNU_PROPERTY_TYPE_0; // Type of note descriptor+        let values = [n_namsz, n_descsz, n_type];+        values.map(|v| data.extend_from_slice(&(v.to_ne_bytes())));+        data.push(b'G'); // Owner of the program property note+        data.push(b'N');+        data.push(b'U');+        data.push(0);+        let pr_datasz: u32 = 4; //size of the pr_data field

 pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static         _ => elf::ELFOSABI_NONE,     };     let abi_version = 0;+    // check bti protection+    let mut check_cfprotection = false;+    let mut pr_type: u32 = 0;+    if architecture == Architecture::X86_64+        && matches!(+            sess.opts.unstable_opts.cf_protection,+            rustc_session::config::CFProtection::Branch | rustc_session::config::CFProtection::Full+        )+    {+        check_cfprotection = true;+        pr_type = 0xc0000002;+    }+    if architecture == Architecture::Aarch64 && sess.opts.unstable_opts.branch_protection.is_some()+    {+        check_cfprotection = true;+        pr_type = 0xc0000000;+    }+    if check_cfprotection && binary_format == BinaryFormat::Elf {+        let segment: Vec<u8> = file.segment_name(StandardSegment::Data).to_vec();+        let name: Vec<u8> = b".note.gnu.property".to_vec();+        let kind = SectionKind::Note;+        let section = file.add_section(segment, name, kind);+        let mut data: Vec<u8> = Vec::new();+        let n_namsz: u32 = 4; // Size of the n_name field+        let n_descsz: u32 = 16; // Size of the n_desc field+        let n_type: u32 = NT_GNU_PROPERTY_TYPE_0; // Type of note descriptor+        let values = [n_namsz, n_descsz, n_type];+        values.map(|v| data.extend_from_slice(&(v.to_ne_bytes())));+        data.push(b'G'); // Owner of the program property note+        data.push(b'N');+        data.push(b'U');+        data.push(0);+        let pr_datasz: u32 = 4; //size of the pr_data field+        let pr_data: u32 = 3; //program property descriptor+        let pr_padding: u32 = 3;+        let values = [pr_type, pr_datasz, pr_data, pr_padding];+        values.map(|v| data.extend_from_slice(&(v.to_ne_bytes())));+        let x = data.len();+        assert_eq!(x, 32);+        let align = 4;+        file.append_section_data(section, &data, align);+    }

 pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static         _ => elf::ELFOSABI_NONE,     };     let abi_version = 0;+    // check bti protection+    let mut check_cfprotection = false;+    let mut pr_type: u32 = 0;+    if architecture == Architecture::X86_64+        && matches!(+            sess.opts.unstable_opts.cf_protection,+            rustc_session::config::CFProtection::Branch | rustc_session::config::CFProtection::Full+        )+    {+        check_cfprotection = true;+        pr_type = 0xc0000002;+    }+    if architecture == Architecture::Aarch64 && sess.opts.unstable_opts.branch_protection.is_some()+    {+        check_cfprotection = true;+        pr_type = 0xc0000000;+    }+    if check_cfprotection && binary_format == BinaryFormat::Elf {+        let segment: Vec<u8> = file.segment_name(StandardSegment::Data).to_vec();+        let name: Vec<u8> = b".note.gnu.property".to_vec();+        let kind = SectionKind::Note;+        let section = file.add_section(segment, name, kind);+        let mut data: Vec<u8> = Vec::new();+        let n_namsz: u32 = 4; // Size of the n_name field+        let n_descsz: u32 = 16; // Size of the n_desc field+        let n_type: u32 = NT_GNU_PROPERTY_TYPE_0; // Type of note descriptor+        let values = [n_namsz, n_descsz, n_type];+        values.map(|v| data.extend_from_slice(&(v.to_ne_bytes())));+        data.push(b'G'); // Owner of the program property note+        data.push(b'N');+        data.push(b'U');+        data.push(0);+        let pr_datasz: u32 = 4; //size of the pr_data field+        let pr_data: u32 = 3; //program property descriptor