Repository: rust-lang/rust-analyzer
Pull request #16000 (2023-12-01 12:24:22)

Initial support for implicit drop inlay hint
cc #15785


Patch:
diff --git a/crates/hir-def/src/item_tree.rs b/crates/hir-def/src/item_tree.rs
index 473ae298c7..70b96b2573 100644
--- a/crates/hir-def/src/item_tree.rs
+++ b/crates/hir-def/src/item_tree.rs
@@ -38,6 +38,7 @@ mod tests;
 use std::{
     fmt::{self, Debug},
     hash::{Hash, Hasher},
+    marker::PhantomData,
     ops::Index,
 };
 
@@ -339,37 +340,34 @@ pub trait ItemTreeNode: Clone {
     fn id_to_mod_item(id: FileItemTreeId<Self>) -> ModItem;
 }
 
-pub struct FileItemTreeId<N: ItemTreeNode>(Idx<N>);
-
-impl<N: ItemTreeNode> FileItemTreeId<N> {
-    pub fn index(&self) -> Idx<N> {
-        self.0
-    }
+pub struct FileItemTreeId<N: ItemTreeNode> {
+    index: Idx<N>,
+    _p: PhantomData<N>,
 }
 
 impl<N: ItemTreeNode> Clone for FileItemTreeId<N> {
     fn clone(&self) -> Self {
-        Self(self.0)
+        Self { index: self.index, _p: PhantomData }
     }
 }
 impl<N: ItemTreeNode> Copy for FileItemTreeId<N> {}
 
 impl<N: ItemTreeNode> PartialEq for FileItemTreeId<N> {
     fn eq(&self, other: &FileItemTreeId<N>) -> bool {
-        self.0 == other.0
+        self.index == other.index
     }
 }
 impl<N: ItemTreeNode> Eq for FileItemTreeId<N> {}
 
 impl<N: ItemTreeNode> Hash for FileItemTreeId<N> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.hash(state)
+        self.index.hash(state)
     }
 }
 
 impl<N: ItemTreeNode> fmt::Debug for FileItemTreeId<N> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
+        self.index.fmt(f)
     }
 }
 
@@ -550,7 +548,7 @@ impl Index<RawVisibilityId> for ItemTree {
 impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
     type Output = N;
     fn index(&self, id: FileItemTreeId<N>) -> &N {
-        N::lookup(self, id.index())
+        N::lookup(self, id.index)
     }
 }
 
@@ -927,23 +925,23 @@ impl ModItem {
 
     pub fn ast_id(&self, tree: &ItemTree) -> FileAstId<ast::Item> {
         match self {
-            ModItem::Use(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::ExternCrate(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::ExternBlock(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Function(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Struct(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Union(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Enum(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Const(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Static(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Trait(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::TraitAlias(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Impl(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::TypeAlias(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::Mod(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::MacroCall(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::MacroRules(it) => tree[it.index()].ast_id().upcast(),
-            ModItem::MacroDef(it) => tree[it.index()].ast_id().upcast(),
+            ModItem::Use(it) => tree[it.index].ast_id().upcast(),
+            ModItem::ExternCrate(it) => tree[it.index].ast_id().upcast(),
+            ModItem::ExternBlock(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Function(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Struct(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Union(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Enum(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Const(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Static(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Trait(it) => tree[it.index].ast_id().upcast(),
+            ModItem::TraitAlias(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Impl(it) => tree[it.index].ast_id().upcast(),
+            ModItem::TypeAlias(it) => tree[it.index].ast_id().upcast(),
+            ModItem::Mod(it) => tree[it.index].ast_id().upcast(),
+            ModItem::MacroCall(it) => tree[it.index].ast_id().upcast(),
+            ModItem::MacroRules(it) => tree[it.index].ast_id().upcast(),
+            ModItem::MacroDef(it) => tree[it.index].ast_id().upcast(),
         }
     }
 }
diff --git a/crates/hir-def/src/item_tree/lower.rs b/crates/hir-def/src/item_tree/lower.rs
index 6807326be5..c898eb5f92 100644
--- a/crates/hir-def/src/item_tree/lower.rs
+++ b/crates/hir-def/src/item_tree/lower.rs
@@ -13,7 +13,7 @@ use crate::{
 use super::*;
 
 fn id<N: ItemTreeNode>(index: Idx<N>) -> FileItemTreeId<N> {
-    FileItemTreeId(index)
+    FileItemTreeId { index, _p: PhantomData }
 }
 
 pub(super) struct Ctx<'a> {
diff --git a/crates/hir-ty/src/mir.rs b/crates/hir-ty/src/mir.rs
index 747ca54858..2e6fe59d3b 100644
--- a/crates/hir-ty/src/mir.rs
+++ b/crates/hir-ty/src/mir.rs
@@ -269,6 +269,10 @@ impl ProjectionStore {
 impl ProjectionId {
     pub const EMPTY: ProjectionId = ProjectionId(0);
 
+    pub fn is_empty(self) -> bool {
+        self == ProjectionId::EMPTY
+    }
+
     pub fn lookup(self, store: &ProjectionStore) -> &[PlaceElem] {
         store.id_to_proj.get(&self).unwrap()
     }
@@ -1069,6 +1073,10 @@ pub struct MirBody {
 }
 
 impl MirBody {
+    pub fn local_to_binding_map(&self) -> ArenaMap<LocalId, BindingId> {
+        self.binding_locals.iter().map(|(it, y)| (*y, it)).collect()
+    }
+
     fn walk_places(&mut self, mut f: impl FnMut(&mut Place, &mut ProjectionStore)) {
         fn for_operand(
             op: &mut Operand,
@@ -1188,3 +1196,9 @@ pub enum MirSpan {
 }
 
 impl_from!(ExprId, PatId for MirSpan);
+
+impl From<&ExprId> for MirSpan {
+    fn from(value: &ExprId) -> Self {
+        (*value).into()
+    }
+}
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index 9905d52214..922aee011c 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs
@@ -105,9 +105,14 @@ pub enum MirLowerError {
 /// A token to ensuring that each drop scope is popped at most once, thanks to the compiler that checks moves.
 struct DropScopeToken;
 impl DropScopeToken {
-    fn pop_and_drop(self, ctx: &mut MirLowerCtx<'_>, current: BasicBlockId) -> BasicBlockId {
+    fn pop_and_drop(
+        self,
+        ctx: &mut MirLowerCtx<'_>,
+        current: BasicBlockId,
+        span: MirSpan,
+    ) -> BasicBlockId {
         std::mem::forget(self);
-        ctx.pop_drop_scope_internal(current)
+        ctx.pop_drop_scope_internal(current, span)
     }
 
     /// It is useful when we want a drop scope is syntaxically closed, but we don't want to execute any drop
@@ -582,7 +587,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 self.lower_loop(current, place, *label, expr_id.into(), |this, begin| {
                     let scope = this.push_drop_scope();
                     if let Some((_, mut current)) = this.lower_expr_as_place(begin, *body, true)? {
-                        current = scope.pop_and_drop(this, current);
+                        current = scope.pop_and_drop(this, current, body.into());
                         this.set_goto(current, begin, expr_id.into());
                     } else {
                         scope.pop_assume_dropped(this);
@@ -720,7 +725,8 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         .ok_or(MirLowerError::ContinueWithoutLoop)?,
                 };
                 let begin = loop_data.begin;
-                current = self.drop_until_scope(loop_data.drop_scope_index, current);
+                current =
+                    self.drop_until_scope(loop_data.drop_scope_index, current, expr_id.into());
                 self.set_goto(current, begin, expr_id.into());
                 Ok(None)
             }
@@ -759,7 +765,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         self.current_loop_blocks.as_ref().unwrap().drop_scope_index,
                     ),
                 };
-                current = self.drop_until_scope(drop_scope, current);
+                current = self.drop_until_scope(drop_scope, current, expr_id.into());
                 self.set_goto(current, end, expr_id.into());
                 Ok(None)
             }
@@ -773,7 +779,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         return Ok(None);
                     }
                 }
-                current = self.drop_until_scope(0, current);
+                current = self.drop_until_scope(0, current, expr_id.into());
                 self.set_terminator(current, TerminatorKind::Return, expr_id.into());
                 Ok(None)
             }
@@ -1782,7 +1788,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         return Ok(None);
                     };
                     self.push_fake_read(c, p, expr.into());
-                    current = scope2.pop_and_drop(self, c);
+                    current = scope2.pop_and_drop(self, c, expr.into());
                 }
             }
         }
@@ -1793,7 +1799,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
             };
             current = c;
         }
-        current = scope.pop_and_drop(self, current);
+        current = scope.pop_and_drop(self, current, span);
         Ok(Some(current))
     }
 
@@ -1873,9 +1879,14 @@ impl<'ctx> MirLowerCtx<'ctx> {
         }
     }
 
-    fn drop_until_scope(&mut self, scope_index: usize, mut current: BasicBlockId) -> BasicBlockId {
+    fn drop_until_scope(
+        &mut self,
+        scope_index: usize,
+        mut current: BasicBlockId,
+        span: MirSpan,
+    ) -> BasicBlockId {
         for scope in self.drop_scopes[scope_index..].to_vec().iter().rev() {
-            self.emit_drop_and_storage_dead_for_scope(scope, &mut current);
+            self.emit_drop_and_storage_dead_for_scope(scope, &mut current, span);
         }
         current
     }
@@ -1891,17 +1902,22 @@ impl<'ctx> MirLowerCtx<'ctx> {
     }
 
     /// Don't call directly
-    fn pop_drop_scope_internal(&mut self, mut current: BasicBlockId) -> BasicBlockId {
+    fn pop_drop_scope_internal(
+        &mut self,
+        mut current: BasicBlockId,
+        span: MirSpan,
+    ) -> BasicBlockId {
         let scope = self.drop_scopes.pop().unwrap();
-        self.emit_drop_and_storage_dead_for_scope(&scope, &mut current);
+        self.emit_drop_and_storage_dead_for_scope(&scope, &mut current, span);
         current
     }
 
     fn pop_drop_scope_assert_finished(
         &mut self,
         mut current: BasicBlockId,
+        span: MirSpan,
     ) -> Result<BasicBlockId> {
-        current = self.pop_drop_scope_internal(current);
+        current = self.pop_drop_scope_internal(current, span);
         if !self.drop_scopes.is_empty() {
             implementation_error!("Mismatched count between drop scope push and pops");
         }
@@ -1912,6 +1928,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         &mut self,
         scope: &DropScope,
         current: &mut Idx<BasicBlock>,
+        span: MirSpan,
     ) {
         for &l in scope.locals.iter().rev() {
             if !self.result.locals[l].ty.clone().is_copy(self.db, self.owner) {
@@ -1919,13 +1936,10 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 self.set_terminator(
                     prev,
                     TerminatorKind::Drop { place: l.into(), target: *current, unwind: None },
-                    MirSpan::Unknown,
+                    span,
                 );
             }
-            self.push_statement(
-                *current,
-                StatementKind::StorageDead(l).with_span(MirSpan::Unknown),
-            );
+            self.push_statement(*current, StatementKind::StorageDead(l).with_span(span));
         }
     }
 }
@@ -2002,7 +2016,7 @@ pub fn mir_body_for_closure_query(
         |_| true,
     )?;
     if let Some(current) = ctx.lower_expr_to_place(*root, return_slot().into(), current)? {
-        let current = ctx.pop_drop_scope_assert_finished(current)?;
+        let current = ctx.pop_drop_scope_assert_finished(current, root.into())?;
         ctx.set_terminator(current, TerminatorKind::Return, (*root).into());
     }
     let mut upvar_map: FxHashMap<LocalId, Vec<(&CapturedItem, usize)>> = FxHashMap::default();
@@ -2146,7 +2160,7 @@ pub fn lower_to_mir(
         ctx.lower_params_and_bindings([].into_iter(), binding_picker)?
     };
     if let Some(current) = ctx.lower_expr_to_place(root_expr, return_slot().into(), current)? {
-        let current = ctx.pop_drop_scope_assert_finished(current)?;
+        let current = ctx.pop_drop_scope_assert_finished(current, root_expr.into())?;
         ctx.set_terminator(current, TerminatorKind::Return, root_expr.into());
     }
     Ok(ctx.result)
diff --git a/crates/hir-ty/src/mir/pretty.rs b/crates/hir-ty/src/mir/pretty.rs
index 6e42bee97f..a91f90bc24 100644
--- a/crates/hir-ty/src/mir/pretty.rs
+++ b/crates/hir-ty/src/mir/pretty.rs
@@ -145,7 +145,7 @@ impl<'a> MirPrettyCtx<'a> {
         let indent = mem::take(&mut self.indent);
         let mut ctx = MirPrettyCtx {
             body: &body,
-            local_to_binding: body.binding_locals.iter().map(|(it, y)| (*y, it)).collect(),
+            local_to_binding: body.local_to_binding_map(),
             result,
             indent,
             ..*self
@@ -167,7 +167,7 @@ impl<'a> MirPrettyCtx<'a> {
     }
 
     fn new(body: &'a MirBody, hir_body: &'a Body, db: &'a dyn HirDatabase) -> Self {
-        let local_to_binding = body.binding_locals.iter().map(|(it, y)| (*y, it)).collect();
+        let local_to_binding = body.local_to_binding_map();
         MirPrettyCtx {
             body,
             db,
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 920c88ccfb..908027a202 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -67,7 +67,7 @@ use hir_ty::{
     known_const_to_ast,
     layout::{Layout as TyLayout, RustcEnumVariantIdx, RustcFieldIdx, TagEncoding},
     method_resolution::{self, TyFingerprint},
-    mir::{self, interpret_mir},
+    mir::interpret_mir,
     primitive::UintTy,
     traits::FnTrait,
     AliasTy, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast, ClosureId, GenericArg,
@@ -129,9 +129,10 @@ pub use {
     hir_ty::{
         display::{ClosureStyle, HirDisplay, HirDisplayError, HirWrite},
         layout::LayoutError,
-        mir::MirEvalError,
         PointerCast, Safety,
     },
+    // FIXME: Properly encapsulate mir
+    hir_ty::{mir, Interner as ChalkTyInterner},
 };
 
 // These are negative re-exports: pub using these names is forbidden, they
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 24f44ca06f..7ea9d4f103 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -31,6 +31,7 @@ mod discriminant;
 mod fn_lifetime_fn;
 mod implicit_static;
 mod param_name;
+mod implicit_drop;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct InlayHintsConfig {
@@ -45,6 +46,7 @@ pub struct InlayHintsConfig {
     pub closure_return_type_hints: ClosureReturnTypeHints,
     pub closure_capture_hints: bool,
     pub binding_mode_hints: bool,
+    pub implicit_drop_hints: bool,
     pub lifetime_elision_hints: LifetimeElisionHints,
     pub param_names_for_lifetime_elision_hints: bool,
     pub hide_named_constructor_hints: bool,
@@ -124,6 +126,7 @@ pub enum InlayKind {
     Lifetime,
     Parameter,
     Type,
+    Drop,
 }
 
 #[derive(Debug)]
@@ -503,7 +506,10 @@ fn hints(
             ast::Item(it) => match it {
                 // FIXME: record impl lifetimes so they aren't being reused in assoc item lifetime inlay hints
                 ast::Item::Impl(_) => None,
-                ast::Item::Fn(it) => fn_lifetime_fn::hints(hints, config, it),
+                ast::Item::Fn(it) => {
+                    implicit_drop::hints(hints, sema, config, &it);
+                    fn_lifetime_fn::hints(hints, config, it)
+                },
                 // static type elisions
                 ast::Item::Static(it) => implicit_static::hints(hints, config, Either::Left(it)),
                 ast::Item::Const(it) => implicit_static::hints(hints, config, Either::Right(it)),
@@ -591,6 +597,7 @@ mod tests {
         max_length: None,
         closing_brace_hints_min_lines: None,
         fields_to_resolve: InlayFieldsToResolve::empty(),
+        implicit_drop_hints: false,
     };
     pub(super) const TEST_CONFIG: InlayHintsConfig = InlayHintsConfig {
         type_hints: true,
diff --git a/crates/ide/src/inlay_hints/implicit_drop.rs b/crates/ide/src/inlay_hints/implicit_drop.rs
new file mode 100644
index 0000000000..60f1f3496f
--- /dev/null
+++ b/crates/ide/src/inlay_hints/implicit_drop.rs
@@ -0,0 +1,204 @@
+//! Implementation of "implicit drop" inlay hints:
+//! ```no_run
+//! fn main() {
+//!     let x = vec![2];
+//!     if some_condition() {
+//!         /* drop(x) */return;
+//!     }
+//! }
+//! ```
+use hir::{
+    db::{DefDatabase as _, HirDatabase as _},
+    mir::{MirSpan, TerminatorKind},
+    ChalkTyInterner, DefWithBody, Semantics,
+};
+use ide_db::{base_db::FileRange, RootDatabase};
+
+use syntax::{
+    ast::{self, AstNode},
+    match_ast,
+};
+
+use crate::{InlayHint, InlayHintLabel, InlayHintPosition, InlayHintsConfig, InlayKind};
+
+pub(super) fn hints(
+    acc: &mut Vec<InlayHint>,
+    sema: &Semantics<'_, RootDatabase>,
+    config: &InlayHintsConfig,
+    def: &ast::Fn,
+) -> Option<()> {
+    if !config.implicit_drop_hints {
+        return None;
+    }
+
+    let def = sema.to_def(def)?;
+    let def: DefWithBody = def.into();
+
+    let source_map = sema.db.body_with_source_map(def.into()).1;
+
+    let hir = sema.db.body(def.into());
+    let mir = sema.db.mir_body(def.into()).ok()?;
+
+    let local_to_binding = mir.local_to_binding_map();
+
+    for (_, bb) in mir.basic_blocks.iter() {
+        let terminator = bb.terminator.as_ref()?;
+        if let TerminatorKind::Drop { place, .. } = terminator.kind {
+            if !place.projection.is_empty() {
+                continue; // Ignore complex cases for now
+            }
+            if mir.locals[place.local].ty.adt_id(ChalkTyInterner).is_none() {
+                continue; // Arguably only ADTs have significant drop impls
+            }
+            let Some(binding) = local_to_binding.get(place.local) else {
+                continue; // Ignore temporary values
+            };
+            let range = match terminator.span {
+                MirSpan::ExprId(e) => match source_map.expr_syntax(e) {
+                    Ok(s) => {
+                        let root = &s.file_syntax(sema.db);
+                        let expr = s.value.to_node(root);
+                        let expr = expr.syntax();
+                        match_ast! {
+                            match expr {
+                                ast::BlockExpr(x) => x.stmt_list().and_then(|x| x.r_curly_token()).map(|x| x.text_range()).unwrap_or_else(|| expr.text_range()),
+                                _ => expr.text_range(),
+                            }
+                        }
+                    }
+                    Err(_) => continue,
+                },
+                MirSpan::PatId(p) => match source_map.pat_syntax(p) {
+                    Ok(s) => s.value.text_range(),
+                    Err(_) => continue,
+                },
+                MirSpan::Unknown => continue,
+            };
+            let binding = &hir.bindings[*binding];
+            let binding_source = binding
+                .definitions
+                .first()
+                .and_then(|d| source_map.pat_syntax(*d).ok())
+                .and_then(|d| {
+                    Some(FileRange { file_id: d.file_id.file_id()?, range: d.value.text_range() })
+                });
+            let name = binding.name.to_smol_str();
+            if name.starts_with("<ra@") {
+                continue; // Ignore desugared variables
+            }
+            let mut label = InlayHintLabel::simple(
+                name,
+                Some(crate::InlayTooltip::String("moz".into())),
+                binding_source,
+            );
+            label.prepend_str("drop(");
+            label.append_str(")");
+            acc.push(InlayHint {
+                range,
+                position: InlayHintPosition::Before,
+                pad_left: true,
+                pad_right: true,
+                kind: InlayKind::Drop,
+                needs_resolve: label.needs_resolve(),
+                label,
+                text_edit: None,
+            })
+        }
+    }
+
+    Some(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        inlay_hints::tests::{check_with_config, DISABLED_CONFIG},
+        InlayHintsConfig,
+    };
+
+    const ONLY_DROP_CONFIG: InlayHintsConfig =
+        InlayHintsConfig { implicit_drop_hints: true, ..DISABLED_CONFIG };
+
+    #[test]
+    fn basic() {
+        check_with_config(
+            ONLY_DROP_CONFIG,
+            r#"
+    struct X;
+    fn f() {
+        let x = X;
+        if 2 == 5 {
+            return;
+          //^^^^^^ drop(x)
+        }
+    }
+  //^ drop(x)
+"#,
+        );
+    }
+
+    #[test]
+    fn no_hint_for_copy_types_and_mutable_references() {
+        // `T: Copy` and `T = &mut U` types do nothing on drop, so we should hide drop inlay hint for them.
+        check_with_config(
+            ONLY_DROP_CONFIG,
+            r#"
+//- minicore: copy, derive
+
+    struct X(i32, i32);
+    #[derive(Clone, Copy)]
+    struct Y(i32, i32);
+    fn f() {
+        let a = 2;
+        let b = a + 4;
+        let mut x = X(a, b);
+        let mut y = Y(a, b);
+        let mx = &mut x;
+        let my = &mut y;
+        let c = a + b;
+    }
+  //^ drop(x)
+"#,
+        );
+    }
+
+    #[test]
+    fn try_operator() {
+        // We currently show drop inlay hint for every `?` operator that may potentialy drop something. We probably need to
+        // make it configurable as it doesn't seem very useful.
+        check_with_config(
+            ONLY_DROP_CONFIG,
+            r#"
+//- minicore: copy, try, option
+
+    struct X;
+    fn f() -> Option<()> {
+        let x = X;
+        let t_opt = Some(2);
+        let t = t_opt?;
+              //^^^^^^ drop(x)
+        Some(())
+    }
+  //^ drop(x)
+"#,
+        );
+    }
+
+    #[test]
+    fn if_let() {
+        check_with_config(
+            ONLY_DROP_CONFIG,
+            r#"
+    struct X;
+    fn f() {
+        let x = X;
+        if let X = x {
+            let y = X;
+        }
+      //^ drop(y)
+    }
+  //^ drop(x)
+"#,
+        );
+    }
+}
diff --git a/crates/ide/src/static_index.rs b/crates/ide/src/static_index.rs
index aabd26da28..b54874d59f 100644
--- a/crates/ide/src/static_index.rs
+++ b/crates/ide/src/static_index.rs
@@ -118,6 +118,7 @@ impl StaticIndex<'_> {
                     adjustment_hints: crate::AdjustmentHints::Never,
                     adjustment_hints_mode: AdjustmentHintsMode::Prefix,
                     adjustment_hints_hide_outside_unsafe: false,
+                    implicit_drop_hints: false,
                     hide_named_constructor_hints: false,
                     hide_closure_initialization_hints: false,
                     closure_style: hir::ClosureStyle::ImplFn,
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 19da297b58..6a2a9adce1 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -376,16 +376,6 @@ fn error_block(p: &mut Parser<'_>, message: &str) {
     m.complete(p, ERROR);
 }
 
-// test_err top_level_let
-// let ref foo: fn() = 1 + 3;
-fn error_let_stmt(p: &mut Parser<'_>, message: &str) {
-    assert!(p.at(T![let]));
-    let m = p.start();
-    p.error(message);
-    expressions::let_stmt(p, expressions::Semicolon::Optional);
-    m.complete(p, ERROR);
-}
-
 /// The `parser` passed this is required to at least consume one token if it returns `true`.
 /// If the `parser` returns false, parsing will stop.
 fn delimited(
diff --git a/crates/parser/src/grammar/expressions.rs b/crates/parser/src/grammar/expressions.rs
index e346ece2f9..1cbd166323 100644
--- a/crates/parser/src/grammar/expressions.rs
+++ b/crates/parser/src/grammar/expressions.rs
@@ -59,8 +59,7 @@ pub(super) fn stmt(p: &mut Parser<'_>, semicolon: Semicolon) {
     attributes::outer_attrs(p);
 
     if p.at(T![let]) {
-        let_stmt(p, semicolon);
-        m.complete(p, LET_STMT);
+        let_stmt(p, m, semicolon);
         return;
     }
 
@@ -110,53 +109,54 @@ pub(super) fn stmt(p: &mut Parser<'_>, semicolon: Semicolon) {
             m.complete(p, EXPR_STMT);
         }
     }
-}
 
-// test let_stmt
-// fn f() { let x: i32 = 92; }
-pub(super) fn let_stmt(p: &mut Parser<'_>, with_semi: Semicolon) {
-    p.bump(T![let]);
-    patterns::pattern(p);
-    if p.at(T![:]) {
-        // test let_stmt_ascription
-        // fn f() { let x: i32; }
-        types::ascription(p);
-    }
-
-    let mut expr_after_eq: Option<CompletedMarker> = None;
-    if p.eat(T![=]) {
-        // test let_stmt_init
-        // fn f() { let x = 92; }
-        expr_after_eq = expressions::expr(p);
-    }
+    // test let_stmt
+    // fn f() { let x: i32 = 92; }
+    fn let_stmt(p: &mut Parser<'_>, m: Marker, with_semi: Semicolon) {
+        p.bump(T![let]);
+        patterns::pattern(p);
+        if p.at(T![:]) {
+            // test let_stmt_ascription
+            // fn f() { let x: i32; }
+            types::ascription(p);
+        }
 
-    if p.at(T![else]) {
-        // test_err let_else_right_curly_brace
-        // fn func() { let Some(_) = {Some(1)} else { panic!("h") };}
-        if let Some(expr) = expr_after_eq {
-            if BlockLike::is_blocklike(expr.kind()) {
-                p.error(
-                    "right curly brace `}` before `else` in a `let...else` statement not allowed",
-                )
-            }
+        let mut expr_after_eq: Option<CompletedMarker> = None;
+        if p.eat(T![=]) {
+            // test let_stmt_init
+            // fn f() { let x = 92; }
+            expr_after_eq = expressions::expr(p);
         }
 
-        // test let_else
-        // fn f() { let Some(x) = opt else { return }; }
-        let m = p.start();
-        p.bump(T![else]);
-        block_expr(p);
-        m.complete(p, LET_ELSE);
-    }
+        if p.at(T![else]) {
+            // test_err let_else_right_curly_brace
+            // fn func() { let Some(_) = {Some(1)} else { panic!("h") };}
+            if let Some(expr) = expr_after_eq {
+                if BlockLike::is_blocklike(expr.kind()) {
+                    p.error(
+                        "right curly brace `}` before `else` in a `let...else` statement not allowed",
+                    )
+                }
+            }
 
-    match with_semi {
-        Semicolon::Forbidden => (),
-        Semicolon::Optional => {
-            p.eat(T![;]);
+            // test let_else
+            // fn f() { let Some(x) = opt else { return }; }
+            let m = p.start();
+            p.bump(T![else]);
+            block_expr(p);
+            m.complete(p, LET_ELSE);
         }
-        Semicolon::Required => {
-            p.expect(T![;]);
+
+        match with_semi {
+            Semicolon::Forbidden => (),
+            Semicolon::Optional => {
+                p.eat(T![;]);
+            }
+            Semicolon::Required => {
+                p.expect(T![;]);
+            }
         }
+        m.complete(p, LET_STMT);
     }
 }
 
@@ -693,17 +693,6 @@ pub(crate) fn record_expr_field_list(p: &mut Parser<'_>) {
                 // We permit `.. }` on the left-hand side of a destructuring assignment.
                 if !p.at(T!['}']) {
                     expr(p);
-
-                    if p.at(T![,]) {
-                        // test_err comma_after_functional_update_syntax
-                        // fn foo() {
-                        //     S { ..x, };
-                        //     S { ..x, a: 0 }
-                        // }
-
-                        // Do not bump, so we can support additional fields after this comma.
-                        p.error("cannot use a comma after the base struct");
-                    }
                 }
             }
             T!['{'] => {
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs
index 34fd3420f1..4e850b1f74 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -79,7 +79,6 @@ pub(super) fn item_or_macro(p: &mut Parser<'_>, stop_on_r_curly: bool) {
             e.complete(p, ERROR);
         }
         EOF | T!['}'] => p.error("expected an item"),
-        T![let] => error_let_stmt(p, "expected an item"),
         _ => p.err_and_bump("expected an item"),
     }
 }
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 0f6539f224..b4debba38c 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -783,6 +783,7 @@ impl flags::AnalysisStats {
                     closure_return_type_hints: ide::ClosureReturnTypeHints::Always,
                     closure_capture_hints: true,
                     binding_mode_hints: true,
+                    implicit_drop_hints: true,
                     lifetime_elision_hints: ide::LifetimeElisionHints::Always,
                     param_names_for_lifetime_elision_hints: true,
                     hide_named_constructor_hints: false,
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index f28f6ffb87..90d1d6b055 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -381,6 +381,8 @@ config_data! {
         inlayHints_expressionAdjustmentHints_hideOutsideUnsafe: bool = "false",
         /// Whether to show inlay hints as postfix ops (`.*` instead of `*`, etc).
         inlayHints_expressionAdjustmentHints_mode: AdjustmentHintsModeDef = "\"prefix\"",
+        /// Whether to show implicit drop hints.
+        inlayHints_implicitDrops_enable: bool                      = "false",
         /// Whether to show inlay type hints for elided lifetimes in function signatures.
         inlayHints_lifetimeElisionHints_enable: LifetimeElisionDef = "\"never\"",
         /// Whether to prefer using parameter names as the name for elided lifetime hints if possible.
@@ -1391,6 +1393,7 @@ impl Config {
             type_hints: self.data.inlayHints_typeHints_enable,
             parameter_hints: self.data.inlayHints_parameterHints_enable,
             chaining_hints: self.data.inlayHints_chainingHints_enable,
+            implicit_drop_hints: self.data.inlayHints_implicitDrops_enable,
             discriminant_hints: match self.data.inlayHints_discriminantHints_enable {
                 DiscriminantHintsDef::Always => ide::DiscriminantHints::Always,
                 DiscriminantHintsDef::Never => ide::DiscriminantHints::Never,
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index 7091ea1ce9..8a2d080844 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -564,6 +564,11 @@ Whether to hide inlay hints for type adjustments outside of `unsafe` blocks.
 --
 Whether to show inlay hints as postfix ops (`.*` instead of `*`, etc).
 --
+[[rust-analyzer.inlayHints.implicitDrops.enable]]rust-analyzer.inlayHints.implicitDrops.enable (default: `false`)::
++
+--
+Whether to show implicit drop hints.
+--
 [[rust-analyzer.inlayHints.lifetimeElisionHints.enable]]rust-analyzer.inlayHints.lifetimeElisionHints.enable (default: `"never"`)::
 +
 --
diff --git a/editors/code/package.json b/editors/code/package.json
index c43f2b964f..cfaf421327 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1264,6 +1264,11 @@
                         "Show prefix or postfix depending on which uses less parenthesis, preferring postfix."
                     ]
                 },
+                "rust-analyzer.inlayHints.implicitDrops.enable": {
+                    "markdownDescription": "Whether to show implicit drop hints.",
+                    "default": false,
+                    "type": "boolean"
+                },
                 "rust-analyzer.inlayHints.lifetimeElisionHints.enable": {
                     "markdownDescription": "Whether to show inlay type hints for elided lifetimes in function signatures.",
                     "default": "never",
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index 06034e1648..e817d680ea 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -3,7 +3,7 @@ import * as vscode from "vscode";
 import * as path from "path";
 import type * as ra from "./lsp_ext";
 
-import { Cargo, type ExecutableInfo, getRustcId, getSysroot } from "./toolchain";
+import { Cargo, getRustcId, getSysroot } from "./toolchain";
 import type { Ctx } from "./ctx";
 import { prepareEnv } from "./run";
 import { unwrapUndefinable } from "./undefinable";
@@ -12,7 +12,6 @@ const debugOutput = vscode.window.createOutputChannel("Debug");
 type DebugConfigProvider = (
     config: ra.Runnable,
     executable: string,
-    cargoWorkspace: string,
     env: Record<string, string>,
     sourceFileMap?: Record<string, string>,
 ) => vscode.DebugConfiguration;
@@ -131,7 +130,7 @@ async function getDebugConfiguration(
     }
 
     const env = prepareEnv(runnable, ctx.config.runnablesExtraEnv);
-    const { executable, workspace: cargoWorkspace } = await getDebugExecutableInfo(runnable, env);
+    const executable = await getDebugExecutable(runnable, env);
     let sourceFileMap = debugOptions.sourceFileMap;
     if (sourceFileMap === "auto") {
         // let's try to use the default toolchain
@@ -143,13 +142,7 @@ async function getDebugConfiguration(
     }
 
     const provider = unwrapUndefinable(knownEngines[debugEngine.id]);
-    const debugConfig = provider(
-        runnable,
-        simplifyPath(executable),
-        cargoWorkspace,
-        env,
-        sourceFileMap,
-    );
+    const debugConfig = provider(runnable, simplifyPath(executable), env, sourceFileMap);
     if (debugConfig.type in debugOptions.engineSettings) {
         const settingsMap = (debugOptions.engineSettings as any)[debugConfig.type];
         for (var key in settingsMap) {
@@ -171,21 +164,20 @@ async function getDebugConfiguration(
     return debugConfig;
 }
 
-async function getDebugExecutableInfo(
+async function getDebugExecutable(
     runnable: ra.Runnable,
     env: Record<string, string>,
-): Promise<ExecutableInfo> {
+): Promise<string> {
     const cargo = new Cargo(runnable.args.workspaceRoot || ".", debugOutput, env);
-    const executableInfo = await cargo.executableInfoFromArgs(runnable.args.cargoArgs);
+    const executable = await cargo.executableFromArgs(runnable.args.cargoArgs);
 
     // if we are here, there were no compilation errors.
-    return executableInfo;
+    return executable;
 }
 
 function getLldbDebugConfig(
     runnable: ra.Runnable,
     executable: string,
-    cargoWorkspace: string,
     env: Record<string, string>,
     sourceFileMap?: Record<string, string>,
 ): vscode.DebugConfiguration {
@@ -195,7 +187,7 @@ function getLldbDebugConfig(
         name: runnable.label,
         program: executable,
         args: runnable.args.executableArgs,
-        cwd: cargoWorkspace || runnable.args.workspaceRoot,
+        cwd: runnable.args.workspaceRoot,
         sourceMap: sourceFileMap,
         sourceLanguages: ["rust"],
         env,
@@ -205,7 +197,6 @@ function getLldbDebugConfig(
 function getCppvsDebugConfig(
     runnable: ra.Runnable,
     executable: string,
-    cargoWorkspace: string,
     env: Record<string, string>,
     sourceFileMap?: Record<string, string>,
 ): vscode.DebugConfiguration {
@@ -215,7 +206,7 @@ function getCppvsDebugConfig(
         name: runnable.label,
         program: executable,
         args: runnable.args.executableArgs,
-        cwd: cargoWorkspace || runnable.args.workspaceRoot,
+        cwd: runnable.args.workspaceRoot,
         sourceFileMap,
         env,
     };
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 1037e513aa..58e5fc747a 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -9,17 +9,11 @@ import { unwrapUndefinable } from "./undefinable";
 
 interface CompilationArtifact {
     fileName: string;
-    workspace: string;
     name: string;
     kind: string;
     isTest: boolean;
 }
 
-export interface ExecutableInfo {
-    executable: string;
-    workspace: string;
-}
-
 export interface ArtifactSpec {
     cargoArgs: string[];
     filter?: (artifacts: CompilationArtifact[]) => CompilationArtifact[];
@@ -74,7 +68,6 @@ export class Cargo {
                             artifacts.push({
                                 fileName: message.executable,
                                 name: message.target.name,
-                                workspace: message.manifest_path.replace(/\/Cargo\.toml$/, ""),
                                 kind: message.target.kind[0],
                                 isTest: message.profile.test,
                             });
@@ -93,7 +86,7 @@ export class Cargo {
         return spec.filter?.(artifacts) ?? artifacts;
     }
 
-    async executableInfoFromArgs(args: readonly string[]): Promise<ExecutableInfo> {
+    async executableFromArgs(args: readonly string[]): Promise<string> {
         const artifacts = await this.getArtifacts(Cargo.artifactSpec(args));
 
         if (artifacts.length === 0) {
@@ -103,10 +96,7 @@ export class Cargo {
         }
 
         const artifact = unwrapUndefinable(artifacts[0]);
-        return {
-            executable: artifact.fileName,
-            workspace: artifact.workspace,
-        };
+        return artifact.fileName;
     }
 
     private async runCargo(


Test patch:
diff --git a/crates/parser/test_data/parser/inline/err/0024_comma_after_functional_update_syntax.rast b/crates/parser/test_data/parser/inline/err/0024_comma_after_functional_update_syntax.rast
deleted file mode 100644
index 0e2fe5988d..0000000000
--- a/crates/parser/test_data/parser/inline/err/0024_comma_after_functional_update_syntax.rast
+++ /dev/null
@@ -1,66 +0,0 @@
-SOURCE_FILE
-  FN
-    FN_KW "fn"
-    WHITESPACE " "
-    NAME
-      IDENT "foo"
-    PARAM_LIST
-      L_PAREN "("
-      R_PAREN ")"
-    WHITESPACE " "
-    BLOCK_EXPR
-      STMT_LIST
-        L_CURLY "{"
-        WHITESPACE "\n    "
-        EXPR_STMT
-          RECORD_EXPR
-            PATH
-              PATH_SEGMENT
-                NAME_REF
-                  IDENT "S"
-            WHITESPACE " "
-            RECORD_EXPR_FIELD_LIST
-              L_CURLY "{"
-              WHITESPACE " "
-              DOT2 ".."
-              PATH_EXPR
-                PATH
-                  PATH_SEGMENT
-                    NAME_REF
-                      IDENT "x"
-              COMMA ","
-              WHITESPACE " "
-              R_CURLY "}"
-          SEMICOLON ";"
-        WHITESPACE "\n    "
-        RECORD_EXPR
-          PATH
-            PATH_SEGMENT
-              NAME_REF
-                IDENT "S"
-          WHITESPACE " "
-          RECORD_EXPR_FIELD_LIST
-            L_CURLY "{"
-            WHITESPACE " "
-            DOT2 ".."
-            PATH_EXPR
-              PATH
-                PATH_SEGMENT
-                  NAME_REF
-                    IDENT "x"
-            COMMA ","
-            WHITESPACE " "
-            RECORD_EXPR_FIELD
-              NAME_REF
-                IDENT "a"
-              COLON ":"
-              WHITESPACE " "
-              LITERAL
-                INT_NUMBER "0"
-            WHITESPACE " "
-            R_CURLY "}"
-        WHITESPACE "\n"
-        R_CURLY "}"
-  WHITESPACE "\n"
-error 22: cannot use a comma after the base struct
-error 38: cannot use a comma after the base struct
diff --git a/crates/parser/test_data/parser/inline/err/0024_comma_after_functional_update_syntax.rs b/crates/parser/test_data/parser/inline/err/0024_comma_after_functional_update_syntax.rs
deleted file mode 100644
index 14cf96719b..0000000000
--- a/crates/parser/test_data/parser/inline/err/0024_comma_after_functional_update_syntax.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-fn foo() {
-    S { ..x, };
-    S { ..x, a: 0 }
-}
diff --git a/crates/parser/test_data/parser/inline/err/0024_top_level_let.rast b/crates/parser/test_data/parser/inline/err/0024_top_level_let.rast
deleted file mode 100644
index 5ddef5f3f0..0000000000
--- a/crates/parser/test_data/parser/inline/err/0024_top_level_let.rast
+++ /dev/null
@@ -1,30 +0,0 @@
-SOURCE_FILE
-  ERROR
-    LET_KW "let"
-    WHITESPACE " "
-    IDENT_PAT
-      REF_KW "ref"
-      WHITESPACE " "
-      NAME
-        IDENT "foo"
-    COLON ":"
-    WHITESPACE " "
-    FN_PTR_TYPE
-      FN_KW "fn"
-      PARAM_LIST
-        L_PAREN "("
-        R_PAREN ")"
-    WHITESPACE " "
-    EQ "="
-    WHITESPACE " "
-    BIN_EXPR
-      LITERAL
-        INT_NUMBER "1"
-      WHITESPACE " "
-      PLUS "+"
-      WHITESPACE " "
-      LITERAL
-        INT_NUMBER "3"
-    SEMICOLON ";"
-  WHITESPACE "\n"
-error 0: expected an item
diff --git a/crates/parser/test_data/parser/inline/err/0024_top_level_let.rs b/crates/parser/test_data/parser/inline/err/0024_top_level_let.rs
deleted file mode 100644
index 3d3e7dd56c..0000000000
--- a/crates/parser/test_data/parser/inline/err/0024_top_level_let.rs
+++ /dev/null
@@ -1,1 +0,0 @@
-let ref foo: fn() = 1 + 3;
diff --git a/crates/test-utils/src/minicore.rs b/crates/test-utils/src/minicore.rs
index f2ca9d82ed..ba5c86db0e 100644
--- a/crates/test-utils/src/minicore.rs
+++ b/crates/test-utils/src/minicore.rs
@@ -1054,6 +1054,10 @@ pub mod option {
         Some(T),
     }
 
+    // region:copy
+    impl<T: Copy> Copy for Option<T> {}
+    // endregion:copy
+
     impl<T> Option<T> {
         pub const fn unwrap(self) -> T {
             match self {