diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 97e070958751a..d10b098b6b920 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -1532,6 +1532,9 @@ impl Expr {
                 }
             }
 
+            ExprKind::InitBlock(..) => ExprPrecedence::Jump,
+            ExprKind::InitTail(..) => ExprPrecedence::Jump,
+
             ExprKind::Break(_ /*label*/, value)
             | ExprKind::Ret(value)
             | ExprKind::Yield(YieldKind::Prefix(value))
@@ -1653,6 +1656,19 @@ pub struct Closure {
     pub fn_arg_span: Span,
 }
 
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct InitBlock {
+    pub init_kw_span: Span,
+    pub expr: P<Expr>,
+    pub fn_decl: P<FnDecl>,
+}
+
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub enum InitKind {
+    Free(P<Expr>),
+    Array(ThinVec<P<Expr>>),
+}
+
 /// Limit types of a range (inclusive or exclusive).
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, Walkable)]
 pub enum RangeLimits {
@@ -1770,6 +1786,10 @@ pub enum ExprKind {
     Match(P<Expr>, ThinVec<Arm>, MatchKind),
     /// A closure (e.g., `move |a, b, c| a + b + c`).
     Closure(Box<Closure>),
+    /// An `init` block
+    InitBlock(P<InitBlock>),
+    /// An in-place initialization at the tail position of an `init` block
+    InitTail(P<InitKind>),
     /// A block (`'label: { ... }`).
     Block(P<Block>, Option<Label>),
     /// An `async` block (`async move { ... }`),
diff --git a/compiler/rustc_ast/src/util/classify.rs b/compiler/rustc_ast/src/util/classify.rs
index f7daec4b0648c..3f6e81aea1b97 100644
--- a/compiler/rustc_ast/src/util/classify.rs
+++ b/compiler/rustc_ast/src/util/classify.rs
@@ -128,6 +128,8 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
             | Become(..)
             | Break(..)
             | Closure(..)
+            | InitBlock(..)
+            | InitTail(..)
             | ConstBlock(..)
             | Continue(..)
             | FormatArgs(..)
@@ -230,6 +232,8 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
             | Use(_, _)
             | Field(_, _)
             | Index(_, _, _)
+            | InitBlock(_)
+            | InitTail(_)
             | Underscore
             | Path(_, _)
             | Continue(_)
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index ab15cb28fa12d..81c97e6d07a5e 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -998,6 +998,19 @@ macro_rules! common_visitor_and_walkers {
                     try_visit!(vis.visit_fn(kind, *span, *id));
                     visit_visitable!($($mut)? vis, fn_decl_span, fn_arg_span);
                 }
+                ExprKind::InitBlock(expr) => {
+                    try_visit!(vis.visit_fn(
+                        FnKind::Closure(&$($mut)?ClosureBinder::NotPresent, &$($mut)?None, &$($mut)?expr.fn_decl, &$($mut)?expr.expr),
+                        *span,
+                        *id,
+                    ));
+                }
+                ExprKind::InitTail(tail) => {
+                    match **tail {
+                        InitKind::Free(ref $($mut)? expr) => try_visit!(vis.visit_expr(expr)),
+                        InitKind::Array(ref $($mut)? exprs) => try_visit!(visit_exprs(vis, exprs)),
+                    }
+                }
                 ExprKind::Block(block, opt_label) =>
                     visit_visitable!($($mut)? vis, block, opt_label),
                 ExprKind::Gen(capt, body, kind, decl_span) =>
diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index c3222b79e55c9..48e5f44dd980b 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -26,61 +26,81 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         hir::Block { hir_id, stmts, expr, rules, span: self.lower_span(b.span), targeted_by_break }
     }
 
-    fn lower_stmts(
+    fn lower_one_stmt(
         &mut self,
-        mut ast_stmts: &[Stmt],
-    ) -> (&'hir [hir::Stmt<'hir>], Option<&'hir hir::Expr<'hir>>) {
-        let mut stmts = SmallVec::<[hir::Stmt<'hir>; 8]>::new();
-        let mut expr = None;
-        while let [s, tail @ ..] = ast_stmts {
-            match &s.kind {
-                StmtKind::Let(local) => {
-                    let hir_id = self.lower_node_id(s.id);
-                    let local = self.lower_local(local);
-                    self.alias_attrs(hir_id, local.hir_id);
-                    let kind = hir::StmtKind::Let(local);
-                    let span = self.lower_span(s.span);
-                    stmts.push(hir::Stmt { hir_id, kind, span });
-                }
-                StmtKind::Item(it) => {
-                    stmts.extend(self.lower_item_ref(it).into_iter().enumerate().map(
-                        |(i, item_id)| {
-                            let hir_id = match i {
-                                0 => self.lower_node_id(s.id),
-                                _ => self.next_id(),
-                            };
-                            let kind = hir::StmtKind::Item(item_id);
-                            let span = self.lower_span(s.span);
-                            hir::Stmt { hir_id, kind, span }
-                        },
-                    ));
-                }
-                StmtKind::Expr(e) => {
-                    let e = self.lower_expr(e);
-                    if tail.is_empty() {
-                        expr = Some(e);
-                    } else {
-                        let hir_id = self.lower_node_id(s.id);
-                        self.alias_attrs(hir_id, e.hir_id);
-                        let kind = hir::StmtKind::Expr(e);
+        s: &Stmt,
+        at_tail: Option<&mut Option<&'hir hir::Expr<'hir>>>,
+        hir_stmts: &mut impl Extend<hir::Stmt<'hir>>,
+    ) {
+        match &s.kind {
+            StmtKind::Let(local) => {
+                let hir_id = self.lower_node_id(s.id);
+                let local = self.lower_local(local);
+                self.alias_attrs(hir_id, local.hir_id);
+                let kind = hir::StmtKind::Let(local);
+                let span = self.lower_span(s.span);
+                hir_stmts.extend([hir::Stmt { hir_id, kind, span }]);
+            }
+            StmtKind::Item(it) => {
+                hir_stmts.extend(self.lower_item_ref(it).into_iter().enumerate().map(
+                    |(i, item_id)| {
+                        let hir_id = match i {
+                            0 => self.lower_node_id(s.id),
+                            _ => self.next_id(),
+                        };
+                        let kind = hir::StmtKind::Item(item_id);
                         let span = self.lower_span(s.span);
-                        stmts.push(hir::Stmt { hir_id, kind, span });
-                    }
-                }
-                StmtKind::Semi(e) => {
+                        hir::Stmt { hir_id, kind, span }
+                    },
+                ));
+            }
+            StmtKind::Expr(e) => {
+                if let Some(expr) = at_tail {
+                    let e = if self.is_in_init_tail {
+                        let hir_id = self.lower_node_id(s.id);
+                        let kind = self.lower_implicit_init_tail(e);
+                        self.arena.alloc(hir::Expr { hir_id, kind, span: s.span })
+                    } else {
+                        self.lower_expr(e)
+                    };
+                    *expr = Some(e);
+                } else {
                     let e = self.lower_expr(e);
                     let hir_id = self.lower_node_id(s.id);
                     self.alias_attrs(hir_id, e.hir_id);
-                    let kind = hir::StmtKind::Semi(e);
+                    let kind = hir::StmtKind::Expr(e);
                     let span = self.lower_span(s.span);
-                    stmts.push(hir::Stmt { hir_id, kind, span });
+                    hir_stmts.extend([hir::Stmt { hir_id, kind, span }]);
                 }
-                StmtKind::Empty => {}
-                StmtKind::MacCall(..) => panic!("shouldn't exist here"),
             }
-            ast_stmts = tail;
+            StmtKind::Semi(e) => {
+                let e = self.lower_expr(e);
+                let hir_id = self.lower_node_id(s.id);
+                self.alias_attrs(hir_id, e.hir_id);
+                let kind = hir::StmtKind::Semi(e);
+                let span = self.lower_span(s.span);
+                hir_stmts.extend([hir::Stmt { hir_id, kind, span }]);
+            }
+            StmtKind::Empty => {}
+            StmtKind::MacCall(..) => panic!("shouldn't exist here"),
+        }
+    }
+
+    fn lower_stmts(
+        &mut self,
+        ast_stmts: &[Stmt],
+    ) -> (&'hir [hir::Stmt<'hir>], Option<&'hir hir::Expr<'hir>>) {
+        let mut hir_stmts = SmallVec::<[hir::Stmt<'hir>; 8]>::new();
+        let mut expr = None;
+        if let [stmts @ .., tail] = ast_stmts {
+            self.enter_non_init_tail_lowering(|this| {
+                for s in stmts {
+                    this.lower_one_stmt(s, None, &mut hir_stmts);
+                }
+            });
+            self.lower_one_stmt(tail, Some(&mut expr), &mut hir_stmts);
         }
-        (self.arena.alloc_from_iter(stmts), expr)
+        (self.arena.alloc_from_iter(hir_stmts), expr)
     }
 
     /// Return an `ImplTraitContext` that allows impl trait in bindings if
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 15e736261d583..5ac33800ef458 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -244,6 +244,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         *fn_arg_span,
                     ),
                 },
+                ExprKind::InitBlock(block) => self.lower_expr_init_block(
+                    e.id,
+                    block.init_kw_span,
+                    &block.fn_decl,
+                    &block.expr,
+                ),
+                ExprKind::InitTail(kind) => self.lower_expr_init_tail(kind),
                 ExprKind::Gen(capture_clause, block, genblock_kind, decl_span) => {
                     let desugaring_kind = match genblock_kind {
                         GenBlockKind::Async => hir::CoroutineDesugaring::Async,
@@ -1212,6 +1219,35 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir::ExprKind::Closure(c)
     }
 
+    fn lower_expr_init_block(
+        &mut self,
+        init_id: NodeId,
+        init_kw_span: Span,
+        fn_decl: &FnDecl,
+        body: &Expr,
+    ) -> hir::ExprKind<'hir> {
+        let def_id = self.local_def_id(init_id);
+
+        let body_id = self.with_new_scopes(body.span, move |this| {
+            this.enter_init_tail_lowering(|this| {
+                this.lower_fn_body(fn_decl, None, |this| this.lower_expr_mut(body))
+            })
+        });
+        let block = self.arena.alloc(hir::InitBlock {
+            def_id,
+            body: body_id,
+            init_kw_span,
+            fn_decl: self.arena.alloc(hir::FnDecl {
+                inputs: &[],
+                output: hir::FnRetTy::DefaultReturn(body.span),
+                c_variadic: false,
+                implicit_self: hir::ImplicitSelfKind::None,
+                lifetime_elision_allowed: false,
+            }),
+        });
+        hir::ExprKind::InitBlock(block)
+    }
+
     /// Destructure the LHS of complex assignments.
     /// For instance, lower `(a, b) = t` to `{ let (lhs1, lhs2) = t; a = lhs1; b = lhs2; }`.
     fn lower_expr_assign(
diff --git a/compiler/rustc_ast_lowering/src/init.rs b/compiler/rustc_ast_lowering/src/init.rs
new file mode 100644
index 0000000000000..8cb6e4da9954e
--- /dev/null
+++ b/compiler/rustc_ast_lowering/src/init.rs
@@ -0,0 +1,60 @@
+use rustc_ast::ptr::P as AstP;
+use rustc_ast::*;
+use rustc_hir as hir;
+
+use super::LoweringContext;
+
+impl<'hir> LoweringContext<'_, 'hir> {
+    pub(crate) fn lower_free_expr_init_tail(&mut self, expr: &Expr) -> hir::ExprKind<'hir> {
+        if let ExprKind::Block(block, label) = &expr.kind {
+            self.lower_block_init_tail(block, *label)
+        } else {
+            let expr = self.lower_expr(expr);
+            hir::ExprKind::InitTail(self.arena.alloc(hir::InitKind::Free(expr)))
+        }
+    }
+
+    /// This lower machine transforms a block expression within a in-place initialisation context
+    pub(crate) fn lower_block_init_tail(
+        &mut self,
+        block: &Block,
+        label: Option<Label>,
+    ) -> hir::ExprKind<'hir> {
+        let block = self.enter_init_tail_lowering(|this| this.lower_block(block, false));
+        hir::ExprKind::InitTail(self.arena.alloc(hir::InitKind::Block(block, label)))
+    }
+
+    pub(crate) fn lower_implicit_init_tail(&mut self, expr: &Expr) -> hir::ExprKind<'hir> {
+        match &expr.kind {
+            ExprKind::Block(block, label) => self.lower_block_init_tail(block, *label),
+            ExprKind::Array(exprs) => self.lower_array_init_tail(&exprs[..]),
+            ExprKind::Struct(_) | ExprKind::Repeat(_, _) | ExprKind::Call(_, _) => {
+                todo!(
+                    "pinit: these are cases we still need to implement,
+                    especially Call *must* be lowered to a `struct` init tail expr,
+                    and block-style `struct` supports non-member fields so that computation
+                    and initialisation can interleave"
+                )
+            }
+            _ => self.lower_free_expr_init_tail(expr),
+        }
+    }
+
+    pub(crate) fn lower_array_init_tail(&mut self, exprs: &[AstP<Expr>]) -> hir::ExprKind<'hir> {
+        let exprs = self.arena.alloc_from_iter(exprs.iter().map(|expr| {
+            let hir_id = self.next_id();
+            let span = expr.span;
+            self.lower_attrs(hir_id, &expr.attrs, span);
+            let kind = self.lower_implicit_init_tail(expr);
+            hir::Expr { hir_id, kind, span }
+        }));
+        hir::ExprKind::InitTail(self.arena.alloc(hir::InitKind::Array(exprs)))
+    }
+
+    pub(crate) fn lower_expr_init_tail(&mut self, kind: &InitKind) -> hir::ExprKind<'hir> {
+        match kind {
+            InitKind::Free(expr) => self.lower_free_expr_init_tail(expr),
+            InitKind::Array(exprs) => self.lower_array_init_tail(exprs),
+        }
+    }
+}
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 9aef189a29d49..e1c77ab52e903 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -82,6 +82,7 @@ mod errors;
 mod expr;
 mod format;
 mod index;
+mod init;
 mod item;
 mod pat;
 mod path;
@@ -120,6 +121,7 @@ struct LoweringContext<'a, 'hir> {
     catch_scope: Option<HirId>,
     loop_scope: Option<HirId>,
     is_in_loop_condition: bool,
+    is_in_init_tail: bool,
     is_in_dyn_type: bool,
 
     current_hir_id_owner: hir::OwnerId,
@@ -173,6 +175,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             catch_scope: None,
             loop_scope: None,
             is_in_loop_condition: false,
+            is_in_init_tail: false,
             is_in_dyn_type: false,
             coroutine_kind: None,
             task_context: None,
@@ -916,7 +919,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn with_new_scopes<T>(&mut self, scope_span: Span, f: impl FnOnce(&mut Self) -> T) -> T {
         let current_item = self.current_item;
         self.current_item = Some(scope_span);
-
+        let was_in_init_tail = self.is_in_init_tail;
+        self.is_in_init_tail = false;
         let was_in_loop_condition = self.is_in_loop_condition;
         self.is_in_loop_condition = false;
 
@@ -924,19 +928,41 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         let catch_scope = self.catch_scope.take();
         let loop_scope = self.loop_scope.take();
+
         let ret = f(self);
+
         self.catch_scope = catch_scope;
         self.loop_scope = loop_scope;
-
         self.contract_ensures = old_contract;
-
+        self.is_in_init_tail = was_in_init_tail;
         self.is_in_loop_condition = was_in_loop_condition;
-
         self.current_item = current_item;
 
         ret
     }
 
+    /// Signal from the lowering context that the tail value of a current block
+    /// should be in-place initialised and should be lowered as an `init` tail.
+    #[inline]
+    fn enter_init_tail_lowering<T>(&mut self, lowering: impl FnOnce(&mut Self) -> T) -> T {
+        let was_in_init_tail = self.is_in_init_tail;
+        self.is_in_init_tail = true;
+        let ret = lowering(self);
+        self.is_in_init_tail = was_in_init_tail;
+        ret
+    }
+
+    /// Signal from the lowering context that blocks in statements of a current block
+    /// shall not be in-place initialised.
+    #[inline]
+    fn enter_non_init_tail_lowering<T>(&mut self, lowering: impl FnOnce(&mut Self) -> T) -> T {
+        let was_in_init_tail = self.is_in_init_tail;
+        self.is_in_init_tail = false;
+        let ret = lowering(self);
+        self.is_in_init_tail = was_in_init_tail;
+        ret
+    }
+
     fn lower_attrs(
         &mut self,
         id: HirId,
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index 8a2cb64b2a084..864c83cb65864 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -593,6 +593,14 @@ impl<'a> State<'a> {
                 self.space();
                 self.print_expr(body, FixupContext::default());
             }
+            ast::ExprKind::InitBlock(expr) => {
+                self.word_space("init");
+                self.print_expr(&expr.expr, FixupContext::default());
+            }
+            ast::ExprKind::InitTail(kind) => match &**kind {
+                ast::InitKind::Free(expr) => self.print_expr(expr, FixupContext::default()),
+                ast::InitKind::Array(exprs) => self.print_expr_vec(exprs),
+            },
             ast::ExprKind::Block(blk, opt_label) => {
                 if let Some(label) = opt_label {
                     self.print_ident(label.ident);
diff --git a/compiler/rustc_borrowck/messages.ftl b/compiler/rustc_borrowck/messages.ftl
index 33b80c4b03d6f..d650143d71494 100644
--- a/compiler/rustc_borrowck/messages.ftl
+++ b/compiler/rustc_borrowck/messages.ftl
@@ -174,6 +174,12 @@ borrowck_partial_var_move_by_use_in_coroutine =
         *[false] moved
     } due to use in coroutine
 
+borrowck_partial_var_move_by_use_in_init =
+    variable {$is_partial ->
+        [true] partially moved
+        *[false] moved
+    } due to use in init
+
 borrowck_restrict_to_static =
     consider restricting the type parameter to the `'static` lifetime
 
@@ -249,6 +255,9 @@ borrowck_var_borrow_by_use_in_closure =
 borrowck_var_borrow_by_use_in_coroutine =
     borrow occurs due to use in coroutine
 
+borrowck_var_borrow_by_use_in_init =
+    borrow occurs due to use in init
+
 borrowck_var_borrow_by_use_place_in_closure =
     {$is_single_var ->
         *[true] borrow occurs
@@ -261,6 +270,12 @@ borrowck_var_borrow_by_use_place_in_coroutine =
         [false] borrows occur
     } due to use of {$place} in coroutine
 
+borrowck_var_borrow_by_use_place_in_init =
+    {$is_single_var ->
+        *[true] borrow occurs
+        [false] borrows occur
+    } due to use of {$place} in init block
+
 borrowck_var_cannot_escape_closure =
     captured variable cannot escape `FnMut` closure body
     .note = `FnMut` closures only have access to their captured variables while they are executing...
@@ -276,6 +291,9 @@ borrowck_var_first_borrow_by_use_place_in_closure =
 borrowck_var_first_borrow_by_use_place_in_coroutine =
     first borrow occurs due to use of {$place} in coroutine
 
+borrowck_var_first_borrow_by_use_place_in_init =
+    first borrow occurs due to use of {$place} in init block
+
 borrowck_var_here_captured = variable captured here
 
 borrowck_var_here_defined = variable defined here
@@ -286,6 +304,9 @@ borrowck_var_move_by_use_in_closure =
 borrowck_var_move_by_use_in_coroutine =
     move occurs due to use in coroutine
 
+borrowck_var_move_by_use_in_init =
+    move occurs due to use in init block
+
 borrowck_var_mutable_borrow_by_use_place_in_closure =
     mutable borrow occurs due to use of {$place} in closure
 
@@ -294,3 +315,6 @@ borrowck_var_second_borrow_by_use_place_in_closure =
 
 borrowck_var_second_borrow_by_use_place_in_coroutine =
     second borrow occurs due to use of {$place} in coroutine
+
+borrowck_var_second_borrow_by_use_place_in_init =
+    second borrow occurs due to use of {$place} in init block
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 040a0607db561..909dc5650794d 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1500,6 +1500,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                     MoveUseInClosure { var_span }
                 }
+                hir::ClosureKind::Init => MoveUseInInit { var_span },
             }
         });
 
@@ -1567,6 +1568,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                     BorrowUsePlaceClosure { place: desc_place, var_span, is_single_var: true }
                 }
+                hir::ClosureKind::Init => {
+                    BorrowUsePlaceInit { place: desc_place, var_span, is_single_var: true }
+                }
             }
         });
 
@@ -1729,6 +1733,11 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                                     var_span,
                                     is_single_var: true,
                                 },
+                                hir::ClosureKind::Init => BorrowUsePlaceInit {
+                                    place: desc_place,
+                                    var_span,
+                                    is_single_var: true,
+                                },
                             }
                         },
                     );
@@ -1821,6 +1830,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                         BorrowUsePlaceClosure { place: desc_place, var_span, is_single_var: false }
                     }
+                    hir::ClosureKind::Init => {
+                        BorrowUsePlaceInit { place: desc_place, var_span, is_single_var: false }
+                    }
                 }
             });
         } else {
@@ -1835,6 +1847,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                         FirstBorrowUsePlaceClosure { place: borrow_place_desc, var_span }
                     }
+                    hir::ClosureKind::Init => {
+                        FirstBorrowUsePlaceInit { place: borrow_place_desc, var_span }
+                    }
                 }
             });
 
@@ -1847,6 +1862,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                         SecondBorrowUsePlaceClosure { place: desc_place, var_span }
                     }
+                    hir::ClosureKind::Init => {
+                        SecondBorrowUsePlaceInit { place: desc_place, var_span }
+                    }
                 }
             });
         }
@@ -3737,6 +3755,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                             BorrowUseInClosure { var_span }
                         }
+                        hir::ClosureKind::Init => BorrowUseInInit { var_span },
                     }
                 });
 
@@ -3756,6 +3775,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                     BorrowUseInClosure { var_span }
                 }
+                hir::ClosureKind::Init => BorrowUseInInit { var_span },
             }
         });
 
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index 9ad91d605a77d..a2fa9ecd847e3 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -818,6 +818,9 @@ impl UseSpans<'_> {
                         PartialAssignment => AssignPartInClosure { path_span },
                     });
                 }
+                hir::ClosureKind::Init => {
+                    // @dingxiangfei2009: what subdiagnostic?
+                }
             }
         }
     }
@@ -1532,6 +1535,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
                         CaptureVarCause::PartialMoveUseInClosure { var_span, is_partial }
                     }
+                    hir::ClosureKind::Init => {
+                        CaptureVarCause::PartialMoveUseInInit { var_span, is_partial }
+                    }
                 })
             }
         }
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
index edd14d155f669..e3d280c092028 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -776,6 +776,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                         " of coroutine"
                     }
                     hir::ClosureKind::Closure => " of closure",
+                    hir::ClosureKind::Init => " of init block",
                 };
                 (span, mir_description, hir_ty)
             }
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 321b18c9b78b2..5eae8ebce41e1 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1798,6 +1798,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
+                    | ty::Init(_, _)
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
                     | ty::Coroutine(_, _)
@@ -1825,7 +1826,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                             return;
                         }
                     }
-                    ty::Closure(..)
+                    ty::Init(..)
+                    | ty::Closure(..)
                     | ty::CoroutineClosure(..)
                     | ty::Coroutine(_, _)
                     | ty::Tuple(_) => (),
diff --git a/compiler/rustc_borrowck/src/session_diagnostics.rs b/compiler/rustc_borrowck/src/session_diagnostics.rs
index 5143b2fa20598..062291bba7fa7 100644
--- a/compiler/rustc_borrowck/src/session_diagnostics.rs
+++ b/compiler/rustc_borrowck/src/session_diagnostics.rs
@@ -217,6 +217,13 @@ pub(crate) enum CaptureVarCause {
         #[primary_span]
         var_span: Span,
     },
+    #[label(borrowck_var_borrow_by_use_place_in_init)]
+    BorrowUsePlaceInit {
+        is_single_var: bool,
+        place: String,
+        #[primary_span]
+        var_span: Span,
+    },
     #[label(borrowck_var_borrow_by_use_in_coroutine)]
     BorrowUseInCoroutine {
         #[primary_span]
@@ -227,6 +234,11 @@ pub(crate) enum CaptureVarCause {
         #[primary_span]
         var_span: Span,
     },
+    #[label(borrowck_var_borrow_by_use_in_init)]
+    BorrowUseInInit {
+        #[primary_span]
+        var_span: Span,
+    },
     #[label(borrowck_var_move_by_use_in_coroutine)]
     MoveUseInCoroutine {
         #[primary_span]
@@ -237,6 +249,11 @@ pub(crate) enum CaptureVarCause {
         #[primary_span]
         var_span: Span,
     },
+    #[label(borrowck_var_move_by_use_in_init)]
+    MoveUseInInit {
+        #[primary_span]
+        var_span: Span,
+    },
     #[label(borrowck_var_first_borrow_by_use_place_in_coroutine)]
     FirstBorrowUsePlaceCoroutine {
         place: String,
@@ -249,6 +266,12 @@ pub(crate) enum CaptureVarCause {
         #[primary_span]
         var_span: Span,
     },
+    #[label(borrowck_var_first_borrow_by_use_place_in_init)]
+    FirstBorrowUsePlaceInit {
+        place: String,
+        #[primary_span]
+        var_span: Span,
+    },
     #[label(borrowck_var_second_borrow_by_use_place_in_coroutine)]
     SecondBorrowUsePlaceCoroutine {
         place: String,
@@ -261,6 +284,12 @@ pub(crate) enum CaptureVarCause {
         #[primary_span]
         var_span: Span,
     },
+    #[label(borrowck_var_second_borrow_by_use_place_in_init)]
+    SecondBorrowUsePlaceInit {
+        place: String,
+        #[primary_span]
+        var_span: Span,
+    },
     #[label(borrowck_var_mutable_borrow_by_use_place_in_closure)]
     MutableBorrowUsePlaceClosure {
         place: String,
@@ -279,6 +308,12 @@ pub(crate) enum CaptureVarCause {
         var_span: Span,
         is_partial: bool,
     },
+    #[label(borrowck_partial_var_move_by_use_in_init)]
+    PartialMoveUseInInit {
+        #[primary_span]
+        var_span: Span,
+        is_partial: bool,
+    },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_builtin_macros/src/assert/context.rs b/compiler/rustc_builtin_macros/src/assert/context.rs
index ea7248ca5393a..fb66372d9bbe5 100644
--- a/compiler/rustc_builtin_macros/src/assert/context.rs
+++ b/compiler/rustc_builtin_macros/src/assert/context.rs
@@ -300,6 +300,8 @@ impl<'cx, 'a> Context<'cx, 'a> {
             | ExprKind::Block(_, _)
             | ExprKind::Break(_, _)
             | ExprKind::Closure(_)
+            | ExprKind::InitBlock(_)
+            | ExprKind::InitTail(_)
             | ExprKind::ConstBlock(_)
             | ExprKind::Continue(_)
             | ExprKind::Dummy
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index 18279a4d05fe0..b7a5ec1587f05 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -410,7 +410,8 @@ fn push_debuginfo_type_name<'tcx>(
         }
         ty::Closure(def_id, args)
         | ty::CoroutineClosure(def_id, args)
-        | ty::Coroutine(def_id, args, ..) => {
+        | ty::Coroutine(def_id, args, ..)
+        | ty::Init(def_id, args) => {
             // Name will be "{closure_env#0}<T1, T2, ...>", "{coroutine_env#0}<T1, T2, ...>", or
             // "{async_fn_env#0}<T1, T2, ...>", etc.
             // In the case of cpp-like debuginfo, the name additionally gets wrapped inside of
diff --git a/compiler/rustc_const_eval/src/const_eval/valtrees.rs b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
index 5ab72c853c4fc..0b959f12a2485 100644
--- a/compiler/rustc_const_eval/src/const_eval/valtrees.rs
+++ b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
@@ -176,7 +176,7 @@ fn const_to_valtree_inner<'tcx>(
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
-        | ty::CoroutineWitness(..)
+        | ty::CoroutineWitness(..) |ty::Init(..)
         | ty::UnsafeBinder(_) => Err(ValTreeCreationError::NonSupportedType(ty)),
     }
 }
@@ -337,6 +337,7 @@ pub fn valtree_to_const_value<'tcx>(
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
         | ty::CoroutineWitness(..)
+        | ty::Init(..)
         | ty::FnPtr(..)
         | ty::Str
         | ty::Slice(_)
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 1503f3bcd990b..c7c940921edc7 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -575,6 +575,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             | ty::InstanceKind::AsyncDropGlueCtorShim(..)
             | ty::InstanceKind::AsyncDropGlue(..)
             | ty::InstanceKind::FutureDropPollShim(..)
+            | ty::InstanceKind::Init(..)
             | ty::InstanceKind::Item(_) => {
                 // We need MIR for this fn.
                 // Note that this can be an intrinsic, if we are executing its fallback body.
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index e24a355891dba..fa0c7d4f17cc4 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -181,6 +181,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
+                    | ty::Init(_, _)
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
                     | ty::Coroutine(_, _)
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index 2e99bb4209f2b..746d2d2e879d0 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -501,6 +501,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 | ty::Coroutine(..)
                 | ty::CoroutineWitness(..)
                 | ty::Array(..)
+                | ty::Init(..)
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)
                 | ty::Never
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 693b378296004..21d9f08dba6cf 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -785,6 +785,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
             | ty::Str
             | ty::Dynamic(..)
             | ty::Closure(..)
+            | ty::Init(..)
             | ty::Pat(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..) => interp_ok(false),
diff --git a/compiler/rustc_const_eval/src/util/type_name.rs b/compiler/rustc_const_eval/src/util/type_name.rs
index e8f2728a7728f..b24a4a27dccf2 100644
--- a/compiler/rustc_const_eval/src/util/type_name.rs
+++ b/compiler/rustc_const_eval/src/util/type_name.rs
@@ -52,6 +52,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
             | ty::FnDef(def_id, args)
             | ty::Alias(ty::Projection | ty::Opaque, ty::AliasTy { def_id, args, .. })
             | ty::Closure(def_id, args)
+            | ty::Init(def_id, args)
             | ty::CoroutineClosure(def_id, args)
             | ty::Coroutine(def_id, args) => self.print_def_path(def_id, args),
             ty::Foreign(def_id) => self.print_def_path(def_id, &[]),
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index ca57c4f31641d..ce71adb7d1c13 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -144,6 +144,8 @@ pub enum DefKind {
     /// The definition of a synthetic coroutine body created by the lowering of a
     /// coroutine-closure, such as an async closure.
     SyntheticCoroutineBody,
+    /// The definition of an `init` thunk created by lowering an `init` expression.
+    Init,
 }
 
 impl DefKind {
@@ -186,6 +188,7 @@ impl DefKind {
             DefKind::Field => "field",
             DefKind::Impl { .. } => "implementation",
             DefKind::Closure => "closure",
+            DefKind::Init => "init block",
             DefKind::ExternCrate => "extern crate",
             DefKind::GlobalAsm => "global assembly block",
             DefKind::SyntheticCoroutineBody => "synthetic mir body",
@@ -244,6 +247,7 @@ impl DefKind {
             | DefKind::LifetimeParam
             | DefKind::ExternCrate
             | DefKind::Closure
+            | DefKind::Init
             | DefKind::Use
             | DefKind::ForeignMod
             | DefKind::GlobalAsm
@@ -290,7 +294,7 @@ impl DefKind {
             DefKind::OpaqueTy => DefPathData::OpaqueTy,
             DefKind::GlobalAsm => DefPathData::GlobalAsm,
             DefKind::Impl { .. } => DefPathData::Impl,
-            DefKind::Closure => DefPathData::Closure,
+            DefKind::Closure | DefKind::Init => DefPathData::Closure,
             DefKind::SyntheticCoroutineBody => DefPathData::SyntheticCoroutineBody,
         }
     }
@@ -316,6 +320,7 @@ impl DefKind {
             | DefKind::AssocFn
             | DefKind::Ctor(..)
             | DefKind::Closure
+            | DefKind::Init
             | DefKind::Static { .. }
             | DefKind::SyntheticCoroutineBody => true,
             DefKind::Mod
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index e83f6a1df720d..789d409ab9d2a 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1609,6 +1609,8 @@ pub enum ClosureKind {
     /// additionally allows capturing the coroutine's upvars by ref, and therefore
     /// needs to be specially treated during analysis and borrowck.
     CoroutineClosure(CoroutineDesugaring),
+    /// This is an `init` block
+    Init,
 }
 
 /// A block of statements `{ .. }`, which may have a label (in this case the
@@ -2305,6 +2307,8 @@ impl Expr<'_> {
 
             ExprKind::Break(..)
             | ExprKind::Ret(..)
+            | ExprKind::InitTail(..)
+            | ExprKind::InitBlock(..)
             | ExprKind::Yield(..)
             | ExprKind::Become(..) => ExprPrecedence::Jump,
 
@@ -2402,6 +2406,8 @@ impl Expr<'_> {
             | ExprKind::If(..)
             | ExprKind::Match(..)
             | ExprKind::Closure { .. }
+            | ExprKind::InitTail(..)
+            | ExprKind::InitBlock(..)
             | ExprKind::Block(..)
             | ExprKind::Repeat(..)
             | ExprKind::Array(..)
@@ -2517,6 +2523,8 @@ impl Expr<'_> {
             | ExprKind::Continue(..)
             | ExprKind::Ret(..)
             | ExprKind::Become(..)
+            | ExprKind::InitTail(..)
+            | ExprKind::InitBlock(..)
             | ExprKind::Let(..)
             | ExprKind::Loop(..)
             | ExprKind::Assign(..)
@@ -2838,6 +2846,12 @@ pub enum ExprKind<'hir> {
     /// e.g. `unsafe<'a> &'a i32` <=> `&i32`.
     UnsafeBinderCast(UnsafeBinderCastKind, &'hir Expr<'hir>, Option<&'hir Ty<'hir>>),
 
+    /// A tail expression of an `init` block
+    InitTail(&'hir InitKind<'hir>),
+
+    /// The outer of an `init` block
+    InitBlock(&'hir InitBlock<'hir>),
+
     /// A placeholder for an expression that wasn't syntactically well formed in some way.
     Err(rustc_span::ErrorGuaranteed),
 }
@@ -2855,6 +2869,31 @@ pub enum StructTailExpr<'hir> {
     DefaultFields(Span),
 }
 
+/// An `init` expression or block
+#[derive(Debug, Clone, Copy, HashStable_Generic)]
+pub struct InitBlock<'hir> {
+    pub def_id: LocalDefId,
+    pub body: BodyId,
+    pub init_kw_span: Span,
+    pub fn_decl: &'hir FnDecl<'hir>,
+}
+
+#[derive(Debug, Clone, Copy, HashStable_Generic)]
+pub enum InitKind<'hir> {
+    /// An array of init-able expression, `[init .., init .., init ..]`
+    Array(&'hir [Expr<'hir>]),
+    /// A repeating init-able expression, `[init ..; $const]`
+    Repeat(&'hir Expr<'hir>, &'hir ConstArg<'hir>),
+    /// A tuple of init-able expression
+    Tuple(&'hir [Expr<'hir>]),
+    /// Struct init-able expression
+    Struct(&'hir QPath<'hir>, &'hir [ExprField<'hir>], StructTailExpr<'hir>),
+    /// Free expression without further in-place `init`
+    Free(&'hir Expr<'hir>),
+    /// A possibly recursive block with one eventually in-place tail expression
+    Block(&'hir Block<'hir>, Option<Label>),
+}
+
 /// Represents an optionally `Self`-qualified value/type path or associated extension.
 ///
 /// To resolve the path to a `DefId`, call [`qpath_res`].
@@ -4824,9 +4863,12 @@ impl<'hir> Node<'hir> {
                 owner_id, kind: ItemKind::GlobalAsm { asm: _, fake_body }, ..
             }) => Some((owner_id.def_id, *fake_body)),
 
-            Node::Expr(Expr { kind: ExprKind::Closure(Closure { def_id, body, .. }), .. }) => {
-                Some((*def_id, *body))
-            }
+            Node::Expr(Expr {
+                kind:
+                    ExprKind::Closure(Closure { def_id, body, .. })
+                    | ExprKind::InitBlock(InitBlock { def_id, body, .. }),
+                ..
+            }) => Some((*def_id, *body)),
 
             Node::AnonConst(constant) => Some((constant.def_id, constant.body)),
             Node::ConstBlock(constant) => Some((constant.def_id, constant.body)),
@@ -4880,7 +4922,7 @@ impl<'hir> Node<'hir> {
                 _ => None,
             },
             Node::Expr(e) => match e.kind {
-                ExprKind::Closure { .. } => Some(FnKind::Closure),
+                ExprKind::Closure { .. } | ExprKind::InitBlock(_) => Some(FnKind::Closure),
                 _ => None,
             },
             _ => None,
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index f33915d5b0773..99b09a00c71c6 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -816,17 +816,19 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
     let Expr { hir_id, kind, span } = expression;
     try_visit!(visitor.visit_id(*hir_id));
     match *kind {
-        ExprKind::Array(subexpressions) => {
+        ExprKind::InitTail(&InitKind::Array(subexpressions)) | ExprKind::Array(subexpressions) => {
             walk_list!(visitor, visit_expr, subexpressions);
         }
         ExprKind::ConstBlock(ref const_block) => {
             try_visit!(visitor.visit_inline_const(const_block))
         }
-        ExprKind::Repeat(ref element, ref count) => {
+        ExprKind::InitTail(&InitKind::Repeat(element, count))
+        | ExprKind::Repeat(element, count) => {
             try_visit!(visitor.visit_expr(element));
             try_visit!(visitor.visit_const_arg_unambig(count));
         }
-        ExprKind::Struct(ref qpath, fields, ref optional_base) => {
+        ExprKind::InitTail(&InitKind::Struct(qpath, fields, ref optional_base))
+        | ExprKind::Struct(qpath, fields, ref optional_base) => {
             try_visit!(visitor.visit_qpath(qpath, *hir_id, *span));
             walk_list!(visitor, visit_expr_field, fields);
             match optional_base {
@@ -834,7 +836,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
                 StructTailExpr::None | StructTailExpr::DefaultFields(_) => {}
             }
         }
-        ExprKind::Tup(subexpressions) => {
+        ExprKind::InitTail(&InitKind::Tuple(subexpressions)) | ExprKind::Tup(subexpressions) => {
             walk_list!(visitor, visit_expr, subexpressions);
         }
         ExprKind::Call(ref callee_expression, arguments) => {
@@ -897,7 +899,16 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
             walk_list!(visitor, visit_generic_param, bound_generic_params);
             try_visit!(visitor.visit_fn(FnKind::Closure, fn_decl, body, *span, def_id));
         }
-        ExprKind::Block(ref block, ref opt_label) => {
+        ExprKind::InitBlock(block) => try_visit!(visitor.visit_fn(
+            FnKind::Closure,
+            block.fn_decl,
+            block.body,
+            *span,
+            block.def_id
+        )),
+        ExprKind::InitTail(&InitKind::Free(expr)) => try_visit!(visitor.visit_expr(expr)),
+        ExprKind::InitTail(&InitKind::Block(block, ref opt_label))
+        | ExprKind::Block(block, ref opt_label) => {
             visit_opt!(visitor, visit_label, opt_label);
             try_visit!(visitor.visit_block(block));
         }
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 75c04b23ed6e8..3171fdb45602a 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -352,6 +352,18 @@ language_item_table! {
 
     MaybeUninit,             sym::maybe_uninit,        maybe_uninit,               Target::Union,          GenericRequirement::None;
 
+    Init,                    sym::init_trait,          init_trait,                 Target::Trait,          GenericRequirement::Exact(1);
+    InitError,               sym::init_error,          init_error,                 Target::AssocTy,        GenericRequirement::None;
+    InitLayout,              sym::init_layout,         init_layout,                Target::Method(MethodKind::Trait { body: false }), GenericRequirement::Exact(1);
+    InitInit,                sym::init_init,           init_init,                  Target::Method(MethodKind::Trait { body: false }), GenericRequirement::Exact(1);
+    InitGuard,               sym::init_guard,          init_guard,                 Target::Struct,         GenericRequirement::Exact(1);
+    InitGuardNew,            sym::init_guard_new,      init_guard_new,             Target::Method(MethodKind::Inherent), GenericRequirement::Exact(1);
+    InitGuardRelease,        sym::init_guard_release,  init_guard_release,         Target::Method(MethodKind::Inherent), GenericRequirement::Exact(1);
+    InitArrayGuard,          sym::init_array_guard,    init_array_guard,           Target::Struct,         GenericRequirement::Exact(1);
+    InitArrayGuardNew,       sym::init_array_guard_new, init_array_guard_new,      Target::Method(MethodKind::Inherent), GenericRequirement::Exact(1);
+    InitArrayGuardBump,      sym::init_array_guard_bump, init_array_guard_bump,    Target::Method(MethodKind::Inherent), GenericRequirement::Exact(1);
+    InitArrayGuardRelease,   sym::init_array_guard_release, init_array_guard_release, Target::Method(MethodKind::Inherent), GenericRequirement::Exact(1);
+
     Termination,             sym::termination,         termination,                Target::Trait,          GenericRequirement::None;
 
     Try,                     sym::Try,                 try_trait,                  Target::Trait,          GenericRequirement::None;
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 14ec82ede1c5f..e1f88bfcb9681 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -2315,6 +2315,7 @@ fn lint_redundant_lifetimes<'tcx>(
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::SyntheticCoroutineBody => return,
     }
 
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index 80bf13dc4b7a3..8b69d0e8a9406 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -191,6 +191,7 @@ impl<'tcx> InherentCollect<'tcx> {
                 Err(self.tcx.dcx().emit_err(errors::InherentNominal { span: item_span }))
             }
             ty::FnDef(..)
+            | ty::Init(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index c75fef9f716d6..ad24b321c615c 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -227,7 +227,8 @@ pub(crate) fn orphan_check_impl(
             | ty::Tuple(..)
             | ty::UnsafeBinder(_) => (LocalImpl::Allow, NonlocalImpl::DisallowOther),
 
-            ty::Closure(..)
+            ty::Init(..)
+            | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index 31e9c3b80fba2..fa8eb166d0b51 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -181,9 +181,10 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             }
         }
         Node::ConstBlock(_)
-        | Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure { .. }, .. }) => {
-            Some(tcx.typeck_root_def_id(def_id.to_def_id()))
-        }
+        | Node::Expr(&hir::Expr {
+            kind: hir::ExprKind::Closure { .. } | hir::ExprKind::InitBlock { .. },
+            ..
+        }) => Some(tcx.typeck_root_def_id(def_id.to_def_id())),
         Node::OpaqueTy(&hir::OpaqueTy {
             origin:
                 hir::OpaqueTyOrigin::FnReturn { parent: fn_def_id, in_trait_or_impl }
@@ -371,14 +372,20 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
     // provide junk type parameter defs - the only place that
     // cares about anything but the length is instantiation,
     // and we don't do that for closures.
-    if let Node::Expr(&hir::Expr {
-        kind: hir::ExprKind::Closure(hir::Closure { kind, .. }), ..
-    }) = node
-    {
+    let closure_kind = match node {
+        Node::Expr(&hir::Expr {
+            kind: hir::ExprKind::Closure(hir::Closure { kind, .. }), ..
+        }) => Some(kind),
+        Node::Expr(hir::Expr { kind: hir::ExprKind::InitBlock(_), .. }) => Some(&ClosureKind::Init),
+        _ => None,
+    };
+    if let Some(kind) = closure_kind {
         // See `ClosureArgsParts`, `CoroutineArgsParts`, and `CoroutineClosureArgsParts`
         // for info on the usage of each of these fields.
         let dummy_args = match kind {
-            ClosureKind::Closure => &["<closure_kind>", "<closure_signature>", "<upvars>"][..],
+            ClosureKind::Closure | ClosureKind::Init => {
+                &["<closure_kind>", "<closure_signature>", "<upvars>"][..]
+            }
             ClosureKind::Coroutine(_) => &[
                 "<coroutine_kind>",
                 "<resume_ty>",
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index eb3492f5de6e7..2f7a55195df35 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -500,6 +500,16 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                 // contained within is scoped within its binder.
                 intravisit::walk_expr(this, e)
             });
+        } else if let hir::ExprKind::InitBlock(_) = e.kind {
+            self.record_late_bound_vars(e.hir_id, vec![]);
+            let scope = Scope::Binder {
+                hir_id: e.hir_id,
+                bound_vars: Default::default(),
+                s: self.scope,
+                scope_type: BinderScopeType::Normal,
+                where_bound_origin: None,
+            };
+            self.with(scope, |this| intravisit::walk_expr(this, e))
         } else {
             intravisit::walk_expr(self, e)
         }
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index d768799835867..6043ffc196292 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2294,7 +2294,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 | DefKind::Closure
                 | DefKind::ExternCrate
                 | DefKind::GlobalAsm
-                | DefKind::SyntheticCoroutineBody,
+                | DefKind::SyntheticCoroutineBody
+                | DefKind::Init,
                 _,
             )
             | Res::PrimTy(_)
diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/compiler/rustc_hir_analysis/src/variance/constraints.rs
index 960ec7f66ab15..3a8ec2afbaf17 100644
--- a/compiler/rustc_hir_analysis/src/variance/constraints.rs
+++ b/compiler/rustc_hir_analysis/src/variance/constraints.rs
@@ -236,7 +236,11 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 // leaf type -- noop
             }
 
-            ty::FnDef(..) | ty::Coroutine(..) | ty::Closure(..) | ty::CoroutineClosure(..) => {
+            ty::FnDef(..)
+            | ty::Coroutine(..)
+            | ty::Closure(..)
+            | ty::CoroutineClosure(..)
+            | ty::Init(..) => {
                 bug!("Unexpected unnameable type in variance computation: {ty}");
             }
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index bda02042aa66b..0863177c60c41 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1453,21 +1453,24 @@ impl<'a> State<'a> {
         let ib = self.ibox(INDENT_UNIT);
         self.ann.pre(self, AnnNode::Expr(expr));
         match expr.kind {
-            hir::ExprKind::Array(exprs) => {
+            hir::ExprKind::InitTail(&hir::InitKind::Array(exprs)) | hir::ExprKind::Array(exprs) => {
                 self.print_expr_vec(exprs);
             }
             hir::ExprKind::ConstBlock(ref anon_const) => {
                 self.print_inline_const(anon_const);
             }
-            hir::ExprKind::Repeat(element, ref count) => {
+            hir::ExprKind::InitTail(&hir::InitKind::Repeat(element, count))
+            | hir::ExprKind::Repeat(element, count) => {
                 self.print_expr_repeat(element, count);
             }
-            hir::ExprKind::Struct(qpath, fields, wth) => {
+            hir::ExprKind::InitTail(&hir::InitKind::Struct(qpath, fields, wth))
+            | hir::ExprKind::Struct(qpath, fields, wth) => {
                 self.print_expr_struct(qpath, fields, wth);
             }
-            hir::ExprKind::Tup(exprs) => {
+            hir::ExprKind::InitTail(&hir::InitKind::Tuple(exprs)) | hir::ExprKind::Tup(exprs) => {
                 self.print_expr_tup(exprs);
             }
+            hir::ExprKind::InitTail(&hir::InitKind::Free(expr)) => self.print_expr(expr),
             hir::ExprKind::Call(func, args) => {
                 self.print_expr_call(func, args);
             }
@@ -1576,7 +1579,12 @@ impl<'a> State<'a> {
                 // This is a bare expression.
                 self.ann.nested(self, Nested::Body(body));
             }
-            hir::ExprKind::Block(blk, opt_label) => {
+            hir::ExprKind::InitBlock(block) => {
+                self.word("init");
+                self.ann.nested(self, Nested::Body(block.body));
+            }
+            hir::ExprKind::Block(blk, opt_label)
+            | hir::ExprKind::InitTail(&hir::InitKind::Block(blk, opt_label)) => {
                 if let Some(label) = opt_label {
                     self.print_ident(label.ident);
                     self.word_space(":");
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 3eeb0eac023a9..19d1dd3f47ed3 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -138,6 +138,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             | ty::Pat(..)
             | ty::FnDef(..)
             | ty::FnPtr(..)
+            | ty::Init(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
index a413f805873de..be6f9b3a95b0e 100644
--- a/compiler/rustc_hir_typeck/src/closure.rs
+++ b/compiler/rustc_hir_typeck/src/closure.rs
@@ -116,6 +116,27 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
                 (Ty::new_closure(tcx, expr_def_id.to_def_id(), closure_args.args), None)
             }
+            hir::ClosureKind::Init => {
+                let sig = bound_sig.map_bound(|sig| {
+                    tcx.mk_fn_sig([], sig.output(), false, hir::Safety::Safe, ExternAbi::Rust)
+                });
+
+                debug!(?sig, ?expected_kind);
+
+                let closure_kind_ty = Ty::from_closure_kind(tcx, ClosureKind::FnOnce);
+
+                let closure_args = ty::ClosureArgs::new(
+                    tcx,
+                    ty::ClosureArgsParts {
+                        parent_args,
+                        closure_kind_ty,
+                        closure_sig_as_fn_ptr_ty: Ty::new_fn_ptr(tcx, sig),
+                        tupled_upvars_ty,
+                    },
+                );
+
+                (Ty::new_init(tcx, expr_def_id.to_def_id(), closure_args.args), None)
+            }
             hir::ClosureKind::Coroutine(kind) => {
                 let yield_ty = match kind {
                     hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _)
@@ -301,6 +322,31 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         closure_ty
     }
 
+    #[instrument(skip(self), level = "debug")]
+    pub(crate) fn check_init(
+        &self,
+        block: &hir::InitBlock<'tcx>,
+        expr_span: Span,
+        expected: Expectation<'tcx>,
+    ) -> Ty<'tcx> {
+        self.check_expr_closure(
+            &hir::Closure {
+                def_id: block.def_id,
+                binder: hir::ClosureBinder::Default,
+                constness: hir::Constness::NotConst,
+                capture_clause: hir::CaptureBy::Value { move_kw: block.init_kw_span },
+                bound_generic_params: &[],
+                fn_decl: block.fn_decl,
+                body: block.body,
+                fn_decl_span: expr_span,
+                fn_arg_span: None,
+                kind: hir::ClosureKind::Init,
+            },
+            expr_span,
+            expected,
+        )
+    }
+
     /// Given the expected type, figures out what it can about this closure we
     /// are about to type check:
     #[instrument(skip(self), level = "debug", ret)]
@@ -344,6 +390,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 hir::ClosureKind::Coroutine(_) | hir::ClosureKind::CoroutineClosure(_) => {
                     (None, None)
                 }
+                hir::ClosureKind::Init => todo!("dxf reject this case"),
             },
             _ => (None, None),
         }
@@ -356,6 +403,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         predicates: impl DoubleEndedIterator<Item = (ty::Predicate<'tcx>, Span)>,
     ) -> (Option<ExpectedSig<'tcx>>, Option<ty::ClosureKind>) {
         let mut expected_sig = None;
+        let mut expected_sig_from_trait_predicate = None;
         let mut expected_kind = None;
 
         for (pred, span) in traits::elaborate(
@@ -371,78 +419,99 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             debug!(?pred);
             let bound_predicate = pred.kind();
 
+            // Make sure that we didn't infer a signature that mentions itself.
+            // This can happen when we elaborate certain supertrait bounds that
+            // mention projections containing the `Self` type. See #105401.
+            struct MentionsTy<'tcx> {
+                expected_ty: Ty<'tcx>,
+            }
+            impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MentionsTy<'tcx> {
+                type Result = ControlFlow<()>;
+
+                fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
+                    if t == self.expected_ty {
+                        ControlFlow::Break(())
+                    } else {
+                        t.super_visit_with(self)
+                    }
+                }
+            }
+            let apply_inferred_sig =
+                |inferred_sig: Option<ExpectedSig<'tcx>>, expected_sig: &mut Option<_>| {
+                    // Don't infer a closure signature from a goal that names the closure type as this will
+                    // (almost always) lead to occurs check errors later in type checking.
+                    if self.next_trait_solver()
+                        && let Some(inferred_sig) = inferred_sig
+                    {
+                        // In the new solver it is difficult to explicitly normalize the inferred signature as we
+                        // would have to manually handle universes and rewriting bound vars and placeholders back
+                        // and forth.
+                        //
+                        // Instead we take advantage of the fact that we relating an inference variable with an alias
+                        // will only instantiate the variable if the alias is rigid(*not quite). Concretely we:
+                        // - Create some new variable `?sig`
+                        // - Equate `?sig` with the unnormalized signature, e.g. `fn(<Foo<?x> as Trait>::Assoc)`
+                        // - Depending on whether `<Foo<?x> as Trait>::Assoc` is rigid, ambiguous or normalizeable,
+                        //   we will either wind up with `?sig=<Foo<?x> as Trait>::Assoc/?y/ConcreteTy` respectively.
+                        //
+                        // *: In cases where there are ambiguous aliases in the signature that make use of bound vars
+                        //    they will wind up present in `?sig` even though they are non-rigid.
+                        //
+                        //    This is a bit weird and means we may wind up discarding the goal due to it naming `expected_ty`
+                        //    even though the normalized form may not name `expected_ty`. However, this matches the existing
+                        //    behaviour of the old solver and would be technically a breaking change to fix.
+                        let generalized_fnptr_sig = self.next_ty_var(span);
+                        let inferred_fnptr_sig = Ty::new_fn_ptr(self.tcx, inferred_sig.sig);
+                        self.demand_eqtype(span, inferred_fnptr_sig, generalized_fnptr_sig);
+
+                        let resolved_sig = self.resolve_vars_if_possible(generalized_fnptr_sig);
+
+                        if resolved_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
+                            *expected_sig = Some(ExpectedSig {
+                                cause_span: inferred_sig.cause_span,
+                                sig: resolved_sig.fn_sig(self.tcx),
+                            });
+                        }
+                    } else {
+                        if inferred_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
+                            *expected_sig = inferred_sig;
+                        }
+                    }
+                };
             // Given a Projection predicate, we can potentially infer
             // the complete signature.
-            if expected_sig.is_none()
+            if matches!(closure_kind, hir::ClosureKind::Init)
+                && expected_sig_from_trait_predicate.is_none()
+                && let ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_predicate)) =
+                    bound_predicate.skip_binder()
+                && self.tcx.is_lang_item(trait_predicate.def_id(), LangItem::Init)
+            {
+                apply_inferred_sig(
+                    self.normalize(
+                        span,
+                        self.deduce_sig_from_trait_predicate(
+                            Some(span),
+                            closure_kind,
+                            bound_predicate.rebind(trait_predicate),
+                        ),
+                    ),
+                    &mut expected_sig_from_trait_predicate,
+                );
+            } else if expected_sig.is_none()
                 && let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj_predicate)) =
                     bound_predicate.skip_binder()
             {
-                let inferred_sig = self.normalize(
-                    span,
-                    self.deduce_sig_from_projection(
-                        Some(span),
-                        closure_kind,
-                        bound_predicate.rebind(proj_predicate),
+                apply_inferred_sig(
+                    self.normalize(
+                        span,
+                        self.deduce_sig_from_projection(
+                            Some(span),
+                            closure_kind,
+                            bound_predicate.rebind(proj_predicate),
+                        ),
                     ),
+                    &mut expected_sig,
                 );
-
-                // Make sure that we didn't infer a signature that mentions itself.
-                // This can happen when we elaborate certain supertrait bounds that
-                // mention projections containing the `Self` type. See #105401.
-                struct MentionsTy<'tcx> {
-                    expected_ty: Ty<'tcx>,
-                }
-                impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MentionsTy<'tcx> {
-                    type Result = ControlFlow<()>;
-
-                    fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
-                        if t == self.expected_ty {
-                            ControlFlow::Break(())
-                        } else {
-                            t.super_visit_with(self)
-                        }
-                    }
-                }
-
-                // Don't infer a closure signature from a goal that names the closure type as this will
-                // (almost always) lead to occurs check errors later in type checking.
-                if self.next_trait_solver()
-                    && let Some(inferred_sig) = inferred_sig
-                {
-                    // In the new solver it is difficult to explicitly normalize the inferred signature as we
-                    // would have to manually handle universes and rewriting bound vars and placeholders back
-                    // and forth.
-                    //
-                    // Instead we take advantage of the fact that we relating an inference variable with an alias
-                    // will only instantiate the variable if the alias is rigid(*not quite). Concretely we:
-                    // - Create some new variable `?sig`
-                    // - Equate `?sig` with the unnormalized signature, e.g. `fn(<Foo<?x> as Trait>::Assoc)`
-                    // - Depending on whether `<Foo<?x> as Trait>::Assoc` is rigid, ambiguous or normalizeable,
-                    //   we will either wind up with `?sig=<Foo<?x> as Trait>::Assoc/?y/ConcreteTy` respectively.
-                    //
-                    // *: In cases where there are ambiguous aliases in the signature that make use of bound vars
-                    //    they will wind up present in `?sig` even though they are non-rigid.
-                    //
-                    //    This is a bit weird and means we may wind up discarding the goal due to it naming `expected_ty`
-                    //    even though the normalized form may not name `expected_ty`. However, this matches the existing
-                    //    behaviour of the old solver and would be technically a breaking change to fix.
-                    let generalized_fnptr_sig = self.next_ty_var(span);
-                    let inferred_fnptr_sig = Ty::new_fn_ptr(self.tcx, inferred_sig.sig);
-                    self.demand_eqtype(span, inferred_fnptr_sig, generalized_fnptr_sig);
-
-                    let resolved_sig = self.resolve_vars_if_possible(generalized_fnptr_sig);
-
-                    if resolved_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
-                        expected_sig = Some(ExpectedSig {
-                            cause_span: inferred_sig.cause_span,
-                            sig: resolved_sig.fn_sig(self.tcx),
-                        });
-                    }
-                } else {
-                    if inferred_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
-                        expected_sig = inferred_sig;
-                    }
-                }
             }
 
             // Even if we can't infer the full signature, we may be able to
@@ -460,6 +529,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             if let Some(trait_def_id) = trait_def_id {
                 let found_kind = match closure_kind {
                     hir::ClosureKind::Closure
+                    | hir::ClosureKind::Init
                     // FIXME(iter_macro): Someday we'll probably want iterator closures instead of
                     // just using Fn* for iterators.
                     | hir::ClosureKind::CoroutineClosure(hir::CoroutineDesugaring::Gen) => {
@@ -488,7 +558,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
-        (expected_sig, expected_kind)
+        (expected_sig.or(expected_sig_from_trait_predicate), expected_kind)
     }
 
     /// Given a projection like "<F as Fn(X)>::Result == Y", we can deduce
@@ -525,6 +595,35 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             {
                 self.extract_sig_from_projection_and_future_bound(cause_span, projection)
             }
+            hir::ClosureKind::Init if self.tcx.is_lang_item(def_id, LangItem::InitError) => {
+                self.extract_init_sig_from_projection(cause_span, projection)
+            }
+            _ => None,
+        }
+    }
+
+    #[instrument(level = "debug", skip(self, cause_span), ret)]
+    fn deduce_sig_from_trait_predicate(
+        &self,
+        cause_span: Option<Span>,
+        closure_kind: hir::ClosureKind,
+        predicate: ty::PolyTraitPredicate<'tcx>,
+    ) -> Option<ExpectedSig<'tcx>> {
+        let def_id = predicate.def_id();
+        match closure_kind {
+            hir::ClosureKind::Init if self.tcx.is_lang_item(def_id, LangItem::Init) => {
+                let predicate = self.resolve_vars_if_possible(predicate);
+                let target_ty = predicate.skip_binder().trait_ref.args.type_at(1);
+                let err_ty = self.next_ty_var(cause_span.unwrap_or(DUMMY_SP));
+                let sig = predicate.rebind(self.tcx.mk_fn_sig(
+                    self.tcx.mk_type_list(&[]),
+                    Ty::new_tup(self.tcx, &[target_ty, err_ty]),
+                    false,
+                    hir::Safety::Safe,
+                    ExternAbi::Rust,
+                ));
+                Some(ExpectedSig { cause_span, sig })
+            }
             _ => None,
         }
     }
@@ -560,6 +659,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         Some(ExpectedSig { cause_span, sig })
     }
 
+    /// Given an `Init::Error` projection, extract the args
+    /// and return type to infer a [`ty::PolyFnSig`] for the init block.
+    fn extract_init_sig_from_projection(
+        &self,
+        cause_span: Option<Span>,
+        projection: ty::PolyProjectionPredicate<'tcx>,
+    ) -> Option<ExpectedSig<'tcx>> {
+        let projection = self.resolve_vars_if_possible(projection);
+
+        let target_ty = projection.skip_binder().projection_term.args.type_at(1);
+        debug!(?target_ty);
+
+        // Since this is a return parameter type it is safe to unwrap.
+        let err_ty = projection.skip_binder().term.expect_type();
+        debug!(?err_ty);
+
+        let sig = projection.rebind(self.tcx.mk_fn_sig(
+            self.tcx.mk_type_list(&[]),
+            Ty::new_tup(self.tcx, &[target_ty, err_ty]),
+            false,
+            hir::Safety::Safe,
+            ExternAbi::Rust,
+        ));
+
+        Some(ExpectedSig { cause_span, sig })
+    }
+
     /// When an async closure is passed to a function that has a "two-part" `Fn`
     /// and `Future` trait bound, like:
     ///
@@ -959,6 +1085,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 | hir::ClosureKind::CoroutineClosure(_) => {
                     lowerer.ty_infer(None, decl.output.span())
                 }
+                // The return type in a pseudo-fn-pointer of an `init`
+                // is a tuple of a target and an error type.
+                hir::ClosureKind::Init => Ty::new_tup(
+                    self.tcx,
+                    &[
+                        lowerer.ty_infer(None, decl.output.span()),
+                        lowerer.ty_infer(None, decl.output.span()),
+                    ],
+                ),
             },
         };
 
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 08e8164078cb4..074b70aec67be 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -393,6 +393,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     | ExprKind::Cast(_, _)
                     | ExprKind::DropTemps(_)
                     | ExprKind::If(_, _, _)
+                    | ExprKind::InitBlock(_)
+                    | ExprKind::InitTail(_)
                     | ExprKind::Closure(_)
                     | ExprKind::Block(_, _)
                     | ExprKind::AssignOp(_, _, _)
@@ -568,6 +570,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.check_expr_match(expr, discrim, arms, expected, match_src)
             }
             ExprKind::Closure(closure) => self.check_expr_closure(closure, expr.span, expected),
+            ExprKind::InitBlock(block) => self.check_init(block, expr.span, expected),
+            ExprKind::InitTail(kind) => self.check_init_tail(kind, expected, expr),
             ExprKind::Block(body, _) => self.check_expr_block(body, expected),
             ExprKind::Call(callee, args) => self.check_expr_call(expr, callee, args, expected),
             ExprKind::Use(used_expr, _) => self.check_expr_use(used_expr, expected),
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index 2034131882820..f836acac986f7 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -433,11 +433,12 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                 self.consume_exprs(args)?;
             }
 
-            hir::ExprKind::Struct(_, fields, ref opt_with) => {
+            hir::ExprKind::Struct(_, fields, ref opt_with)
+            | hir::ExprKind::InitTail(&hir::InitKind::Struct(_, fields, ref opt_with)) => {
                 self.walk_struct_expr(fields, opt_with)?;
             }
 
-            hir::ExprKind::Tup(exprs) => {
+            hir::ExprKind::Tup(exprs) | hir::ExprKind::InitTail(&hir::InitKind::Tuple(exprs)) => {
                 self.consume_exprs(exprs)?;
             }
 
@@ -467,7 +468,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                 }
             }
 
-            hir::ExprKind::Array(exprs) => {
+            hir::ExprKind::Array(exprs) | hir::ExprKind::InitTail(&hir::InitKind::Array(exprs)) => {
                 self.consume_exprs(exprs)?;
             }
 
@@ -525,7 +526,8 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                 self.consume_expr(rhs)?;
             }
 
-            hir::ExprKind::Block(blk, _) => {
+            hir::ExprKind::Block(blk, _)
+            | hir::ExprKind::InitTail(&hir::InitKind::Block(blk, _)) => {
                 self.walk_block(blk)?;
             }
 
@@ -561,12 +563,21 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                 self.consume_expr(rhs)?;
             }
 
-            hir::ExprKind::Repeat(base, _) => {
+            hir::ExprKind::Repeat(base, _)
+            | hir::ExprKind::InitTail(&hir::InitKind::Repeat(base, _)) => {
                 self.consume_expr(base)?;
             }
 
             hir::ExprKind::Closure(closure) => {
-                self.walk_captures(closure)?;
+                self.walk_captures(closure.def_id)?;
+            }
+
+            hir::ExprKind::InitBlock(&hir::InitBlock { def_id, .. }) => {
+                self.walk_captures(def_id)?;
+            }
+
+            hir::ExprKind::InitTail(&hir::InitKind::Free(expr)) => {
+                self.consume_expr(expr)?;
             }
 
             hir::ExprKind::Yield(value, _) => {
@@ -1047,7 +1058,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
     /// - When reporting the Place back to the Delegate, ensure that the UpvarId uses the enclosing
     /// closure as the DefId.
     #[instrument(skip(self), level = "debug")]
-    fn walk_captures(&self, closure_expr: &hir::Closure<'_>) -> Result<(), Cx::Error> {
+    fn walk_captures(&self, closure_def_id: LocalDefId) -> Result<(), Cx::Error> {
         fn upvar_is_local_variable(
             upvars: Option<&FxIndexMap<HirId, hir::Upvar>>,
             upvar_id: HirId,
@@ -1057,7 +1068,6 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         }
 
         let tcx = self.cx.tcx();
-        let closure_def_id = closure_expr.def_id;
         // For purposes of this function, coroutine and closures are equivalent.
         let body_owner_is_closure = matches!(
             tcx.hir_body_owner_kind(self.cx.body_owner_def_id()),
@@ -1413,6 +1423,8 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
             | hir::ExprKind::Assign(..)
             | hir::ExprKind::AssignOp(..)
             | hir::ExprKind::Closure { .. }
+            | hir::ExprKind::InitBlock(..)
+            | hir::ExprKind::InitTail(..)
             | hir::ExprKind::Ret(..)
             | hir::ExprKind::Become(..)
             | hir::ExprKind::Unary(..)
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index eb8d671c939ce..8ff5dc9345439 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1863,7 +1863,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
+    pub(crate) fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
         // Don't do all the complex logic below for `DeclItem`.
         match stmt.kind {
             hir::StmtKind::Item(..) => return,
diff --git a/compiler/rustc_hir_typeck/src/init.rs b/compiler/rustc_hir_typeck/src/init.rs
new file mode 100644
index 0000000000000..d035bc506277d
--- /dev/null
+++ b/compiler/rustc_hir_typeck/src/init.rs
@@ -0,0 +1,145 @@
+#![allow(unused)]
+use std::cell::RefCell;
+
+use hir::{Expr, InitKind};
+use rustc_abi::ExternAbi;
+use rustc_hir::def::DefKind;
+use rustc_hir::lang_items::LangItem;
+use rustc_hir::{self as hir, ExprKind};
+use rustc_hir_analysis::check::check_function_signature;
+use rustc_infer::infer::RegionVariableOrigin;
+use rustc_infer::traits::{Obligation, WellFormedLoc};
+use rustc_middle::span_bug;
+use rustc_middle::ty::{self, Binder, Ty, TyCtxt};
+use rustc_span::def_id::LocalDefId;
+use rustc_span::sym;
+use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
+use tracing::{debug, instrument};
+
+use crate::coercion::CoerceMany;
+use crate::expectation::Expectation;
+use crate::gather_locals::GatherLocalsVisitor;
+use crate::{CoroutineTypes, Diverges, FnCtxt};
+
+impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
+    #[instrument(level = "debug", skip(self, kind))]
+    pub(crate) fn check_init_tail(
+        &self,
+        kind: &InitKind<'tcx>,
+        expected: Expectation<'tcx>,
+        expr: &'tcx Expr<'tcx>,
+    ) -> Ty<'tcx> {
+        // If there is expectation, which should be very probable,
+        // it should have been a tuple of a target type and a error type.
+        let (ret_ty, err_ty) = if let Some(expected) = expected.to_option(self)
+            && let &ty::Tuple(tys) = self.try_structurally_resolve_type(expr.span, expected).kind()
+            && let [ret_ty, err_ty] = tys[..]
+        {
+            (ret_ty, err_ty)
+        } else {
+            (self.next_ty_var(expr.span), self.next_ty_var(expr.span))
+        };
+        let (ret_ty, err_ty) = self.check_init_tail_inner(kind, ret_ty, err_ty, expr);
+        Ty::new_tup(self.tcx, &[ret_ty, err_ty])
+    }
+
+    #[instrument(level = "debug", skip(self, kind))]
+    fn check_init_tail_inner(
+        &self,
+        kind: &InitKind<'tcx>,
+        ret_ty: Ty<'tcx>,
+        err_ty: Ty<'tcx>,
+        expr: &'tcx Expr<'tcx>,
+    ) -> (Ty<'tcx>, Ty<'tcx>) {
+        match kind {
+            &InitKind::Free(expr) => {
+                let free_ty = self.try_structurally_resolve_type(
+                    expr.span,
+                    self.check_expr_with_hint(expr, ret_ty),
+                );
+                let nested_err_ty =
+                    self.register_init_tail_obligation_and_project_err(free_ty, ret_ty, expr);
+                let mut coerce =
+                    CoerceMany::with_coercion_sites(err_ty, std::slice::from_ref(expr));
+                coerce.coerce(self, &self.misc(expr.span), expr, nested_err_ty);
+                let err_ty = coerce.complete(self);
+                (ret_ty, err_ty)
+            }
+            &InitKind::Block(block, label) => {
+                self.check_expr_block(
+                    block,
+                    Expectation::ExpectHasType(Ty::new_tup(self.tcx, &[ret_ty, err_ty])),
+                );
+                (ret_ty, err_ty)
+            }
+            &InitKind::Array(exprs) => {
+                let mut coerce_ret =
+                    CoerceMany::with_coercion_sites(ret_ty, std::slice::from_ref(expr));
+                let mut coerce_err = CoerceMany::with_coercion_sites(err_ty, exprs);
+                let elem_ty = self.next_ty_var(expr.span);
+                let mut coerce_elem = CoerceMany::with_coercion_sites(elem_ty, exprs);
+                for expr in exprs {
+                    let ExprKind::InitTail(inner_kind) = expr.kind else {
+                        span_bug!(
+                            expr.span,
+                            "expecting InitTail in HIR array expression, got {:?}",
+                            expr.kind
+                        )
+                    };
+                    let (inner_elem_ty, inner_err_ty) =
+                        self.check_init_tail_inner(inner_kind, elem_ty, err_ty, expr);
+                    coerce_err.coerce(
+                        self,
+                        &self.misc(expr.span),
+                        expr,
+                        self.resolve_vars_if_possible(inner_err_ty),
+                    );
+                    let inner_elem_ty = self.resolve_vars_if_possible(inner_elem_ty);
+                    coerce_elem.coerce(self, &self.misc(expr.span), expr, inner_elem_ty);
+                    self.write_ty(expr.hir_id, inner_elem_ty);
+                }
+                let elem_ty = self.resolve_vars_if_possible(coerce_elem.complete(self));
+                coerce_ret.coerce(
+                    self,
+                    &self.misc(expr.span),
+                    expr,
+                    Ty::new_array(self.tcx, elem_ty, exprs.len() as u64),
+                );
+                let ret_ty = coerce_ret.complete(self);
+                let err_ty = coerce_err.complete(self);
+                (ret_ty, err_ty)
+            }
+            &InitKind::Repeat(_expr, _const_arg) => todo!("dxf: sorry"),
+            &InitKind::Tuple(_exprs) => todo!("dxf: sorry"),
+            &InitKind::Struct(_qpath, _expr_fields, _struct_tail_expr) => {
+                todo!("dxf: sorry but this have to deviate from a typical HIR struct expr")
+            }
+        }
+    }
+
+    fn register_init_tail_obligation_and_project_err(
+        &self,
+        free_ty: Ty<'tcx>,
+        ret_ty: Ty<'tcx>,
+        expr: &'tcx Expr<'tcx>,
+    ) -> Ty<'tcx> {
+        // Now demand the `free_ty` to satisfy `$free_ty: Init<$ret_ty, Error = $err_ty>`
+        let cause = self.misc(expr.span);
+        // NOTE(@dingxiangfei2009): potential problem, what happens if the error type can be ty::Never?
+        let predicate = ty::TraitPredicate {
+            trait_ref: ty::TraitRef::new(
+                self.tcx,
+                self.tcx.require_lang_item(LangItem::Init, expr.span),
+                [free_ty, ret_ty],
+            ),
+            polarity: ty::PredicatePolarity::Positive,
+        };
+        let obligation = Obligation::new(self.tcx, cause, self.param_env, predicate);
+        self.register_predicate(obligation);
+        Ty::new_projection(
+            self.tcx,
+            self.tcx.require_lang_item(LangItem::InitError, expr.span),
+            [free_ty, ret_ty],
+        )
+    }
+}
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 9e324286fa176..0dde99833178b 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -21,6 +21,7 @@ mod diverges;
 mod errors;
 mod expectation;
 mod expr;
+mod init;
 mod inline_asm;
 // Used by clippy;
 pub mod expr_use_visitor;
diff --git a/compiler/rustc_hir_typeck/src/naked_functions.rs b/compiler/rustc_hir_typeck/src/naked_functions.rs
index d055fa68fc34a..43ef00562df18 100644
--- a/compiler/rustc_hir_typeck/src/naked_functions.rs
+++ b/compiler/rustc_hir_typeck/src/naked_functions.rs
@@ -147,6 +147,8 @@ impl CheckInlineAssembly {
             | ExprKind::Match(..)
             | ExprKind::If(..)
             | ExprKind::Closure { .. }
+            | ExprKind::InitBlock(..)
+            | ExprKind::InitTail(..)
             | ExprKind::Assign(..)
             | ExprKind::AssignOp(..)
             | ExprKind::Field(..)
diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index be774106abf8f..34d201e9ac05a 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -147,6 +147,20 @@ impl<'a, 'tcx> Visitor<'tcx> for InferBorrowKindVisitor<'a, 'tcx> {
                 self.visit_body(body);
                 self.fcx.analyze_closure(expr.hir_id, expr.span, body_id, body, capture_clause);
             }
+            hir::ExprKind::InitBlock(&hir::InitBlock {
+                body: body_id,
+                init_kw_span: move_kw,
+                ..
+            }) => {
+                let body = self.fcx.tcx.hir_body(body_id);
+                self.fcx.analyze_closure(
+                    expr.hir_id,
+                    expr.span,
+                    body_id,
+                    body,
+                    hir::CaptureBy::Value { move_kw },
+                );
+            }
             _ => {}
         }
 
@@ -173,7 +187,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // Extract the type of the closure.
         let ty = self.node_ty(closure_hir_id);
         let (closure_def_id, args, infer_kind) = match *ty.kind() {
-            ty::Closure(def_id, args) => {
+            ty::Closure(def_id, args) | ty::Init(def_id, args) => {
                 (def_id, UpvarArgs::Closure(args), self.closure_kind(ty).is_none())
             }
             ty::CoroutineClosure(def_id, args) => {
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index 060447ba72068..60c509e5dd1ba 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -409,6 +409,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Bool
             | ty::Char
             | ty::Int(..)
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 2d269e320b64d..100abcddc12ec 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1237,7 +1237,7 @@ impl<'tcx> InferCtxt<'tcx> {
     /// `ClosureKind` may not yet be known.
     pub fn closure_kind(&self, closure_ty: Ty<'tcx>) -> Option<ty::ClosureKind> {
         let unresolved_kind_ty = match *closure_ty.kind() {
-            ty::Closure(_, args) => args.as_closure().kind_ty(),
+            ty::Closure(_, args) | ty::Init(_, args) => args.as_closure().kind_ty(),
             ty::CoroutineClosure(_, args) => args.as_coroutine_closure().kind_ty(),
             _ => bug!("unexpected type {closure_ty}"),
         };
diff --git a/compiler/rustc_lint/src/dangling.rs b/compiler/rustc_lint/src/dangling.rs
index c737919db9c2d..29fa9a6427e3b 100644
--- a/compiler/rustc_lint/src/dangling.rs
+++ b/compiler/rustc_lint/src/dangling.rs
@@ -199,6 +199,9 @@ fn is_temporary_rvalue(expr: &Expr<'_>) -> bool {
 
         // Not applicable
         ExprKind::Type(..) | ExprKind::Err(..) => false,
+
+        // In-place thunk are not temporary
+        ExprKind::InitBlock(..) | ExprKind::InitTail(..) => false,
     }
 }
 
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index fc9d795cb2315..5c46fc664faa6 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -1404,6 +1404,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             | ty::Infer(..)
             | ty::Bound(..)
             | ty::Error(_)
+            | ty::Init(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 5cd98038fc6d3..8362d0f8b0165 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -929,6 +929,7 @@ fn should_encode_span(def_kind: DefKind) -> bool {
         | DefKind::Field
         | DefKind::Impl { .. }
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::SyntheticCoroutineBody => true,
         DefKind::ForeignMod | DefKind::GlobalAsm => false,
     }
@@ -958,7 +959,7 @@ fn should_encode_attrs(def_kind: DefKind) -> bool {
         // closures from upstream crates, too. This is used by
         // https://github.com/model-checking/kani and is not a performance
         // or maintenance issue for us.
-        DefKind::Closure => true,
+        DefKind::Closure | DefKind::Init => true,
         DefKind::SyntheticCoroutineBody => false,
         DefKind::TyParam
         | DefKind::ConstParam
@@ -1007,6 +1008,7 @@ fn should_encode_expn_that_defined(def_kind: DefKind) -> bool {
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::SyntheticCoroutineBody => false,
     }
 }
@@ -1044,6 +1046,7 @@ fn should_encode_visibility(def_kind: DefKind) -> bool {
         | DefKind::Impl { .. }
         | DefKind::Closure
         | DefKind::ExternCrate
+        | DefKind::Init
         | DefKind::SyntheticCoroutineBody => false,
     }
 }
@@ -1079,6 +1082,7 @@ fn should_encode_stability(def_kind: DefKind) -> bool {
         | DefKind::InlineConst
         | DefKind::GlobalAsm
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::ExternCrate
         | DefKind::SyntheticCoroutineBody => false,
     }
@@ -1174,6 +1178,7 @@ fn should_encode_variances<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, def_kind: Def
         | DefKind::InlineConst
         | DefKind::GlobalAsm
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::ExternCrate
         | DefKind::SyntheticCoroutineBody => false,
         DefKind::TyAlias => tcx.type_alias_is_lazy(def_id),
@@ -1204,6 +1209,7 @@ fn should_encode_generics(def_kind: DefKind) -> bool {
         | DefKind::Field
         | DefKind::TyParam
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::SyntheticCoroutineBody => true,
         DefKind::Mod
         | DefKind::ForeignMod
@@ -1233,6 +1239,7 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
         | DefKind::AssocFn
         | DefKind::AssocConst
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::ConstParam
         | DefKind::AnonConst
         | DefKind::InlineConst
@@ -1295,6 +1302,7 @@ fn should_encode_fn_sig(def_kind: DefKind) -> bool {
         | DefKind::Impl { .. }
         | DefKind::AssocConst
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::ConstParam
         | DefKind::AnonConst
         | DefKind::InlineConst
@@ -1344,6 +1352,7 @@ fn should_encode_constness(def_kind: DefKind) -> bool {
         | DefKind::ExternCrate
         | DefKind::Ctor(_, CtorKind::Const)
         | DefKind::Variant
+        | DefKind::Init
         | DefKind::SyntheticCoroutineBody => false,
     }
 }
@@ -1366,6 +1375,7 @@ fn should_encode_const(def_kind: DefKind) -> bool {
         | DefKind::Impl { .. }
         | DefKind::AssocFn
         | DefKind::Closure
+        | DefKind::Init
         | DefKind::ConstParam
         | DefKind::AssocTy
         | DefKind::TyParam
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
index 28f406fbc9629..23c4672dfe78f 100644
--- a/compiler/rustc_metadata/src/rmeta/table.rs
+++ b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -155,6 +155,7 @@ fixed_size_enum! {
         ( Impl { of_trait: false }                 )
         ( Impl { of_trait: true }                  )
         ( Closure                                  )
+        ( Init                                     )
         ( Static { safety: hir::Safety::Unsafe, mutability: ast::Mutability::Not, nested: false } )
         ( Static { safety: hir::Safety::Safe, mutability: ast::Mutability::Not, nested: false } )
         ( Static { safety: hir::Safety::Unsafe, mutability: ast::Mutability::Mut, nested: false } )
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index 42a1e7377f4ba..9d73b0ede81c5 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -295,7 +295,9 @@ impl<'tcx> TyCtxt<'tcx> {
             }
             DefKind::InlineConst => BodyOwnerKind::Const { inline: true },
             DefKind::Ctor(..) | DefKind::Fn | DefKind::AssocFn => BodyOwnerKind::Fn,
-            DefKind::Closure | DefKind::SyntheticCoroutineBody => BodyOwnerKind::Closure,
+            DefKind::Closure | DefKind::Init | DefKind::SyntheticCoroutineBody => {
+                BodyOwnerKind::Closure
+            }
             DefKind::Static { safety: _, mutability, nested: false } => {
                 BodyOwnerKind::Static(mutability)
             }
diff --git a/compiler/rustc_middle/src/middle/lang_items.rs b/compiler/rustc_middle/src/middle/lang_items.rs
index 93264f02cc259..bec7ac3f2bfdd 100644
--- a/compiler/rustc_middle/src/middle/lang_items.rs
+++ b/compiler/rustc_middle/src/middle/lang_items.rs
@@ -38,7 +38,7 @@ impl<'tcx> TyCtxt<'tcx> {
         match self.as_lang_item(id)? {
             LangItem::Fn => Some(ty::ClosureKind::Fn),
             LangItem::FnMut => Some(ty::ClosureKind::FnMut),
-            LangItem::FnOnce => Some(ty::ClosureKind::FnOnce),
+            LangItem::FnOnce | LangItem::Init => Some(ty::ClosureKind::FnOnce),
             _ => None,
         }
     }
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
index 2d7ddd105bd4f..182aed72a46ed 100644
--- a/compiler/rustc_middle/src/mir/mono.rs
+++ b/compiler/rustc_middle/src/mir/mono.rs
@@ -555,6 +555,7 @@ impl<'tcx> CodegenUnit<'tcx> {
                             | InstanceKind::FnPtrAddrShim(..)
                             | InstanceKind::AsyncDropGlue(..)
                             | InstanceKind::FutureDropPollShim(..)
+                            | InstanceKind::Init(..)
                             | InstanceKind::AsyncDropGlueCtorShim(..) => None,
                         }
                     }
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 8e403dfddaed8..6b25f19cdcde1 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -663,9 +663,11 @@ fn write_mir_sig(tcx: TyCtxt<'_>, body: &Body<'_>, w: &mut dyn io::Write) -> io:
     let def_id = body.source.def_id();
     let kind = tcx.def_kind(def_id);
     let is_function = match kind {
-        DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) | DefKind::SyntheticCoroutineBody => {
-            true
-        }
+        DefKind::Fn
+        | DefKind::AssocFn
+        | DefKind::Ctor(..)
+        | DefKind::SyntheticCoroutineBody
+        | DefKind::Init => true,
         _ => tcx.is_closure_like(def_id),
     };
     match (kind, body.source.promoted) {
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 929ebe1aee181..098a4bd44fa2b 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -358,6 +358,7 @@ macro_rules! make_mir_visitor {
                         ty::InstanceKind::FnPtrShim(_def_id, ty)
                         | ty::InstanceKind::DropGlue(_def_id, Some(ty))
                         | ty::InstanceKind::CloneShim(_def_id, ty)
+                        | ty::InstanceKind::Init(_def_id, ty)
                         | ty::InstanceKind::FnPtrAddrShim(_def_id, ty)
                         | ty::InstanceKind::AsyncDropGlue(_def_id, ty)
                         | ty::InstanceKind::AsyncDropGlueCtorShim(_def_id, ty) => {
diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs
index c498e6b3c83da..88e3572094da7 100644
--- a/compiler/rustc_middle/src/traits/select.rs
+++ b/compiler/rustc_middle/src/traits/select.rs
@@ -125,6 +125,18 @@ pub enum SelectionCandidate<'tcx> {
         is_const: bool,
     },
 
+    /// Implementation of the `Init` trait by the anonymous types backed by
+    /// `init` blocks.
+    InitCandidate,
+
+    /// Implementation of the `Init` trait by the moving value into the target
+    /// place.
+    TrivialInitCandidate,
+
+    /// Implementation of the `Init` trait through implicit array unsizing
+    /// from a bound in the environment
+    ArrayUnsizeInitCandidate(ty::PolyTraitPredicate<'tcx>),
+
     /// Implementation of an `AsyncFn`-family trait by one of the anonymous types
     /// generated for an `async ||` expression.
     AsyncClosureCandidate,
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 51db92ecd78f2..99f098460325e 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -542,6 +542,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
+            | ty::Init(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
@@ -2497,6 +2498,7 @@ impl<'tcx> TyCtxt<'tcx> {
                 FnPtr,
                 UnsafeBinder,
                 Placeholder,
+                Init,
                 Coroutine,
                 CoroutineWitness,
                 Dynamic,
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
index 13723874ad3a1..263595291479b 100644
--- a/compiler/rustc_middle/src/ty/error.rs
+++ b/compiler/rustc_middle/src/ty/error.rs
@@ -196,6 +196,7 @@ impl<'tcx> Ty<'tcx> {
             ty::FnPtr(..) => "fn pointer".into(),
             ty::UnsafeBinder(_) => "unsafe binder".into(),
             ty::Dynamic(..) => "trait object".into(),
+            ty::Init(..) => "init".into(),
             ty::Closure(..) | ty::CoroutineClosure(..) => "closure".into(),
             ty::Coroutine(def_id, ..) => {
                 format!("{:#}", tcx.coroutine_kind(def_id).unwrap()).into()
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index d5767ca3786e8..1e06dfa04e8b0 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -183,6 +183,11 @@ pub enum InstanceKind<'tcx> {
     /// async_drop_in_place poll function implementation (for generated coroutine).
     /// `Ty` here is `async_drop_in_place<T>::{closure}` coroutine type, not just `T`
     AsyncDropGlue(DefId, Ty<'tcx>),
+
+    /// `core::init::PinInit::<T>::pin_init`
+    ///
+    /// `Ty` here is `T`
+    Init(DefId, Ty<'tcx>),
 }
 
 impl<'tcx> Instance<'tcx> {
@@ -256,6 +261,7 @@ impl<'tcx> InstanceKind<'tcx> {
                 coroutine_closure_def_id: def_id,
                 receiver_by_ref: _,
             }
+            | InstanceKind::Init(def_id, _)
             | InstanceKind::DropGlue(def_id, _)
             | InstanceKind::CloneShim(def_id, _)
             | InstanceKind::FnPtrAddrShim(def_id, _)
@@ -273,6 +279,7 @@ impl<'tcx> InstanceKind<'tcx> {
             | InstanceKind::AsyncDropGlueCtorShim(def_id, _)
             | InstanceKind::AsyncDropGlue(def_id, _)
             | InstanceKind::FutureDropPollShim(def_id, ..)
+            | InstanceKind::Init(def_id, _)
             | InstanceKind::ThreadLocalShim(def_id) => Some(def_id),
             InstanceKind::VTableShim(..)
             | InstanceKind::ReifyShim(..)
@@ -348,6 +355,7 @@ impl<'tcx> InstanceKind<'tcx> {
             | InstanceKind::ConstructCoroutineInClosureShim { .. }
             | InstanceKind::DropGlue(..)
             | InstanceKind::Item(_)
+            | InstanceKind::Init(..)
             | InstanceKind::Intrinsic(..)
             | InstanceKind::ReifyShim(..)
             | InstanceKind::Virtual(..)
@@ -426,6 +434,7 @@ pub fn fmt_instance(
         InstanceKind::FutureDropPollShim(_, proxy_ty, impl_ty) => {
             write!(f, " - dropshim({proxy_ty}-{impl_ty})")
         }
+        InstanceKind::Init(_, ty) => write!(f, " - init({ty})"),
         InstanceKind::AsyncDropGlue(_, ty) => write!(f, " - shim({ty})"),
         InstanceKind::AsyncDropGlueCtorShim(_, ty) => write!(f, " - shim(Some({ty}))"),
     }
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 809717513c795..9b45152bc8356 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -897,7 +897,7 @@ where
                 ty::Str => TyMaybeWithLayout::Ty(tcx.types.u8),
 
                 // Tuples, coroutines and closures.
-                ty::Closure(_, args) => field_ty_or_layout(
+                ty::Closure(_, args) | ty::Init(_, args) => field_ty_or_layout(
                     TyAndLayout { ty: args.as_closure().tupled_upvars_ty(), ..this },
                     cx,
                     i,
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index a7cde2ad48547..7e9e0e9860ea1 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1765,6 +1765,7 @@ impl<'tcx> TyCtxt<'tcx> {
             | ty::InstanceKind::CloneShim(..)
             | ty::InstanceKind::ThreadLocalShim(..)
             | ty::InstanceKind::FnPtrAddrShim(..)
+            | ty::InstanceKind::Init(..)
             | ty::InstanceKind::AsyncDropGlueCtorShim(..)
             | ty::InstanceKind::AsyncDropGlue(..) => self.mir_shims(instance),
         }
@@ -2143,6 +2144,11 @@ impl<'tcx> TyCtxt<'tcx> {
                 // for `[const]` bounds.
                 false
             }
+            DefKind::Init => {
+                // This depends on further design and whether Closure/RPITs
+                // would receive `~const` bounds.
+                false
+            }
             DefKind::Ctor(_, CtorKind::Const)
             | DefKind::Impl { of_trait: false }
             | DefKind::Mod
diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
index 9172c5d3ab752..2e2c2557392ca 100644
--- a/compiler/rustc_middle/src/ty/print/mod.rs
+++ b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -288,6 +288,7 @@ fn characteristic_def_id_of_type_cached<'a>(
         | ty::CoroutineClosure(def_id, _)
         | ty::Coroutine(def_id, _)
         | ty::CoroutineWitness(def_id, _)
+        | ty::Init(def_id, _)
         | ty::Foreign(def_id) => Some(def_id),
 
         ty::Bool
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 9ee64df0ad065..9cdee8738b509 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -942,7 +942,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
 
                 p!("}}")
             }
-            ty::Closure(did, args) => {
+            // NOTE: Maybe in the future, give init its own pretty print type header
+            ty::Closure(did, args) | ty::Init(did, args) => {
                 p!(write("{{"));
                 if !self.should_print_verbose() {
                     p!(write("closure"));
diff --git a/compiler/rustc_middle/src/ty/significant_drop_order.rs b/compiler/rustc_middle/src/ty/significant_drop_order.rs
index 5ada9ecc80cf3..8f7e983bc8105 100644
--- a/compiler/rustc_middle/src/ty/significant_drop_order.rs
+++ b/compiler/rustc_middle/src/ty/significant_drop_order.rs
@@ -153,6 +153,7 @@ pub fn ty_dtor_span<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Span> {
         | ty::CoroutineWitness(did, _)
         | ty::CoroutineClosure(did, _)
         | ty::Closure(did, _)
+        | ty::Init(did, _)
         | ty::FnDef(did, _)
         | ty::Foreign(did) => Some(tcx.def_span(did)),
         ty::Param(_) => None,
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index ab31d94340809..c69ac90a79d26 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -410,6 +410,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::CoroutineClosure(did, args) => {
                 ty::CoroutineClosure(did, args.try_fold_with(folder)?)
             }
+            ty::Init(did, args) => ty::Init(did, args.try_fold_with(folder)?),
             ty::Alias(kind, data) => ty::Alias(kind, data.try_fold_with(folder)?),
             ty::Pat(ty, pat) => ty::Pat(ty.try_fold_with(folder)?, pat.try_fold_with(folder)?),
 
@@ -449,6 +450,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::CoroutineWitness(did, args) => ty::CoroutineWitness(did, args.fold_with(folder)),
             ty::Closure(did, args) => ty::Closure(did, args.fold_with(folder)),
             ty::CoroutineClosure(did, args) => ty::CoroutineClosure(did, args.fold_with(folder)),
+            ty::Init(did, args) => ty::Init(did, args.fold_with(folder)),
             ty::Alias(kind, data) => ty::Alias(kind, data.fold_with(folder)),
             ty::Pat(ty, pat) => ty::Pat(ty.fold_with(folder), pat.fold_with(folder)),
 
@@ -495,7 +497,7 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
             }
             ty::Coroutine(_did, args) => args.visit_with(visitor),
             ty::CoroutineWitness(_did, args) => args.visit_with(visitor),
-            ty::Closure(_did, args) => args.visit_with(visitor),
+            ty::Closure(_did, args) | ty::Init(_did, args) => args.visit_with(visitor),
             ty::CoroutineClosure(_did, args) => args.visit_with(visitor),
             ty::Alias(_, data) => data.visit_with(visitor),
 
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 8bb3b3f1263fa..30585ea6b2948 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -657,6 +657,7 @@ impl<'tcx> Ty<'tcx> {
                 | DefKind::GlobalAsm
                 | DefKind::Impl { .. }
                 | DefKind::Closure
+                | DefKind::Init
                 | DefKind::SyntheticCoroutineBody => {
                     bug!("not an adt: {def:?} ({:?})", tcx.def_kind(def.did()))
                 }
@@ -796,6 +797,12 @@ impl<'tcx> Ty<'tcx> {
         Ty::new(tcx, Closure(def_id, closure_args))
     }
 
+    #[inline]
+    pub fn new_init(tcx: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>) -> Ty<'tcx> {
+        tcx.debug_assert_args_compatible(def_id, args);
+        Ty::new(tcx, Init(def_id, args))
+    }
+
     #[inline]
     pub fn new_coroutine_closure(
         tcx: TyCtxt<'tcx>,
@@ -975,6 +982,10 @@ impl<'tcx> rustc_type_ir::inherent::Ty<TyCtxt<'tcx>> for Ty<'tcx> {
         Ty::new_closure(interner, def_id, args)
     }
 
+    fn new_init(interner: TyCtxt<'tcx>, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> Self {
+        Ty::new_init(interner, def_id, args)
+    }
+
     fn new_coroutine_witness(
         interner: TyCtxt<'tcx>,
         def_id: DefId,
@@ -1579,6 +1590,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::FnPtr(..)
             | ty::Dynamic(..)
             | ty::Closure(..)
+            | ty::Init(..)
             | ty::CoroutineClosure(..)
             | ty::CoroutineWitness(..)
             | ty::Never
@@ -1615,7 +1627,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::RawPtr(..)
             | ty::Char
             | ty::Ref(..)
-            | ty::Coroutine(..)
+            | ty::Coroutine(..)|ty::Init(..)
             | ty::CoroutineWitness(..)
             | ty::Array(..)
             | ty::Closure(..)
@@ -1807,6 +1819,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Char
             | ty::Ref(..)
             | ty::Coroutine(..)
+            | ty::Init(..)
             | ty::CoroutineWitness(..)
             | ty::Array(..)
             | ty::Pat(..)
@@ -1886,7 +1899,7 @@ impl<'tcx> Ty<'tcx> {
             ty::Coroutine(..) | ty::CoroutineWitness(..) => false,
 
             // Might be, but not "trivial" so just giving the safe answer.
-            ty::Adt(..) | ty::Closure(..) | ty::CoroutineClosure(..) => false,
+            ty::Adt(..) | ty::Closure(..) | ty::CoroutineClosure(..) | ty::Init(..) => false,
 
             ty::UnsafeBinder(_) => false,
 
@@ -1940,6 +1953,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::Init(_, _)
             | ty::Alias(..)
             | ty::Error(_) => false,
         }
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 174892c6f4d2c..696831deda090 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -599,11 +599,11 @@ impl<'tcx> TyCtxt<'tcx> {
     /// have the same `DefKind`.
     ///
     /// Note that closures have a `DefId`, but the closure *expression* also has a
-    // `HirId` that is located within the context where the closure appears (and, sadly,
-    // a corresponding `NodeId`, since those are not yet phased out). The parent of
-    // the closure's `DefId` will also be the context where it appears.
+    /// `HirId` that is located within the context where the closure appears (and, sadly,
+    /// a corresponding `NodeId`, since those are not yet phased out). The parent of
+    /// the closure's `DefId` will also be the context where it appears.
     pub fn is_closure_like(self, def_id: DefId) -> bool {
-        matches!(self.def_kind(def_id), DefKind::Closure)
+        matches!(self.def_kind(def_id), DefKind::Closure | DefKind::Init)
     }
 
     /// Returns `true` if `def_id` refers to a definition that does not have its own
@@ -611,7 +611,10 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn is_typeck_child(self, def_id: DefId) -> bool {
         matches!(
             self.def_kind(def_id),
-            DefKind::Closure | DefKind::InlineConst | DefKind::SyntheticCoroutineBody
+            DefKind::Closure
+                | DefKind::Init
+                | DefKind::InlineConst
+                | DefKind::SyntheticCoroutineBody
         )
     }
 
@@ -1175,6 +1178,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Bound(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Dynamic(..)
             | ty::Foreign(_)
             | ty::Coroutine(..)
@@ -1211,6 +1215,11 @@ impl<'tcx> Ty<'tcx> {
             | ty::Error(_)
             | ty::FnPtr(..) => true,
             ty::Tuple(fields) => fields.iter().all(Self::is_trivially_unpin),
+            ty::Init(..) => {
+                // This is subject to further design.
+                // Here we will keep conservative.
+                true
+            }
             ty::Pat(ty, _) | ty::Slice(ty) | ty::Array(ty, _) => ty.is_trivially_unpin(),
             ty::Adt(..)
             | ty::Bound(..)
@@ -1270,6 +1279,7 @@ impl<'tcx> Ty<'tcx> {
             ty::Adt(..)
             | ty::Bound(..)
             | ty::Closure(..)
+            | ty::Init(..)
             | ty::CoroutineClosure(..)
             | ty::Dynamic(..)
             | ty::Foreign(_)
@@ -1432,6 +1442,7 @@ impl<'tcx> Ty<'tcx> {
             ty::FnDef(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Dynamic(..)
             | ty::Coroutine(..) => false,
 
@@ -1554,6 +1565,7 @@ pub fn needs_drop_components_with_async<'tcx>(
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
         | ty::CoroutineWitness(..)
+        | ty::Init(..)
         | ty::UnsafeBinder(_) => Ok(smallvec![ty]),
     }
 }
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index b694409f327bd..c951dc7b30e63 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -706,6 +706,10 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 }
             },
 
+            hir::ExprKind::InitBlock(_) | hir::ExprKind::InitTail(_) => {
+                todo!("pinit: please implement thir")
+            }
+
             hir::ExprKind::Closure(hir::Closure { .. }) => {
                 let closure_ty = self.typeck_results.expr_ty(expr);
                 let (def_id, args, movability) = match *closure_ty.kind() {
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 8bbc89fdcecb7..69ab874295a0d 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -158,6 +158,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::CoroutineClosure(..)
                     | ty::Coroutine(_, _)
                     | ty::CoroutineWitness(..)
+                    | ty::Init(..)
                     | ty::Never
                     | ty::Tuple(_)
                     | ty::UnsafeBinder(_)
@@ -182,7 +183,8 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     ty::Closure(..)
                     | ty::CoroutineClosure(..)
                     | ty::Coroutine(_, _)
-                    | ty::Tuple(_) => (),
+                    | ty::Tuple(_)
+                    | ty::Init(..) => {}
                     ty::Bool
                     | ty::Char
                     | ty::Int(_)
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index fe53de31f7583..e1c456eeb8405 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -947,6 +947,7 @@ fn try_write_constant<'tcx>(
         | ty::Param(_)
         | ty::Bound(..)
         | ty::Placeholder(..)
+        | ty::Init(..)
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 1c0fc7748675c..8c4c3d1ed7267 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -749,6 +749,8 @@ fn check_mir_is_available<'tcx, I: Inliner<'tcx>>(
             };
         }
 
+        InstanceKind::Init(_, _) => return Err("pinit: please implement inlining"),
+
         // This cannot result in an immediate cycle since the callee MIR is a shim, which does
         // not get any optimizations run on it. Any subsequent inlining may cause cycles, but we
         // do not need to catch this here, we can wait until the inliner decides to continue
diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
index 7f9234d1dc891..096a8907f6c65 100644
--- a/compiler/rustc_mir_transform/src/inline/cycle.rs
+++ b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -32,6 +32,7 @@ fn should_recurse<'tcx>(tcx: TyCtxt<'tcx>, callee: ty::Instance<'tcx>) -> bool {
         | InstanceKind::ClosureOnceShim { .. }
         | InstanceKind::ConstructCoroutineInClosureShim { .. }
         | InstanceKind::ThreadLocalShim { .. }
+        | InstanceKind::Init(_, _)
         | InstanceKind::CloneShim(..) => {}
 
         // This shim does not call any other functions, thus there can be no recursion.
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index 6c65b072bec08..21b6ad87ce7a7 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -165,6 +165,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
         ty::InstanceKind::ThreadLocalShim(..) => build_thread_local_shim(tcx, instance),
         ty::InstanceKind::CloneShim(def_id, ty) => build_clone_shim(tcx, def_id, ty),
         ty::InstanceKind::FnPtrAddrShim(def_id, ty) => build_fn_ptr_addr_shim(tcx, def_id, ty),
+        ty::InstanceKind::Init(_, _) => todo!("dxf implement shim"),
         ty::InstanceKind::FutureDropPollShim(def_id, proxy_ty, impl_ty) => {
             let mut body =
                 async_destructor_ctor::build_future_drop_poll_shim(tcx, def_id, proxy_ty, impl_ty);
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 91c8e64ce9afe..7ee6ca7566bca 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -956,7 +956,8 @@ fn visit_instance_use<'tcx>(
                 output.push(create_fn_mono_item(tcx, instance, source));
             }
         }
-        ty::InstanceKind::DropGlue(_, Some(_))
+        ty::InstanceKind::Init(_, _)
+        | ty::InstanceKind::DropGlue(_, Some(_))
         | ty::InstanceKind::FutureDropPollShim(..)
         | ty::InstanceKind::AsyncDropGlue(_, _)
         | ty::InstanceKind::AsyncDropGlueCtorShim(_, _)
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 69851511fb1f4..35fc36b7a5056 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -645,6 +645,7 @@ fn characteristic_def_id_of_mono_item<'tcx>(
                 | ty::InstanceKind::CloneShim(..)
                 | ty::InstanceKind::ThreadLocalShim(..)
                 | ty::InstanceKind::FnPtrAddrShim(..)
+                | ty::InstanceKind::Init(..)
                 | ty::InstanceKind::FutureDropPollShim(..)
                 | ty::InstanceKind::AsyncDropGlue(..)
                 | ty::InstanceKind::AsyncDropGlueCtorShim(..) => return None,
@@ -814,6 +815,7 @@ fn mono_item_visibility<'tcx>(
         | InstanceKind::FnPtrShim(..)
         | InstanceKind::Virtual(..)
         | InstanceKind::Intrinsic(..)
+        | InstanceKind::Init(_, _)
         | InstanceKind::ClosureOnceShim { .. }
         | InstanceKind::ConstructCoroutineInClosureShim { .. }
         | InstanceKind::DropGlue(..)
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index a418aa82100c4..d1a29e36edb9d 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -369,6 +369,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             | ty::UnsafeBinder(_)
             | ty::Dynamic(_, _, _)
             | ty::Closure(..)
+            | ty::Init(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
             | ty::CoroutineWitness(..)
diff --git a/compiler/rustc_next_trait_solver/src/coherence.rs b/compiler/rustc_next_trait_solver/src/coherence.rs
index f8215a228f5b6..6e3739abcabed 100644
--- a/compiler/rustc_next_trait_solver/src/coherence.rs
+++ b/compiler/rustc_next_trait_solver/src/coherence.rs
@@ -435,7 +435,7 @@ where
                 }
             }
             ty::Error(_) => ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty)),
-            ty::Closure(did, ..) | ty::CoroutineClosure(did, ..) | ty::Coroutine(did, ..) => {
+            ty::Closure(did, ..) | ty::CoroutineClosure(did, ..) | ty::Init(did, ..) | ty::Coroutine(did, ..) => {
                 if self.def_id_is_local(did) {
                     ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
                 } else {
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
index c281ef216c788..e4bed1e746cce 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -632,6 +632,8 @@ where
                 panic!("unexpected self type for `{goal:?}`")
             }
 
+            ty::Init(..) => todo!(),
+
             ty::Infer(ty::TyVar(_)) => {
                 // If we hit infer when normalizing the self type of an alias,
                 // then bail with ambiguity. We should never encounter this on
@@ -732,6 +734,7 @@ where
             | ty::FnPtr(..)
             | ty::UnsafeBinder(_)
             | ty::Alias(..)
+            | ty::Init(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index c0bebdf6fb639..08b0d5eb18624 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -69,7 +69,9 @@ where
             Ok(ty::Binder::dummy(tys.to_vec()))
         }
 
-        ty::Closure(_, args) => Ok(ty::Binder::dummy(vec![args.as_closure().tupled_upvars_ty()])),
+        ty::Closure(_, args) | ty::Init(_, args) => {
+            Ok(ty::Binder::dummy(vec![args.as_closure().tupled_upvars_ty()]))
+        }
 
         ty::CoroutineClosure(_, args) => {
             Ok(ty::Binder::dummy(vec![args.as_coroutine_closure().tupled_upvars_ty()]))
@@ -134,6 +136,7 @@ where
         | ty::Pat(..)
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
+        | ty::Init(..)
         | ty::Never
         | ty::Error(_) => Ok(ty::Binder::dummy(vec![])),
 
@@ -231,7 +234,9 @@ where
         ty::Tuple(tys) => Ok(ty::Binder::dummy(tys.to_vec())),
 
         // impl Copy/Clone for Closure where Self::TupledUpvars: Copy/Clone
-        ty::Closure(_, args) => Ok(ty::Binder::dummy(vec![args.as_closure().tupled_upvars_ty()])),
+        ty::Closure(_, args) | ty::Init(_, args) => {
+            Ok(ty::Binder::dummy(vec![args.as_closure().tupled_upvars_ty()]))
+        }
 
         // impl Copy/Clone for CoroutineClosure where Self::TupledUpvars: Copy/Clone
         ty::CoroutineClosure(_, args) => {
@@ -384,6 +389,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<I: Intern
         | ty::Dynamic(_, _, _)
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(..)
+        | ty::Init(..)
         | ty::Never
         | ty::Tuple(_)
         | ty::Pat(_, _)
@@ -558,6 +564,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
         | ty::Dynamic(_, _, _)
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(..)
+        | ty::Init(..)
         | ty::Never
         | ty::UnsafeBinder(_)
         | ty::Tuple(_)
@@ -707,6 +714,7 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
         | ty::Dynamic(_, _, _)
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(..)
+        | ty::Init(..)
         | ty::Never
         | ty::Tuple(_)
         | ty::Pat(_, _)
@@ -790,6 +798,8 @@ pub(in crate::solve) fn const_conditions_for_destruct<I: Interner>(
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(_, _) => Err(NoSolution),
 
+        ty::Init(..) => Err(NoSolution),
+
         // FIXME(unsafe_binders): Unsafe binders could implement `[const] Drop`
         // if their inner type implements it.
         ty::UnsafeBinder(_) => Err(NoSolution),
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index 1e0a90eb2eefe..f7b036aad3e1d 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -653,6 +653,7 @@ where
             | ty::FnPtr(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Infer(ty::IntVar(..) | ty::FloatVar(..))
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
@@ -907,6 +908,7 @@ where
             | ty::FnPtr(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Infer(ty::IntVar(..) | ty::FloatVar(..))
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index 650b85d99d2cd..dd35fd66c43c1 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -737,6 +737,7 @@ where
                 | ty::Placeholder(..)
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)
+                | ty::Init(..)
                 | ty::Coroutine(..)
                 | ty::UnsafeBinder(_)
                 | ty::CoroutineWitness(..) => {
@@ -1238,6 +1239,7 @@ where
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Never
             | ty::Tuple(_)
             | ty::Adt(_, _)
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 3d89530f91435..8fe24a2df1535 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -16,8 +16,8 @@ use rustc_ast::visit::{Visitor, walk_expr};
 use rustc_ast::{
     self as ast, AnonConst, Arm, AssignOp, AssignOpKind, AttrStyle, AttrVec, BinOp, BinOpKind,
     BlockCheckMode, CaptureBy, ClosureBinder, DUMMY_NODE_ID, Expr, ExprField, ExprKind, FnDecl,
-    FnRetTy, Label, MacCall, MetaItemLit, Movability, Param, RangeLimits, StmtKind, Ty, TyKind,
-    UnOp, UnsafeBinderCastKind, YieldKind,
+    FnRetTy, InitBlock, InitKind, Label, MacCall, MetaItemLit, Movability, Param, RangeLimits,
+    StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
 };
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::{Applicability, Diag, PResult, StashKey, Subdiagnostic};
@@ -1462,6 +1462,8 @@ impl<'a> Parser<'a> {
                 this.parse_expr_array_or_repeat(exp!(CloseBracket))
             } else if this.is_builtin() {
                 this.parse_expr_builtin()
+            } else if this.check_init_block() {
+                this.parse_init_block()
             } else if this.check_path() {
                 this.parse_expr_path_start()
             } else if this.check_keyword(exp!(Move))
@@ -1594,9 +1596,18 @@ impl<'a> Parser<'a> {
         let lo = self.token.span;
         self.bump(); // `[` or other open delim
 
-        let kind = if self.eat(close) {
+        let kind = self.parse_expr_array_or_repeat_inner(close)?;
+        let expr = self.mk_expr(lo.to(self.prev_token.span), kind);
+        self.maybe_recover_from_bad_qpath(expr)
+    }
+
+    fn parse_expr_array_or_repeat_inner(
+        &mut self,
+        close: ExpTokenPair<'_>,
+    ) -> PResult<'a, ExprKind> {
+        if self.eat(close) {
             // Empty vector
-            ExprKind::Array(ThinVec::new())
+            Ok(ExprKind::Array(ThinVec::new()))
         } else {
             // Non-empty vector
             let first_expr = self.parse_expr()?;
@@ -1604,21 +1615,19 @@ impl<'a> Parser<'a> {
                 // Repeating array syntax: `[ 0; 512 ]`
                 let count = self.parse_expr_anon_const()?;
                 self.expect(close)?;
-                ExprKind::Repeat(first_expr, count)
+                Ok(ExprKind::Repeat(first_expr, count))
             } else if self.eat(exp!(Comma)) {
                 // Vector with two or more elements.
                 let sep = SeqSep::trailing_allowed(exp!(Comma));
                 let (mut exprs, _) = self.parse_seq_to_end(close, sep, |p| p.parse_expr())?;
                 exprs.insert(0, first_expr);
-                ExprKind::Array(exprs)
+                Ok(ExprKind::Array(exprs))
             } else {
                 // Vector with one element
                 self.expect(close)?;
-                ExprKind::Array(thin_vec![first_expr])
+                Ok(ExprKind::Array(thin_vec![first_expr]))
             }
-        };
-        let expr = self.mk_expr(lo.to(self.prev_token.span), kind);
-        self.maybe_recover_from_bad_qpath(expr)
+        }
     }
 
     fn parse_expr_path_start(&mut self) -> PResult<'a, P<Expr>> {
@@ -2487,6 +2496,53 @@ impl<'a> Parser<'a> {
         Ok(closure)
     }
 
+    /// Parse the tokens following `init # ..`
+    pub(crate) fn parse_init_block(&mut self) -> PResult<'a, P<Expr>> {
+        let init_kw_span = self.token.span;
+        if !self.eat_keyword(exp!(Init)) || !self.eat_noexpect(&TokenKind::Pound) {
+            unreachable!()
+        }
+
+        let expr = self.with_res(self.restrictions - Restrictions::ALLOW_LET, |this| {
+            if this.check(exp!(OpenBracket)) {
+this.bump();
+                match this.parse_expr_array_or_repeat_inner(exp!(CloseBracket))? {
+                    ExprKind::Array(exprs) => {
+                        let span = init_kw_span.to(this.prev_token.span);
+                        self.psess.gated_spans.gate(sym::in_place_initialization, span);
+                        Ok(this.mk_expr(
+                            span,
+                            ExprKind::InitTail(P(InitKind::Array(exprs))),
+                        ))
+                    },
+                    ExprKind::Repeat(_expr, _konst) => todo!("pinit: implement the repeat syntax"),
+                    _ => unreachable!(),
+                }
+            } else if this.check(exp!(OpenParen)) {
+                this.bump();
+                todo!("pinit: this is the path to parsing a tuple")
+            } else if this.check_path() {
+                todo!("pinit: this is the path to parsing a struct with `init` syntax, with unnamed values")
+            } else {
+                let expr = this.parse_expr_bottom()?;
+                let span = init_kw_span.to(this.prev_token.span);
+                self.psess.gated_spans.gate(sym::in_place_initialization, span);
+                Ok(this.mk_expr(span, ExprKind::InitTail(P(InitKind::Free(expr)))))
+            }
+        })?;
+        Ok(self.mk_expr(
+            expr.span,
+            ExprKind::InitBlock(P(InitBlock {
+                init_kw_span,
+                expr,
+                fn_decl: P(FnDecl {
+                    inputs: Default::default(),
+                    output: FnRetTy::Default(init_kw_span.shrink_to_hi()),
+                }),
+            })),
+        ))
+    }
+
     /// If an explicit return type is given, require a block to appear (RFC 968).
     fn parse_closure_block_body(&mut self, ret_span: Span) -> PResult<'a, P<Expr>> {
         if self.may_recover()
@@ -4199,6 +4255,8 @@ impl MutVisitor for CondChecker<'_> {
             | ExprKind::Loop(_, _, _)
             | ExprKind::Match(_, _, _)
             | ExprKind::Closure(_)
+            | ExprKind::InitBlock(_)
+            | ExprKind::InitTail(_)
             | ExprKind::Block(_, _)
             | ExprKind::Gen(_, _, _, _)
             | ExprKind::TryBlock(_)
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 90491e5324912..4941f7395e920 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -727,6 +727,11 @@ impl<'a> Parser<'a> {
             })
     }
 
+    fn check_init_block(&self) -> bool {
+        self.look_ahead(0, |t| matches!(t.kind, token::Ident(sym::init, IdentIsRaw::No)))
+            && self.look_ahead(1, |t| matches!(t.kind, token::Pound))
+    }
+
     fn check_inline_const(&self, dist: usize) -> bool {
         self.is_keyword_ahead(dist, &[kw::Const])
             && self.look_ahead(dist + 1, |t| match &t.kind {
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 2fa6520f2a42a..4e70a14e01470 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -194,6 +194,14 @@ impl<'a> Parser<'a> {
 
     fn parse_stmt_path_start(&mut self, lo: Span, attrs: AttrWrapper) -> PResult<'a, Stmt> {
         let stmt = self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
+            if this.check_init_block() {
+                let expr = this.parse_init_block()?;
+                return Ok((
+                    this.mk_stmt(rustc_span::DUMMY_SP, StmtKind::Expr(expr)),
+                    Trailing::No,
+                    UsePreAttrPos::No,
+                ));
+            }
             let path = this.parse_path(PathStyle::Expr)?;
 
             if this.eat(exp!(Bang)) {
diff --git a/compiler/rustc_parse/src/parser/token_type.rs b/compiler/rustc_parse/src/parser/token_type.rs
index b91548196a305..53d9870c8b449 100644
--- a/compiler/rustc_parse/src/parser/token_type.rs
+++ b/compiler/rustc_parse/src/parser/token_type.rs
@@ -130,6 +130,7 @@ pub enum TokenType {
     // tidy-alphabetical-start
     SymAttSyntax,
     SymClobberAbi,
+    SymInit,
     SymInlateout,
     SymInout,
     SymIs,
@@ -556,6 +557,7 @@ macro_rules! exp {
     (Inlateout)      => { exp!(@sym, inlateout,       SymInlateout) };
     (Inout)          => { exp!(@sym, inout,           SymInout) };
     (Is)             => { exp!(@sym, is,              SymIs) };
+    (Init)           => { exp!(@sym, init,            SymInit) };
     (Label)          => { exp!(@sym, label,           SymLabel) };
     (Lateout)        => { exp!(@sym, lateout,         SymLateout) };
     (MayUnwind)      => { exp!(@sym, may_unwind,      SymMayUnwind) };
diff --git a/compiler/rustc_passes/src/check_export.rs b/compiler/rustc_passes/src/check_export.rs
index b1f4584c2a88a..f1ef1d93db283 100644
--- a/compiler/rustc_passes/src/check_export.rs
+++ b/compiler/rustc_passes/src/check_export.rs
@@ -294,6 +294,7 @@ impl<'tcx, 'a> TypeVisitor<TyCtxt<'tcx>> for ExportableItemsChecker<'tcx, 'a> {
             | ty::Ref(_, _, _)
             | ty::Param(_)
             | ty::Closure(_, _)
+            | ty::Init(_, _)
             | ty::Dynamic(_, _, _)
             | ty::Coroutine(_, _)
             | ty::Foreign(_)
diff --git a/compiler/rustc_passes/src/input_stats.rs b/compiler/rustc_passes/src/input_stats.rs
index 6ee325dce0326..544441db842e9 100644
--- a/compiler/rustc_passes/src/input_stats.rs
+++ b/compiler/rustc_passes/src/input_stats.rs
@@ -363,6 +363,8 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
                 Loop,
                 Match,
                 Closure,
+                InitBlock,
+                InitTail,
                 Block,
                 Assign,
                 AssignOp,
@@ -659,7 +661,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
                 If, While, ForLoop, Loop, Match, Closure, Block, Await, Use, TryBlock, Assign,
                 AssignOp, Field, Index, Range, Underscore, Path, AddrOf, Break, Continue, Ret,
                 InlineAsm, FormatArgs, OffsetOf, MacCall, Struct, Repeat, Paren, Try, Yield, Yeet,
-                Become, IncludedBytes, Gen, UnsafeBinderCast, Err, Dummy
+                Become, IncludedBytes, Gen, UnsafeBinderCast, InitBlock, InitTail, Err, Dummy
             ]
         );
         ast_visit::walk_expr(self, e)
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 7350c6a5a82fc..ed38d3e0e895d 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -397,6 +397,8 @@ impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> {
                 }
                 self.set_captures(expr.hir_id, call_caps);
             }
+            hir::ExprKind::InitBlock(_block) => todo!("dxf implement"),
+            hir::ExprKind::InitTail(_) => intravisit::walk_expr(self, expr),
 
             hir::ExprKind::Let(let_expr) => {
                 self.add_from_pat(let_expr.pat);
@@ -854,11 +856,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
             hir::ExprKind::Field(ref e, _) => self.propagate_through_expr(e, succ),
 
-            hir::ExprKind::Closure { .. } => {
-                debug!("{:?} is an ExprKind::Closure", expr);
+            hir::ExprKind::Closure { .. } | hir::ExprKind::InitBlock(_) => {
+                debug!("{:?} is an ExprKind::Closure or ExprKind::InitBlock", expr);
 
                 // the construction of a closure itself is not important,
-                // but we have to consider the closed over variables.
+                // but we have to consider the captured variables.
                 let caps = self
                     .ir
                     .capture_info_map
@@ -1007,9 +1009,12 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             }
 
             // Uninteresting cases: just propagate in rev exec order
-            hir::ExprKind::Array(exprs) => self.propagate_through_exprs(exprs, succ),
+            hir::ExprKind::InitTail(&hir::InitKind::Array(exprs)) | hir::ExprKind::Array(exprs) => {
+                self.propagate_through_exprs(exprs, succ)
+            }
 
-            hir::ExprKind::Struct(_, fields, ref with_expr) => {
+            hir::ExprKind::InitTail(&hir::InitKind::Struct(_, fields, ref with_expr))
+            | hir::ExprKind::Struct(_, fields, ref with_expr) => {
                 let succ = match with_expr {
                     hir::StructTailExpr::Base(base) => {
                         self.propagate_through_opt_expr(Some(base), succ)
@@ -1022,6 +1027,14 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                     .fold(succ, |succ, field| self.propagate_through_expr(field.expr, succ))
             }
 
+            hir::ExprKind::InitTail(&hir::InitKind::Free(expr)) => {
+                self.propagate_through_expr(expr, succ)
+            }
+
+            hir::ExprKind::InitTail(&hir::InitKind::Block(blk, _opt_label)) => {
+                self.propagate_through_block(blk, succ)
+            }
+
             hir::ExprKind::Call(ref f, args) => {
                 let is_ctor = |f: &Expr<'_>| matches!(f.kind, hir::ExprKind::Path(hir::QPath::Resolved(_, path)) if matches!(path.res, rustc_hir::def::Res::Def(rustc_hir::def::DefKind::Ctor(_, _), _)));
                 let succ =
@@ -1042,7 +1055,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                 self.propagate_through_expr(expr, succ)
             }
 
-            hir::ExprKind::Tup(exprs) => self.propagate_through_exprs(exprs, succ),
+            hir::ExprKind::InitTail(&hir::InitKind::Tuple(exprs)) | hir::ExprKind::Tup(exprs) => {
+                self.propagate_through_exprs(exprs, succ)
+            }
 
             hir::ExprKind::Binary(op, ref l, ref r) if op.node.is_lazy() => {
                 let r_succ = self.propagate_through_expr(r, succ);
@@ -1059,13 +1074,14 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                 self.propagate_through_expr(l, r_succ)
             }
 
-            hir::ExprKind::AddrOf(_, _, ref e)
-            | hir::ExprKind::Cast(ref e, _)
-            | hir::ExprKind::Type(ref e, _)
-            | hir::ExprKind::UnsafeBinderCast(_, ref e, _)
-            | hir::ExprKind::DropTemps(ref e)
-            | hir::ExprKind::Unary(_, ref e)
-            | hir::ExprKind::Repeat(ref e, _) => self.propagate_through_expr(e, succ),
+            hir::ExprKind::AddrOf(_, _, e)
+            | hir::ExprKind::Cast(e, _)
+            | hir::ExprKind::Type(e, _)
+            | hir::ExprKind::UnsafeBinderCast(_, e, _)
+            | hir::ExprKind::DropTemps(e)
+            | hir::ExprKind::Unary(_, e)
+            | hir::ExprKind::InitTail(&hir::InitKind::Repeat(e, _))
+            | hir::ExprKind::Repeat(e, _) => self.propagate_through_expr(e, succ),
 
             hir::ExprKind::InlineAsm(asm) => {
                 //
@@ -1453,6 +1469,8 @@ fn check_expr<'tcx>(this: &mut Liveness<'_, 'tcx>, expr: &'tcx Expr<'tcx>) {
         | hir::ExprKind::Struct(..)
         | hir::ExprKind::Repeat(..)
         | hir::ExprKind::Closure { .. }
+        | hir::ExprKind::InitBlock(..)
+        | hir::ExprKind::InitTail(..)
         | hir::ExprKind::Path(_)
         | hir::ExprKind::Yield(..)
         | hir::ExprKind::Type(..)
diff --git a/compiler/rustc_passes/src/upvars.rs b/compiler/rustc_passes/src/upvars.rs
index fae88fbba3604..b71333f8c679d 100644
--- a/compiler/rustc_passes/src/upvars.rs
+++ b/compiler/rustc_passes/src/upvars.rs
@@ -10,30 +10,32 @@ use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
 
 pub(crate) fn provide(providers: &mut Providers) {
-    providers.upvars_mentioned = |tcx, def_id| {
-        if !tcx.is_closure_like(def_id) {
-            return None;
-        }
+    providers.upvars_mentioned = upvars_mentioned;
+}
 
-        let local_def_id = def_id.expect_local();
-        let body = tcx.hir_maybe_body_owned_by(local_def_id)?;
+fn upvars_mentioned<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: hir::def_id::DefId,
+) -> Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>> {
+    if !tcx.is_closure_like(def_id) {
+        return None;
+    }
 
-        let mut local_collector = LocalCollector::default();
-        local_collector.visit_body(&body);
+    let local_def_id = def_id.expect_local();
+    let body = tcx.hir_maybe_body_owned_by(local_def_id)?;
 
-        let mut capture_collector = CaptureCollector {
-            tcx,
-            locals: &local_collector.locals,
-            upvars: FxIndexMap::default(),
-        };
-        capture_collector.visit_body(&body);
+    let mut local_collector = LocalCollector::default();
+    local_collector.visit_body(&body);
 
-        if !capture_collector.upvars.is_empty() {
-            Some(tcx.arena.alloc(capture_collector.upvars))
-        } else {
-            None
-        }
-    };
+    let mut capture_collector =
+        CaptureCollector { tcx, locals: &local_collector.locals, upvars: FxIndexMap::default() };
+    capture_collector.visit_body(&body);
+
+    if !capture_collector.upvars.is_empty() {
+        Some(tcx.arena.alloc(capture_collector.upvars))
+    } else {
+        None
+    }
 }
 
 #[derive(Default)]
@@ -75,8 +77,10 @@ impl<'tcx> Visitor<'tcx> for CaptureCollector<'_, 'tcx> {
     }
 
     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
-        if let hir::ExprKind::Closure(closure) = expr.kind {
-            if let Some(upvars) = self.tcx.upvars_mentioned(closure.def_id) {
+        if let hir::ExprKind::Closure(&hir::Closure { def_id, .. })
+        | hir::ExprKind::InitBlock(&hir::InitBlock { def_id, .. }) = expr.kind
+        {
+            if let Some(upvars) = self.tcx.upvars_mentioned(def_id) {
                 // Every capture of a closure expression is a local in scope,
                 // that is moved/copied/borrowed into the closure value, and
                 // for this analysis they are like any other access to a local.
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 0c1b0d622f229..767d8c1610a4c 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -412,6 +412,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
+            | ty::Init(..)
             | ty::UnsafeBinder(_)
             | ty::Alias(_, _)
             | ty::Param(_)
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 9dd80bc99640b..a87048aebd673 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -188,7 +188,8 @@ where
             | ty::FnDef(def_id, ..)
             | ty::Closure(def_id, ..)
             | ty::CoroutineClosure(def_id, ..)
-            | ty::Coroutine(def_id, ..) => {
+            | ty::Coroutine(def_id, ..)
+            | ty::Init(def_id, ..) => {
                 try_visit!(self.def_id_visitor.visit_def_id(def_id, "type", &ty));
                 if V::SHALLOW {
                     return V::Result::output();
@@ -638,6 +639,7 @@ impl<'tcx> EmbargoVisitor<'tcx> {
             | DefKind::GlobalAsm
             | DefKind::Impl { .. }
             | DefKind::Closure
+            | DefKind::Init
             | DefKind::SyntheticCoroutineBody => (),
         }
     }
diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
index 5a09c3b24f0f1..4af86a66fad01 100644
--- a/compiler/rustc_public/src/compiler_interface.rs
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -47,6 +47,7 @@ impl Bridge for BridgeTys {
     type ForeignDef = crate::ty::ForeignDef;
     type FnDef = crate::ty::FnDef;
     type ClosureDef = crate::ty::ClosureDef;
+    type InitDef = crate::ty::InitDef;
     type CoroutineDef = crate::ty::CoroutineDef;
     type CoroutineClosureDef = crate::ty::CoroutineClosureDef;
     type AliasDef = crate::ty::AliasDef;
diff --git a/compiler/rustc_public/src/lib.rs b/compiler/rustc_public/src/lib.rs
index 958b3b2647889..15a4f27f0fb4b 100644
--- a/compiler/rustc_public/src/lib.rs
+++ b/compiler/rustc_public/src/lib.rs
@@ -258,6 +258,7 @@ bridge_impl!(ForeignModuleDef, crate::ty::ForeignModuleDef);
 bridge_impl!(ForeignDef, crate::ty::ForeignDef);
 bridge_impl!(FnDef, crate::ty::FnDef);
 bridge_impl!(ClosureDef, crate::ty::ClosureDef);
+bridge_impl!(InitDef, crate::ty::InitDef);
 bridge_impl!(CoroutineDef, crate::ty::CoroutineDef);
 bridge_impl!(CoroutineClosureDef, crate::ty::CoroutineClosureDef);
 bridge_impl!(AliasDef, crate::ty::AliasDef);
diff --git a/compiler/rustc_public/src/ty.rs b/compiler/rustc_public/src/ty.rs
index bc67a2f987d9e..e7bddcc618aee 100644
--- a/compiler/rustc_public/src/ty.rs
+++ b/compiler/rustc_public/src/ty.rs
@@ -563,6 +563,7 @@ pub enum RigidTy {
     // FIXME(rustc_public): Movability here is redundant
     Coroutine(CoroutineDef, GenericArgs, Movability),
     CoroutineClosure(CoroutineClosureDef, GenericArgs),
+    Init(InitDef, GenericArgs),
     Dynamic(Vec<Binder<ExistentialPredicate>>, Region, DynKind),
     Never,
     Tuple(Vec<Ty>),
@@ -756,6 +757,19 @@ impl ClosureDef {
     }
 }
 
+crate_def! {
+    #[derive(Serialize)]
+    pub InitDef;
+}
+
+impl InitDef {
+    /// Retrieves the body of the closure definition. Returns None if the body
+    /// isn't available.
+    pub fn body(&self) -> Option<Body> {
+        with(|ctx| ctx.has_body(self.0).then(|| ctx.mir_body(self.0)))
+    }
+}
+
 crate_def! {
     #[derive(Serialize)]
     pub CoroutineDef;
diff --git a/compiler/rustc_public/src/unstable/convert/internal.rs b/compiler/rustc_public/src/unstable/convert/internal.rs
index b2d38e497bc82..475abe78f1139 100644
--- a/compiler/rustc_public/src/unstable/convert/internal.rs
+++ b/compiler/rustc_public/src/unstable/convert/internal.rs
@@ -177,6 +177,9 @@ impl RustcInternal for RigidTy {
             RigidTy::Closure(def, args) => {
                 rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx))
             }
+            RigidTy::Init(def, args) => {
+                rustc_ty::TyKind::Init(def.0.internal(tables, tcx), args.internal(tables, tcx))
+            }
             RigidTy::Coroutine(def, args, _mov) => {
                 rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx))
             }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index d679615b3bdc9..86a1664e07c21 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -453,6 +453,10 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
                 tables.closure_def(*def_id),
                 generic_args.stable(tables, cx),
             )),
+            &ty::Init(def_id, generic_args) => TyKind::RigidTy(RigidTy::Init(
+                tables.init_def(def_id),
+                generic_args.stable(tables, cx),
+            )),
             ty::CoroutineClosure(..) => todo!("FIXME(async_closures): Lower these to SMIR"),
             ty::Coroutine(def_id, generic_args) => TyKind::RigidTy(RigidTy::Coroutine(
                 tables.coroutine_def(*def_id),
@@ -966,6 +970,7 @@ impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> {
             | ty::InstanceKind::DropGlue(..)
             | ty::InstanceKind::CloneShim(..)
             | ty::InstanceKind::FnPtrShim(..)
+            | ty::InstanceKind::Init(..)
             | ty::InstanceKind::FutureDropPollShim(..)
             | ty::InstanceKind::AsyncDropGlue(..)
             | ty::InstanceKind::AsyncDropGlueCtorShim(..) => crate::mir::mono::InstanceKind::Shim,
diff --git a/compiler/rustc_public/src/unstable/mod.rs b/compiler/rustc_public/src/unstable/mod.rs
index 72b14cfa072ae..4959721447222 100644
--- a/compiler/rustc_public/src/unstable/mod.rs
+++ b/compiler/rustc_public/src/unstable/mod.rs
@@ -112,9 +112,11 @@ pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind {
         | DefKind::GlobalAsm => {
             unreachable!("Not a valid item kind: {kind:?}");
         }
-        DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => {
-            ItemKind::Fn
-        }
+        DefKind::Closure
+        | DefKind::AssocFn
+        | DefKind::Fn
+        | DefKind::SyntheticCoroutineBody
+        | DefKind::Init => ItemKind::Fn,
         DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => {
             ItemKind::Const
         }
diff --git a/compiler/rustc_public/src/visitor.rs b/compiler/rustc_public/src/visitor.rs
index 45e2a81547085..25b68b85471e1 100644
--- a/compiler/rustc_public/src/visitor.rs
+++ b/compiler/rustc_public/src/visitor.rs
@@ -165,6 +165,7 @@ impl Visitable for RigidTy {
                 ty.visit(visitor)
             }
             RigidTy::Adt(_, args)
+            | RigidTy::Init(_, args)
             | RigidTy::Closure(_, args)
             | RigidTy::Coroutine(_, args, _)
             | RigidTy::CoroutineWitness(_, args)
diff --git a/compiler/rustc_public_bridge/src/bridge.rs b/compiler/rustc_public_bridge/src/bridge.rs
index d4f4847c8d3bd..6469a35dd73f9 100644
--- a/compiler/rustc_public_bridge/src/bridge.rs
+++ b/compiler/rustc_public_bridge/src/bridge.rs
@@ -43,6 +43,7 @@ make_bridge_trait!(ForeignModuleDef);
 make_bridge_trait!(ForeignDef);
 make_bridge_trait!(FnDef);
 make_bridge_trait!(ClosureDef);
+make_bridge_trait!(InitDef);
 make_bridge_trait!(CoroutineDef);
 make_bridge_trait!(CoroutineClosureDef);
 make_bridge_trait!(AliasDef);
diff --git a/compiler/rustc_public_bridge/src/lib.rs b/compiler/rustc_public_bridge/src/lib.rs
index dec3be70baff4..a2d200e85584d 100644
--- a/compiler/rustc_public_bridge/src/lib.rs
+++ b/compiler/rustc_public_bridge/src/lib.rs
@@ -143,6 +143,10 @@ impl<'tcx, B: Bridge> Tables<'tcx, B> {
         B::ClosureDef::new(self.create_def_id(did))
     }
 
+    pub fn init_def(&mut self, did: rustc_span::def_id::DefId) -> B::InitDef {
+        B::InitDef::new(self.create_def_id(did))
+    }
+
     pub fn coroutine_def(&mut self, did: rustc_span::def_id::DefId) -> B::CoroutineDef {
         B::CoroutineDef::new(self.create_def_id(did))
     }
@@ -229,6 +233,7 @@ pub trait Bridge: Sized {
     type ForeignDef: ForeignDef<Self>;
     type FnDef: FnDef<Self>;
     type ClosureDef: ClosureDef<Self>;
+    type InitDef: InitDef<Self>;
     type CoroutineDef: CoroutineDef<Self>;
     type CoroutineClosureDef: CoroutineClosureDef<Self>;
     type AliasDef: AliasDef<Self>;
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index fe7fa71a7fcb8..2471b756267ca 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -258,6 +258,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 | DefKind::LifetimeParam
                 | DefKind::GlobalAsm
                 | DefKind::Closure
+                | DefKind::Init
                 | DefKind::SyntheticCoroutineBody
                 | DefKind::Impl { .. },
                 _,
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index 7d51fef28d3ba..05110a010f4ad 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -365,6 +365,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             ExprKind::Closure(..) | ExprKind::Gen(..) => {
                 self.create_def(expr.id, None, DefKind::Closure, expr.span)
             }
+            ExprKind::InitBlock(..) => self.create_def(expr.id, None, DefKind::Init, expr.span),
             ExprKind::ConstBlock(ref constant) => {
                 for attr in &expr.attrs {
                     visit::walk_attribute(self, attr);
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
index f4a14b36ce5cf..4d1863ad20a6a 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
@@ -536,7 +536,7 @@ pub(crate) fn encode_ty<'tcx>(
         }
 
         // Function types
-        ty::FnDef(def_id, args) | ty::Closure(def_id, args) => {
+        ty::FnDef(def_id, args) | ty::Closure(def_id, args) | ty::Init(def_id, args) => {
             // u<length><name>[I<element-type1..element-typeN>E], where <element-type> is <subst>,
             // as vendor extended type.
             let mut s = String::new();
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
index c69991f3fb208..e15f686fe73eb 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -50,7 +50,8 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for TransformTy<'tcx> {
     // Transforms a ty:Ty for being encoded and used in the substitution dictionary.
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
         match t.kind() {
-            ty::Closure(..)
+            ty::Init(..)
+            | ty::Closure(..)
             | ty::Coroutine(..)
             | ty::CoroutineClosure(..)
             | ty::CoroutineWitness(..)
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index d54175548e30e..fab7a2d08c314 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1190,6 +1190,7 @@ symbols! {
         import_trait_associated_functions,
         imported_main,
         in_band_lifetimes,
+        in_place_initialization,
         include,
         include_bytes,
         include_bytes_macro,
@@ -1202,6 +1203,18 @@ symbols! {
         infer_static_outlives_requirements,
         inherent_associated_types,
         inherit,
+        init,
+        init_array_guard,
+        init_array_guard_bump,
+        init_array_guard_new,
+        init_array_guard_release,
+        init_error,
+        init_guard,
+        init_guard_new,
+        init_guard_release,
+        init_init,
+        init_layout,
+        init_trait,
         inlateout,
         inline,
         inline_const,
diff --git a/compiler/rustc_symbol_mangling/src/export.rs b/compiler/rustc_symbol_mangling/src/export.rs
index 956c996326bf9..ed7e9d0e533f2 100644
--- a/compiler/rustc_symbol_mangling/src/export.rs
+++ b/compiler/rustc_symbol_mangling/src/export.rs
@@ -118,6 +118,7 @@ impl<'tcx> AbiHashStable<'tcx> for Ty<'tcx> {
             | ty::FnDef(_, _)
             | ty::FnPtr(_, _)
             | ty::Dynamic(_, _, _)
+            | ty::Init(_, _)
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index fe0f8e6113ef7..e986bdf84daab 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -525,7 +525,8 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
             | ty::FnDef(def_id, args)
             | ty::Closure(def_id, args)
             | ty::CoroutineClosure(def_id, args)
-            | ty::Coroutine(def_id, args) => {
+            | ty::Coroutine(def_id, args)
+            | ty::Init(def_id, args) => {
                 self.print_def_path(def_id, args)?;
             }
 
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 1ac309da101f1..51e4b3f704d67 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1682,6 +1682,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 ty::CoroutineClosure(..) => Some(21),
                 ty::Pat(..) => Some(22),
                 ty::UnsafeBinder(..) => Some(23),
+                ty::Init(..) => Some(24),
                 ty::Placeholder(..) | ty::Bound(..) | ty::Infer(..) | ty::Error(_) => None,
             }
         }
@@ -1773,6 +1774,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 hir::CoroutineSource::Closure,
             ))
             | hir::ClosureKind::CoroutineClosure(hir::CoroutineDesugaring::Gen) => "a gen closure",
+            hir::ClosureKind::Init => "a init thunk",
         }
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index d694a092853af..d476ad7aae3f7 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -376,7 +376,9 @@ fn evaluate_host_effect_for_destruct_goal<'tcx>(
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(_, _) => return Err(EvaluationFailure::NoSolution),
 
-        // FIXME(unsafe_binders): Unsafe binders could implement `[const] Drop`
+        ty::Init(..) => return Err(EvaluationFailure::NoSolution),
+
+        // FIXME(unsafe_binders): Unsafe binders could implement `~const Drop`
         // if their inner type implements it.
         ty::UnsafeBinder(_) => return Err(EvaluationFailure::NoSolution),
 
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 28b5b7cf391eb..bbe794f410c56 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -994,6 +994,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                         | LangItem::Fn
                         | LangItem::FnMut
                         | LangItem::FnOnce
+                        | LangItem::Init
                         | LangItem::AsyncFn
                         | LangItem::AsyncFnMut
                         | LangItem::AsyncFnOnce,
@@ -1037,6 +1038,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                         | ty::CoroutineClosure(..)
                         | ty::Coroutine(..)
                         | ty::CoroutineWitness(..)
+                        | ty::Init(..)
                         | ty::Never
                         | ty::Tuple(..)
                         // Integers and floats always have `u8` as their discriminant.
@@ -1091,6 +1093,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                             | ty::CoroutineClosure(..)
                             | ty::Coroutine(..)
                             | ty::CoroutineWitness(..)
+                            | ty::Init(..)
                             | ty::Never
                             // Extern types have unit metadata, according to RFC 2850
                             | ty::Foreign(_)
@@ -1262,6 +1265,8 @@ fn confirm_select_candidate<'cx, 'tcx>(
                 confirm_iterator_candidate(selcx, obligation, data)
             } else if tcx.is_lang_item(trait_def_id, LangItem::AsyncIterator) {
                 confirm_async_iterator_candidate(selcx, obligation, data)
+            } else if tcx.is_lang_item(trait_def_id, LangItem::Init) {
+                confirm_init_candidate(selcx, obligation, data)
             } else if selcx.tcx().fn_trait_kind_from_def_id(trait_def_id).is_some() {
                 if obligation.predicate.self_ty().is_closure()
                     || obligation.predicate.self_ty().is_coroutine_closure()
@@ -1671,6 +1676,89 @@ fn confirm_closure_candidate<'cx, 'tcx>(
         .with_addl_obligations(obligations)
 }
 
+fn confirm_init_candidate<'cx, 'tcx>(
+    selcx: &mut SelectionContext<'cx, 'tcx>,
+    obligation: &ProjectionTermObligation<'tcx>,
+    nested: PredicateObligations<'tcx>,
+) -> Progress<'tcx> {
+    let tcx = selcx.tcx();
+    let self_ty = selcx.infcx.shallow_resolve(obligation.predicate.self_ty());
+    assert!(!self_ty.has_escaping_bound_vars());
+    match self_ty.kind() {
+        // A proper init block
+        ty::Init(_did, args) => {
+            let Normalized { value: sig, obligations } = normalize_with_depth(
+                selcx,
+                obligation.param_env,
+                obligation.cause.clone(),
+                obligation.recursion_depth + 1,
+                args.as_closure().sig(),
+            );
+            let &ty::Tuple(init_rets) = sig.output().skip_binder().kind() else {
+                debug!("failed to resolve return or error type of init block");
+                todo!()
+            };
+            let [ret_ty, err_ty] = **init_rets else { bug!() };
+            // This reads `<$self_ty as Init<$ret_ty>>::Error == $err_ty`
+            let predicate = sig.map_bound(|_| ty::ProjectionPredicate {
+                projection_term: ty::AliasTerm::new(
+                    tcx,
+                    tcx.require_lang_item(LangItem::InitError, obligation.cause.span),
+                    [self_ty, ret_ty],
+                ),
+                term: err_ty.into(),
+            });
+            confirm_param_env_candidate(selcx, obligation, predicate, true)
+                .with_addl_obligations(nested)
+                .with_addl_obligations(obligations)
+        }
+        // A trivial init value
+        ty::Bool
+        | ty::Char
+        | ty::Int(_)
+        | ty::Uint(_)
+        | ty::Float(_)
+        | ty::Adt(_, _)
+        | ty::Foreign(_)
+        | ty::Str
+        | ty::Array(_, _)
+        | ty::Pat(_, _)
+        | ty::Slice(_)
+        | ty::RawPtr(_, _)
+        | ty::Ref(_, _, _)
+        | ty::FnDef(_, _)
+        | ty::FnPtr(_, _)
+        | ty::UnsafeBinder(_)
+        | ty::Dynamic(_, _, _)
+        | ty::Closure(_, _)
+        | ty::CoroutineClosure(_, _)
+        | ty::Coroutine(_, _)
+        | ty::CoroutineWitness(_, _)
+        | ty::Tuple(_)
+        | ty::Alias(_, _)
+        | ty::Param(_)
+        | ty::Infer(ty::IntVar(_) | ty::FloatVar(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_))
+        | ty::Bound(_, _) => {
+            let predicate = ty::Binder::dummy(ty::ProjectionPredicate {
+                projection_term: ty::AliasTerm::new(
+                    tcx,
+                    tcx.require_lang_item(LangItem::InitError, obligation.cause.span),
+                    [self_ty, self_ty],
+                ),
+                term: tcx.types.never.into(),
+            });
+            confirm_param_env_candidate(selcx, obligation, predicate, true)
+                .with_addl_obligations(nested)
+        }
+        ty::Never | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => {
+            span_bug!(
+                obligation.cause.span,
+                "here init candidate should not be confirmed on {self_ty:?}"
+            )
+        }
+    }
+}
+
 fn confirm_callable_candidate<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionTermObligation<'tcx>,
diff --git a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
index 38cfdcdc22d33..ae87188d80ba4 100644
--- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
@@ -59,7 +59,9 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
         // check if *all* of them are trivial.
         ty::Tuple(tys) => tys.iter().all(|t| trivial_dropck_outlives(tcx, t)),
 
-        ty::Closure(_, args) => trivial_dropck_outlives(tcx, args.as_closure().tupled_upvars_ty()),
+        ty::Closure(_, args) | ty::Init(_, args) => {
+            trivial_dropck_outlives(tcx, args.as_closure().tupled_upvars_ty())
+        }
         ty::CoroutineClosure(_, args) => {
             trivial_dropck_outlives(tcx, args.as_coroutine_closure().tupled_upvars_ty())
         }
@@ -297,11 +299,20 @@ pub fn dtorck_constraint_for_ty_inner<'tcx>(
             }
         }),
 
-        ty::Closure(_, args) => rustc_data_structures::stack::ensure_sufficient_stack(|| {
-            for ty in args.as_closure().upvar_tys() {
-                dtorck_constraint_for_ty_inner(tcx, typing_env, span, depth + 1, ty, constraints);
-            }
-        }),
+        ty::Closure(_, args) | ty::Init(_, args) => {
+            rustc_data_structures::stack::ensure_sufficient_stack(|| {
+                for ty in args.as_closure().upvar_tys() {
+                    dtorck_constraint_for_ty_inner(
+                        tcx,
+                        typing_env,
+                        span,
+                        depth + 1,
+                        ty,
+                        constraints,
+                    );
+                }
+            })
+        }
 
         ty::CoroutineClosure(_, args) => {
             rustc_data_structures::stack::ensure_sufficient_stack(|| {
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 2c7089507a897..8dcf3ca708833 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -128,6 +128,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         &mut candidates,
                     );
                 }
+                Some(LangItem::Init) => {
+                    // User defined `Init` comes first but are applicable only on `struct`s and `enums`
+                    self.assemble_candidates_from_impls(obligation, &mut candidates);
+                    self.assemble_candidates_from_object_ty(obligation, &mut candidates);
+                    self.assemble_init_candidates(stack, &mut candidates)?;
+                }
                 _ => {
                     // We re-match here for traits that can have both builtin impls and user written impls.
                     // After the builtin impls we need to also add user written impls, which we do not want to
@@ -253,14 +259,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     /// supplied to find out whether it is listed among them.
     ///
     /// Never affects the inference environment.
-    #[instrument(level = "debug", skip(self, stack, candidates))]
+    #[instrument(level = "debug", skip(self, stack, candidates), fields(?stack.obligation))]
     fn assemble_candidates_from_caller_bounds<'o>(
         &mut self,
         stack: &TraitObligationStack<'o, 'tcx>,
         candidates: &mut SelectionCandidateSet<'tcx>,
     ) -> Result<(), SelectionError<'tcx>> {
-        debug!(?stack.obligation);
-
         let bounds = stack
             .obligation
             .param_env
@@ -584,6 +588,124 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         }
     }
 
+    #[instrument(level = "debug", skip(self, candidates))]
+    fn assemble_init_candidates<'o>(
+        &mut self,
+        stack: &TraitObligationStack<'o, 'tcx>,
+        candidates: &mut SelectionCandidateSet<'tcx>,
+    ) -> Result<(), SelectionError<'tcx>> {
+        let obligation = stack.obligation;
+        let self_ty = obligation.self_ty().skip_binder();
+        debug!(kind = ?self_ty.kind());
+        let tcx = self.tcx();
+        let bounds =
+            obligation.param_env.caller_bounds().iter().filter_map(|p| p.as_trait_clause()).filter(
+                |p| {
+                    tcx.is_lang_item(p.def_id(), LangItem::Init)
+                        && matches!(p.polarity(), ty::PredicatePolarity::Positive)
+                },
+            );
+        if let ty::Init(_, _) = self_ty.kind() {
+            debug!("init candidate");
+            candidates.vec.push(InitCandidate);
+            // Short circuiting
+            // .. because this is the most specific `Init` impl
+            // there can be.
+            // During the confirmation stage we will figure out whether
+            // an unsizing `Init` should be used
+            return Ok(());
+        }
+        let target_ty = self
+            .infcx
+            .resolve_vars_if_possible(obligation.predicate.skip_binder().trait_ref.args.type_at(1));
+        // Try to take from the typing environment, in order of specificity:
+        let drcx = DeepRejectCtxt::relate_rigid_rigid(tcx);
+        match target_ty.kind() {
+            // 1) S: Init<[T; N]>
+            //    ________________ init_unsize_array
+            //    S: Init<[T]>
+            &ty::Slice(elem_ty) => {
+                // todo
+                let mut candidate = None::<ty::PolyTraitPredicate<'_>>;
+                for bound in bounds {
+                    let target_ty = bound.skip_binder().trait_ref.args.type_at(1);
+                    let &ty::Array(other_elem_ty, _) = target_ty.kind() else {
+                        continue;
+                    };
+                    if !drcx.types_may_unify(self_ty, bound.self_ty().skip_binder())
+                        || !drcx.types_may_unify(elem_ty, other_elem_ty)
+                    {
+                        continue;
+                    }
+
+                    let wc =
+                        self.where_clause_may_apply(stack, bound.map_bound(|b| b.trait_ref))?;
+                    if !wc.may_apply() {
+                        continue;
+                    }
+                    // Okay we have one candidate by unsizing the array
+                    // but rejects when there are multiple different impls.
+                    // There is a potential issue: what if there are multiple `Init<[T; N]>`
+                    // with potentially different `N` or un-unifiable `T`?
+                    // This can become an opportunity to bait-and-switch.
+                    if let Some(candidate) = candidate {
+                        let other_target_ty = candidate.skip_binder().trait_ref.args.type_at(1);
+                        if !drcx.types_may_unify(target_ty, other_target_ty) {
+                            debug!(?candidate, another_candidate = ?bound, "ambiguous array unsizing init");
+                            candidates.ambiguous = true;
+                            return Ok(());
+                        }
+                        // We will keep to the first discovery
+                    } else {
+                        candidate = Some(bound);
+                    }
+                }
+                candidates.vec.extend(candidate.map(ArrayUnsizeInitCandidate));
+            }
+            &ty::Adt(_def, _args) => {
+                // NOTE: unify for unsizing ADTs too
+            }
+            _ => {}
+        }
+        // Next candidate, the identity
+        match self_ty.kind() {
+            ty::Init(_, _) => {}
+            ty::Bool
+            | ty::Char
+            | ty::Int(_)
+            | ty::Uint(_)
+            | ty::Float(_)
+            | ty::Adt(_, _)
+            | ty::Foreign(_)
+            | ty::Str
+            | ty::Array(_, _)
+            | ty::Alias(_, _)
+            | ty::Param(_)
+            | ty::Pat(_, _)
+            | ty::Slice(_)
+            | ty::RawPtr(_, _)
+            | ty::Ref(_, _, _)
+            | ty::FnDef(_, _)
+            | ty::FnPtr(_, _)
+            | ty::UnsafeBinder(_)
+            | ty::Dynamic(_, _, _)
+            | ty::Closure(_, _)
+            | ty::CoroutineClosure(_, _)
+            | ty::Coroutine(_, _)
+            | ty::CoroutineWitness(_, _)
+            | ty::Tuple(_)
+            | ty::Infer(
+                ty::IntVar(_) | ty::FloatVar(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_),
+            )
+            | ty::Bound(_, _) => {
+                debug!("trivial init candidate");
+                candidates.vec.push(TrivialInitCandidate);
+            }
+            ty::Never | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => {}
+        }
+        Ok(())
+    }
+
     /// Searches for impls that might apply to `obligation`.
     #[instrument(level = "debug", skip(self, candidates))]
     fn assemble_candidates_from_impls(
@@ -694,6 +816,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::CoroutineClosure(..)
                 | ty::Coroutine(_, _)
                 | ty::CoroutineWitness(..)
+                | ty::Init(..)
                 | ty::UnsafeBinder(_)
                 | ty::Never
                 | ty::Tuple(_)
@@ -867,6 +990,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)
                 | ty::Coroutine(..)
+                | ty::Init(..)
                 | ty::Never
                 | ty::Tuple(_)
                 | ty::UnsafeBinder(_) => {
@@ -1172,7 +1296,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
             }
 
-            ty::Closure(_, args) => {
+            ty::Closure(_, args) | ty::Init(_, args) => {
                 let resolved_upvars =
                     self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
                 if resolved_upvars.is_ty_var() {
@@ -1242,6 +1366,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Array(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Never
             | ty::Error(_) => {
                 candidates.vec.push(SizedCandidate);
@@ -1328,6 +1453,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Never
             | ty::Alias(..)
             | ty::Param(_)
@@ -1367,6 +1493,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::UnsafeBinder(_)
             | ty::Never
             | ty::Tuple(..)
@@ -1420,6 +1547,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Coroutine(..)
             | ty::UnsafeBinder(_)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Bound(..) => {
                 candidates.vec.push(BikeshedGuaranteedNoDropCandidate);
             }
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 488094b15ac60..1ac2e302f63df 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -95,6 +95,18 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 ImplSource::Builtin(BuiltinImplSource::Misc, vtable_coroutine)
             }
 
+            InitCandidate => ImplSource::Builtin(
+                BuiltinImplSource::Misc,
+                self.confirm_init_candidate(obligation)?,
+            ),
+
+            ArrayUnsizeInitCandidate(_bound) => todo!("pinit: sorry"),
+
+            TrivialInitCandidate => ImplSource::Builtin(
+                BuiltinImplSource::Misc,
+                self.confirm_trivial_init_candidate(obligation)?,
+            ),
+
             FutureCandidate => {
                 let vtable_future = self.confirm_future_candidate(obligation)?;
                 ImplSource::Builtin(BuiltinImplSource::Misc, vtable_future)
@@ -705,6 +717,45 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         Ok(nested)
     }
 
+    #[instrument(level = "debug", skip(self), ret)]
+    fn confirm_init_candidate(
+        &mut self,
+        obligation: &PolyTraitObligation<'tcx>,
+    ) -> Result<PredicateObligations<'tcx>, SelectionError<'tcx>> {
+        let placeholder_predicate = self.infcx.enter_forall_and_leak_universe(obligation.predicate);
+        let self_ty = self.infcx.shallow_resolve(placeholder_predicate.self_ty());
+        let ty::Init(_, args) = self_ty.kind() else {
+            bug!("init candidate is only applicable to init blocks")
+        };
+        let closure_args = args.as_closure();
+        let ty::FnPtr(in_outs, _) = closure_args.sig_as_fn_ptr_ty().kind() else { bug!() };
+        let &ty::Tuple(outs) = in_outs.skip_binder().output().kind() else { bug!() };
+        let [ret_ty, ..] = **outs else { bug!() };
+        let trait_ref =
+            ty::TraitRef::new(self.tcx(), placeholder_predicate.def_id(), [self_ty, ret_ty]);
+        let nested = self.equate_trait_refs(
+            obligation.with(self.tcx(), placeholder_predicate),
+            ty::Binder::dummy(trait_ref),
+        )?;
+        Ok(nested)
+    }
+
+    #[instrument(level = "debug", skip(self), ret)]
+    fn confirm_trivial_init_candidate(
+        &mut self,
+        obligation: &PolyTraitObligation<'tcx>,
+    ) -> Result<PredicateObligations<'tcx>, SelectionError<'tcx>> {
+        let placeholder_predicate = self.infcx.enter_forall_and_leak_universe(obligation.predicate);
+        let self_ty = self.infcx.shallow_resolve(placeholder_predicate.self_ty());
+        let trait_ref =
+            ty::TraitRef::new(self.tcx(), placeholder_predicate.def_id(), [self_ty, self_ty]);
+        let nested = self.equate_trait_refs(
+            obligation.with(self.tcx(), placeholder_predicate),
+            ty::Binder::dummy(trait_ref),
+        )?;
+        Ok(nested)
+    }
+
     fn confirm_future_candidate(
         &mut self,
         obligation: &PolyTraitObligation<'tcx>,
@@ -1308,6 +1359,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Coroutine(..)
             | ty::UnsafeBinder(_)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Bound(..) => {
                 obligations.push(obligation.with(
                     tcx,
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index f90316f520b3e..43e7010e47f59 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -1992,6 +1992,9 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | AsyncClosureCandidate
                 | AsyncFnKindHelperCandidate
                 | CoroutineCandidate
+                | InitCandidate
+                | ArrayUnsizeInitCandidate(..)
+                | TrivialInitCandidate
                 | FutureCandidate
                 | IteratorCandidate
                 | AsyncIteratorCandidate
@@ -2121,6 +2124,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Array(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Never
             | ty::Error(_) => ty::Binder::dummy(vec![]),
 
@@ -2218,7 +2222,9 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 .instantiate(self.infcx.tcx, args)
                 .map_bound(|witness| witness.types.to_vec()),
 
-            ty::Closure(_, args) => ty::Binder::dummy(args.as_closure().upvar_tys().to_vec()),
+            ty::Closure(_, args) | ty::Init(_, args) => {
+                ty::Binder::dummy(args.as_closure().upvar_tys().to_vec())
+            }
 
             ty::CoroutineClosure(_, args) => {
                 ty::Binder::dummy(args.as_coroutine_closure().upvar_tys().to_vec())
@@ -2320,7 +2326,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 })
             }
 
-            ty::Closure(_, args) => {
+            ty::Closure(_, args) | ty::Init(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
                 ty::Binder::dummy(AutoImplConstituents { types: vec![ty], assumptions: vec![] })
             }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index adce9850b594c..1ce59554e6d55 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -837,7 +837,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                 self.out.extend(obligations);
             }
 
-            ty::Closure(did, args) => {
+            ty::Closure(did, args) | ty::Init(did, args) => {
                 // Note that we cannot skip the generic types
                 // types. Normally, within the fn
                 // body where they are created, the generics will
diff --git a/compiler/rustc_ty_utils/src/implied_bounds.rs b/compiler/rustc_ty_utils/src/implied_bounds.rs
index 6fa763f18ef19..46f977752f083 100644
--- a/compiler/rustc_ty_utils/src/implied_bounds.rs
+++ b/compiler/rustc_ty_utils/src/implied_bounds.rs
@@ -146,6 +146,7 @@ fn assumed_wf_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx [(Ty<'
         | DefKind::Field
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
+        | DefKind::Init
         | DefKind::Closure
         | DefKind::SyntheticCoroutineBody => {
             span_bug!(
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 163e2b3088374..41e887d7eee25 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -524,7 +524,9 @@ fn layout_of_uncached<'tcx>(
             map_layout(layout)?
         }
 
-        ty::Closure(_, args) => univariant(args.as_closure().upvar_tys(), StructKind::AlwaysSized)?,
+        ty::Closure(_, args) | ty::Init(_, args) => {
+            univariant(args.as_closure().upvar_tys(), StructKind::AlwaysSized)?
+        }
 
         ty::CoroutineClosure(_, args) => {
             univariant(args.as_coroutine_closure().upvar_tys(), StructKind::AlwaysSized)?
diff --git a/compiler/rustc_ty_utils/src/needs_drop.rs b/compiler/rustc_ty_utils/src/needs_drop.rs
index c3b04c20f4b67..8b81d0af01045 100644
--- a/compiler/rustc_ty_utils/src/needs_drop.rs
+++ b/compiler/rustc_ty_utils/src/needs_drop.rs
@@ -221,7 +221,7 @@ where
 
                     _ if tcx.type_is_copy_modulo_regions(self.typing_env, component) => {}
 
-                    ty::Closure(_, args) => {
+                    ty::Closure(_, args) | ty::Init(_, args) => {
                         for upvar in args.as_closure().upvar_tys() {
                             queue_type(self, upvar);
                         }
diff --git a/compiler/rustc_ty_utils/src/opaque_types.rs b/compiler/rustc_ty_utils/src/opaque_types.rs
index 4a7263d0ccd20..ad1277ff87cb5 100644
--- a/compiler/rustc_ty_utils/src/opaque_types.rs
+++ b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -323,11 +323,14 @@ fn opaque_types_defined_by<'tcx>(
         | DefKind::AnonConst => {
             collector.collect_taits_declared_in_body();
         }
-        // Closures and coroutines are type checked with their parent
+        // Closures, inits, inline constants and coroutines are type checked with their parent
         // Note that we also support `SyntheticCoroutineBody` since we create
         // a MIR body for the def kind, and some MIR passes (like promotion)
         // may require doing analysis using its typing env.
-        DefKind::Closure | DefKind::InlineConst | DefKind::SyntheticCoroutineBody => {
+        DefKind::Closure
+        | DefKind::InlineConst
+        | DefKind::SyntheticCoroutineBody
+        | DefKind::Init => {
             collector.opaques.extend(tcx.opaque_types_defined_by(tcx.local_parent(item)));
         }
         DefKind::AssocTy | DefKind::TyAlias | DefKind::GlobalAsm => {}
diff --git a/compiler/rustc_ty_utils/src/sig_types.rs b/compiler/rustc_ty_utils/src/sig_types.rs
index dc6009116ac57..6a094ba8225fa 100644
--- a/compiler/rustc_ty_utils/src/sig_types.rs
+++ b/compiler/rustc_ty_utils/src/sig_types.rs
@@ -84,7 +84,7 @@ pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
         // These are not part of a public API, they can only appear as hidden types, and there
         // the interesting parts are solely in the signature of the containing item's opaque type
         // or dyn type.
-        DefKind::InlineConst | DefKind::Closure | DefKind::SyntheticCoroutineBody => {}
+        DefKind::InlineConst | DefKind::Closure | DefKind::SyntheticCoroutineBody | DefKind::Init => {}
         DefKind::Impl { of_trait } => {
             if of_trait {
                 let span = tcx.hir_node_by_def_id(item).expect_item().expect_impl().of_trait.unwrap().path.span;
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index f8d793464a934..468ab4e4b059e 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -34,6 +34,7 @@ fn sizedness_constraint_for_ty<'tcx>(
         | ty::FnDef(..)
         | ty::FnPtr(..)
         | ty::Array(..)
+        | ty::Init(..)
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
@@ -371,6 +372,7 @@ fn impl_self_is_guaranteed_unsized<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId)
         | ty::FnDef(_, _)
         | ty::FnPtr(_, _)
         | ty::UnsafeBinder(_)
+        | ty::Init(_, _)
         | ty::Closure(_, _)
         | ty::CoroutineClosure(_, _)
         | ty::Coroutine(_, _)
diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
index d88c88fc6f3f5..51037c5765771 100644
--- a/compiler/rustc_type_ir/src/fast_reject.rs
+++ b/compiler/rustc_type_ir/src/fast_reject.rs
@@ -41,6 +41,7 @@ pub enum SimplifiedType<DefId> {
     MarkerTraitObject,
     Trait(DefId),
     Closure(DefId),
+    Init(DefId),
     Coroutine(DefId),
     CoroutineWitness(DefId),
     Function(usize),
@@ -138,6 +139,7 @@ pub fn simplify_type<I: Interner>(
         ty::FnDef(def_id, _) | ty::Closure(def_id, _) | ty::CoroutineClosure(def_id, _) => {
             Some(SimplifiedType::Closure(def_id))
         }
+        ty::Init(def_id, _) => Some(SimplifiedType::Init(def_id)),
         ty::Coroutine(def_id, _) => Some(SimplifiedType::Coroutine(def_id)),
         ty::CoroutineWitness(def_id, _) => Some(SimplifiedType::CoroutineWitness(def_id)),
         ty::Never => Some(SimplifiedType::Never),
@@ -304,6 +306,7 @@ impl<I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_
             | ty::FnDef(..)
             | ty::FnPtr(..)
             | ty::Closure(..)
+            | ty::Init(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
@@ -439,6 +442,12 @@ impl<I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_
                 }
                 _ => false,
             },
+            ty::Init(lhs_def_id, lhs_args) => match rhs.kind() {
+                ty::Init(rhs_def_id, rhs_args) => {
+                    lhs_def_id == rhs_def_id && self.args_may_unify_inner(lhs_args, rhs_args, depth)
+                }
+                _ => false,
+            },
 
             ty::CoroutineClosure(lhs_def_id, lhs_args) => match rhs.kind() {
                 ty::CoroutineClosure(rhs_def_id, rhs_args) => {
diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
index d7b9e0ca340ac..e3cf303f9e968 100644
--- a/compiler/rustc_type_ir/src/flags.rs
+++ b/compiler/rustc_type_ir/src/flags.rs
@@ -246,7 +246,10 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_flags(TypeFlags::HAS_TY_PARAM);
             }
 
-            ty::Closure(_, args) | ty::Coroutine(_, args) | ty::CoroutineClosure(_, args) => {
+            ty::Closure(_, args)
+            | ty::Init(_, args)
+            | ty::Coroutine(_, args)
+            | ty::CoroutineClosure(_, args) => {
                 self.add_args(args.as_slice());
             }
 
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 0e307e15d5b4d..11e3a1aca7e5f 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -89,6 +89,8 @@ pub trait Ty<I: Interner<Ty = Self>>:
 
     fn new_closure(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
 
+    fn new_init(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
+
     fn new_coroutine_witness(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
 
     fn new_ptr(interner: I, ty: Self, mutbl: Mutability) -> Self;
@@ -175,6 +177,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
+            | ty::Init(_, _)
             | ty::CoroutineWitness(_, _)
             | ty::Never
             | ty::Tuple(_)
diff --git a/compiler/rustc_type_ir/src/outlives.rs b/compiler/rustc_type_ir/src/outlives.rs
index b09a378d34143..a7f6afb24fa24 100644
--- a/compiler/rustc_type_ir/src/outlives.rs
+++ b/compiler/rustc_type_ir/src/outlives.rs
@@ -102,6 +102,10 @@ impl<I: Interner> TypeVisitor<I> for OutlivesCollector<'_, I> {
             ty::Closure(_, args) => {
                 args.as_closure().tupled_upvars_ty().visit_with(self);
             }
+            ty::Init(_, args) => {
+                // Yes, ty::Init has the same generic schema as that of closure
+                args.as_closure().tupled_upvars_ty().visit_with(self);
+            }
 
             ty::CoroutineClosure(_, args) => {
                 args.as_coroutine_closure().tupled_upvars_ty().visit_with(self);
diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs
index e3c4a793b37f6..433e4f133353d 100644
--- a/compiler/rustc_type_ir/src/relate.rs
+++ b/compiler/rustc_type_ir/src/relate.rs
@@ -443,6 +443,11 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
             Ok(Ty::new_closure(cx, a_id, args))
         }
 
+        (ty::Init(a_did, a_args), ty::Init(b_did, b_args)) if a_did == b_did => {
+            let args = relate_args_invariantly(relation, a_args, b_args)?;
+            Ok(Ty::new_init(cx, a_did, args))
+        }
+
         (ty::CoroutineClosure(a_id, a_args), ty::CoroutineClosure(b_id, b_args))
             if a_id == b_id =>
         {
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 7c66542475050..47f6f1f9940dd 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -213,6 +213,15 @@ pub enum TyKind<I: Interner> {
     /// ```
     CoroutineWitness(I::DefId, I::GenericArgs),
 
+    /// The anonymous type of an `init` block. Used to represent the type of `init $init_expr`.
+    /// The components are
+    /// - the `DefId` of the init block;
+    /// - the generics of the init block;
+    /// - the unique type that this init block is initialising in-place and the error type,
+    ///   which is encoded in the `fn_ptr` of the generics as return type tuple
+    ///   `(<inited type, error type>)`
+    Init(I::DefId, I::GenericArgs),
+
     /// The never type `!`.
     Never,
 
@@ -317,6 +326,7 @@ impl<I: Interner> TyKind<I> {
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Never
             | ty::Tuple(_) => true,
 
@@ -372,6 +382,7 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
             CoroutineClosure(d, s) => f.debug_tuple("CoroutineClosure").field(d).field(&s).finish(),
             Coroutine(d, s) => f.debug_tuple("Coroutine").field(d).field(&s).finish(),
             CoroutineWitness(d, s) => f.debug_tuple("CoroutineWitness").field(d).field(&s).finish(),
+            Init(d, s) => f.debug_tuple("Init").field(d).field(&s).finish(),
             Never => write!(f, "!"),
             Tuple(t) => {
                 write!(f, "(")?;
diff --git a/compiler/rustc_type_ir/src/walk.rs b/compiler/rustc_type_ir/src/walk.rs
index 9912fad1756ea..2e6994fb7b403 100644
--- a/compiler/rustc_type_ir/src/walk.rs
+++ b/compiler/rustc_type_ir/src/walk.rs
@@ -133,6 +133,7 @@ fn push_inner<I: Interner>(stack: &mut TypeWalkerStack<I>, parent: I::GenericArg
             }
             ty::Adt(_, args)
             | ty::Closure(_, args)
+            | ty::Init(_, args)
             | ty::CoroutineClosure(_, args)
             | ty::Coroutine(_, args)
             | ty::CoroutineWitness(_, args)
diff --git a/library/core/src/init.rs b/library/core/src/init.rs
new file mode 100644
index 0000000000000..401a4a1d57993
--- /dev/null
+++ b/library/core/src/init.rs
@@ -0,0 +1,260 @@
+//! In-place initialization.
+//!
+//! This module describes the interface through which types supporting in-place initialization
+//! can perform initialization with minimal or zero additional allocations or moves.
+
+use crate::alloc::Layout;
+use crate::ptr::{Pointee, Unique, from_raw_parts_mut};
+
+/// In-place Initializer for `T`.
+///
+/// An instance of `Init<T>` carries all the information necessary to initialize a `T` in a
+/// well-defined memory location, criteria of which is prescribed in the Safety section.
+///
+/// # Fallibility
+///
+/// The initialization might fail and return an error of type [`Self::Error`] instead.
+/// In that case, the memory provided to [`Self::init`] shall be repurposed in any way,
+/// even though it might have been written to by this initializer.
+///
+/// # Examples
+///
+/// ## Initializing unsized types
+///
+/// To initialize an unsized type, first query the required layout for `T` using [`Self::layout`].
+/// Then provide a pointer to an allocation of at least the specified alignment and size.
+///
+/// If initialization was successful, then [`Self::init`] returns the metadata that combined with
+/// the pointer to the given to [`Self::init`] yields a valid pointer to `T`.
+///
+/// ``` ignore (illustrative)
+/// use std::alloc::alloc;
+/// fn init_boxed<T: ?Sized + Pointee, I: Init<T>>(init: I) -> Result<Box<T>, I::Error> {
+///     let layout = init.layout();
+///     let memory = alloc(layout).cast::<()>();
+///     let meta = init.init(memory)?;
+///     Box::from_raw(from_raw_parts_mut(memory, meta))
+/// }
+/// ```
+///
+/// # Safety
+///
+/// Implementers must ensure that if [`self.init(slot)`] returns `Ok(metadata)`,
+/// then [`core::ptr::from_raw_parts_mut(slot, metadata)`] must reference a valid
+/// value owned by the caller.
+/// Furthermore, the layout returned by using
+/// [`core::intrinsics::size_of_val`] and [`core::intrinsics::align_of_val`] on this pointer
+/// must match what [`Self::layout()`] returns exactly.
+///
+/// If `T` is sized, or in other words `T: Sized`, [`Init::layout`] in this case *must*
+/// return the same layout as [`Layout::new::<T>()`] would.
+///
+/// Implementers must ensure that the implementation of `init()` does not rely
+/// on the value being pinned.
+///
+/// [`core::ptr::from_raw_parts_mut(slot, metadata)`]: core::ptr::from_raw_parts_mut
+/// [`Self::layout()`]: Init::layout
+/// [`self.init(slot)`]: Init::init
+/// [`Layout::new::<T>()`]: core::alloc::Layout::new
+#[unstable(feature = "in_place_initialization", issue = "999999")]
+#[lang = "init_trait"]
+pub unsafe trait Init<T: ?Sized + Pointee> {
+    /// Error type upon initialization failure during the actual
+    /// in-place initialization procedure.
+    #[lang = "init_error"]
+    type Error;
+
+    /// The layout needed by this initializer.
+    /// This method must return a layout that precisely matches
+    /// with `T`.
+    /// Namely the size and the alignment must be equal.
+    #[lang = "init_layout"]
+    fn layout(&self) -> Layout;
+
+    /// Writes a valid value of type `T` to `slot` or fails.
+    ///
+    /// If this call returns [`Ok`], then `slot` is guaranteed to contain a valid
+    /// value of type `T`.
+    /// Otherwise, in case the result is an [`Err`], the implementation must guarantee
+    /// that the `slot` may be repurposed for future reuse.
+    ///
+    /// If `T` is unsized, then `slot` may be combined with
+    /// the metadata to obtain a valid pointer to the value.
+    ///
+    /// Note that `slot` should be thought of as a `*mut T`. A unit type is used
+    /// so that the pointer is thin even if `T` is unsized.
+    ///
+    /// # Safety
+    ///
+    /// The caller must provide a pointer that references a location that `init`
+    /// may write to, and the location must have at least the size and alignment
+    /// specified by [`Init::layout`].
+    ///
+    /// The caller must also make sure that there is no possible aliasing
+    /// to the slot that the caller is supplying.
+    #[lang = "init_init"]
+    unsafe fn init(self, slot: *mut ()) -> Result<T::Metadata, Self::Error>;
+}
+
+// There is no intention to stabilise this contraption.
+// It shall remain internal.
+#[doc(hidden)]
+#[unstable(feature = "in_place_initialization_guard", issue = "999999")]
+#[lang = "init_guard"]
+#[allow(missing_debug_implementations)]
+pub struct InitGuard<T: ?Sized + Pointee>(Unique<T>);
+
+/// InitGuard is a guard to track the live state of initialised sub-fields of `struct`s,
+/// tuples and fix-length array elements.
+///
+/// ```ignore (illustrative)
+/// init MyStruct {
+///     a: init1,
+///     b: init2,
+/// }
+/// // is conceptually lowered to
+/// let slot_MyStruct: *mut ();
+/// let slot_a: *mut ();
+/// let slot_b: *mut ();
+/// let () = init1.init(slot_a)?;
+/// let guard_a = InitGuard::new(slot_a, ());
+/// let metadata = init2.init(slot_b)?;
+/// let guard_b = InitGuard::new(slot_b, metadata);
+/// // [ accepted state ]
+/// guard_a.release();
+/// guard_b.release();
+/// // [ commit MyStruct ]
+/// Ok(metadata)
+/// ```
+impl<T: ?Sized + Pointee> InitGuard<T> {
+    /// # Safety
+    ///
+    /// The caller in built MIR must make sure that the result of the in-place
+    /// initialization is actually a success before constructing a guard.
+    #[inline(always)]
+    #[lang = "init_guard_new"]
+    unsafe fn new(slot: *mut (), metadata: <T as Pointee>::Metadata) -> Self {
+        // SAFETY: the precondition of this call means that the slot is fully initialized
+        // and the caller is the owner of the data.
+        // Any aliasing cannot happen.
+        unsafe { Self(Unique::new_unchecked(from_raw_parts_mut(slot, metadata))) }
+    }
+
+    /// # Safety
+    ///
+    /// The caller from MIR built from `init` blocks must make sure that
+    /// this function is called only when all in-place initialization
+    /// in the target slot is complete and it is ready to commit the place
+    /// into the accepted state.
+    #[inline(always)]
+    #[lang = "init_guard_release"]
+    unsafe fn release(self) {
+        crate::mem::forget(self);
+    }
+}
+
+unsafe impl<#[may_dangle] T: ?Sized + Pointee> Drop for InitGuard<T> {
+    #[inline(always)]
+    fn drop(&mut self) {
+        // SAFETY: given the precondition to the constructor of the guard,
+        // the ownership of the slot is unique and the slot has been fully
+        // initialized.
+        unsafe {
+            if Layout::for_value_raw(self.0.as_ptr()).size() > 0 {
+                crate::ptr::drop_in_place(self.0.as_ptr());
+            }
+        }
+    }
+}
+
+// There is no intention to stabilise this contraption.
+#[doc(hidden)]
+#[unstable(feature = "in_place_initialization_guard", issue = "999999")]
+#[lang = "init_array_guard"]
+#[allow(missing_debug_implementations)]
+// NOTE: even though we know that here `T: Sized` but the trait solver
+// cannot conclude that `T: Pointee<Metadata = ()>`.
+// Remove it once we sort this one out in the solver.
+pub struct InitArrayGuard<T: Pointee<Metadata = ()>>(Unique<T>, usize);
+
+/// InitArrayGuard is used to track the progress of constructing repeating
+/// in-place initialization for `[{init}; <count>]`
+///
+/// ```ignore (illustrative)
+/// init [some_init; 4]
+/// // to be lowered into
+/// let mut slot: *mut ();
+/// let mut guard = InitArrayGuard::new()
+/// let mut count = 0;
+/// let mut layout: Layout = some_init.layout();
+/// loop {
+///     if count >= 4 { break; }
+///     some_init.init(slot);
+///     slot = (slot as *mut T).wrapping_add(1) as *mut ();
+///     guard.bump();
+/// }
+/// // [ accepted state ]
+/// guard.release();
+/// // [ commit [some_init; 4] ]
+/// Ok(4)
+/// ```
+impl<T: Pointee<Metadata = ()>> InitArrayGuard<T> {
+    /// # Safety
+    ///
+    /// The built MIR assumes that Init::init precondition is upheld,
+    /// so that the `slot` is not null, with exact memory allocation
+    /// so that `T` fits perfectly with correct alignment.
+    ///
+    /// The `Init` protocal also implies that there is no aliasing on any part of
+    /// the supplied slot.
+    #[inline(always)]
+    #[lang = "init_array_guard_new"]
+    unsafe fn new(slot: *mut ()) -> Self {
+        // SAFETY: the precondition of this call means that the slot is fully initialized
+        // and the caller is the owner of the data.
+        // Any aliasing cannot happen.
+        unsafe { Self(Unique::new_unchecked(from_raw_parts_mut(slot, ())), 0) }
+    }
+
+    /// # Safety
+    ///
+    /// The caller from MIR built from `init` blocks must make sure that
+    /// this function is called only when the result from a `Init::init` call
+    /// with the last vacant slot is actually successful.
+    ///
+    /// The caller MIR also must make sure that the total number of calls to
+    /// this function never exceeds the limit that the supplied slot allows.
+    #[inline(always)]
+    #[lang = "init_array_guard_bump"]
+    unsafe fn bump(&mut self) {
+        self.1 += 1;
+    }
+
+    /// # Safety
+    ///
+    /// The caller from MIR built from `init` blocks must make sure that
+    /// this function is called only when all in-place initialization
+    /// in the target slot is complete and it is ready to commit the place
+    /// into the accepted state and hand the ownership off.
+    #[inline(always)]
+    #[lang = "init_array_guard_release"]
+    unsafe fn release(self) {
+        core::mem::forget(self);
+    }
+}
+
+unsafe impl<#[may_dangle] T: Pointee<Metadata = ()>> Drop for InitArrayGuard<T> {
+    #[inline(always)]
+    fn drop(&mut self) {
+        // SAFETY: the precondition to construction of this guard and calls to
+        // `bump` ensures that the constructed sub-array stays in the bound and no
+        // aliasing is possible on this array.
+        unsafe {
+            let (ptr, ()) = self.0.as_ptr().to_raw_parts();
+            if Layout::for_value_raw(ptr).size() > 0 && self.1 > 0 {
+                let to_drop: *mut [T] = from_raw_parts_mut(ptr, self.1);
+                core::ptr::drop_in_place(to_drop);
+            }
+        }
+    }
+}
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 3c33f4b136844..a43207da2ac0e 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -109,6 +109,7 @@
 #![feature(core_intrinsics)]
 #![feature(coverage_attribute)]
 #![feature(disjoint_bitor)]
+#![feature(dropck_eyepatch)]
 #![feature(internal_impls_macro)]
 #![feature(ip)]
 #![feature(is_ascii_octdigit)]
@@ -366,6 +367,10 @@ pub mod task;
 #[allow(missing_docs)]
 pub mod alloc;
 
+/* In-place initialization */
+#[unstable(feature = "in_place_initialization", issue = "999999")]
+pub mod init;
+
 // note: does not need to be public
 mod bool;
 mod escape;
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 323742a75b055..eb20fc3d84200 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -515,6 +515,8 @@ pub use core::i64;
 #[stable(feature = "i128", since = "1.26.0")]
 #[allow(deprecated, deprecated_in_future)]
 pub use core::i128;
+#[unstable(feature = "in_place_initialization", issue = "999999")]
+pub use core::init;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::intrinsics;
 #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 1265a39d27ba8..7cf47c815a19e 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2256,6 +2256,7 @@ pub(crate) fn clean_middle_ty<'tcx>(
         }
 
         ty::Closure(..) => panic!("Closure"),
+        ty::Init(..) => panic!("Init"),
         ty::CoroutineClosure(..) => panic!("CoroutineClosure"),
         ty::Coroutine(..) => panic!("Coroutine"),
         ty::Placeholder(..) => panic!("Placeholder"),
diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index 3aba7a370adb2..131b3ba76062f 100644
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -158,6 +158,7 @@ impl ItemType {
             | DefKind::GlobalAsm
             | DefKind::Impl { .. }
             | DefKind::Closure
+            | DefKind::Init
             | DefKind::SyntheticCoroutineBody => Self::ForeignType,
         }
     }
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 5a9aa2a94c8b4..a6b35de326a0e 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -568,6 +568,7 @@ impl<'tcx> LinkCollector<'_, 'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Dynamic(..)
             | ty::UnsafeBinder(_)
             | ty::Param(_)
@@ -2046,6 +2047,7 @@ fn resolution_failure(
                             Variant
                             | Field
                             | Closure
+                            | Init
                             | AssocTy
                             | AssocConst
                             | AssocFn
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index 5099df3fa0239..66c098dbf924b 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -890,6 +890,7 @@ impl TyCoercionStability {
                 | ty::Coroutine(..)
                 | ty::CoroutineWitness(..)
                 | ty::Closure(..)
+                | ty::Init(..)
                 | ty::CoroutineClosure(..)
                 | ty::Never
                 | ty::Tuple(_)
diff --git a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
index 69c84bc7038ef..50ffc73a03b94 100644
--- a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
@@ -276,6 +276,8 @@ fn never_loop_expr<'tcx>(
         ExprKind::OffsetOf(_, _)
         | ExprKind::Yield(_, _)
         | ExprKind::Closure { .. }
+        | ExprKind::InitBlock(_)
+        | ExprKind::InitTail(_)
         | ExprKind::Path(_)
         | ExprKind::ConstBlock(_)
         | ExprKind::Lit(_)
diff --git a/src/tools/clippy/clippy_lints/src/manual_float_methods.rs b/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
index bd2785fea2709..c217708454f37 100644
--- a/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
@@ -116,6 +116,7 @@ fn is_not_const(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
         | DefKind::Impl { .. }
         | DefKind::OpaqueTy
         | DefKind::SyntheticCoroutineBody
+        | DefKind::Init
         | DefKind::TyParam => true,
 
         DefKind::AnonConst
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index ac92ab5a245cc..0e6a39ef17b4d 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{
     self as hir, BindingMode, CaptureBy, Closure, ClosureKind, ConstArg, ConstArgKind, CoroutineKind, ExprKind,
-    FnRetTy, HirId, Lit, PatExprKind, PatKind, QPath, StmtKind, StructTailExpr,
+    FnRetTy, HirId, InitBlock, Lit, PatExprKind, PatKind, QPath, StmtKind, StructTailExpr,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
@@ -547,6 +547,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                     ClosureKind::CoroutineClosure(desugaring) => {
                         format!("ClosureKind::CoroutineClosure(CoroutineDesugaring::{desugaring:?})")
                     },
+                    ClosureKind::Init => "ClosureKind::Init".to_string(),
                 };
 
                 let ret_ty = match fn_decl.output {
@@ -561,6 +562,15 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 chain!(self, "let {ret_ty} = {fn_decl}.output");
                 self.body(body_id);
             },
+            ExprKind::InitBlock(&InitBlock { body, .. }) => {
+                bind!(self, body);
+                kind!("InitBlock {{ body: {body}, .. }}");
+                self.body(body);
+            },
+            ExprKind::InitTail(_) => {
+                // FIXME: decide how to print the in-place initialiser properly
+                kind!("InitTail");
+            },
             ExprKind::Yield(sub, source) => {
                 bind!(self, sub);
                 kind!("Yield(sub, YieldSource::{source:?})");
diff --git a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
index 9d38672efada9..97dd53b0a0722 100644
--- a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
+++ b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
@@ -300,6 +300,8 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
                 | ExprKind::If(..)
                 | ExprKind::Match(..)
                 | ExprKind::Closure { .. }
+                | ExprKind::InitTail(_)
+                | ExprKind::InitBlock(_)
                 | ExprKind::Field(..)
                 | ExprKind::AddrOf(..)
                 | ExprKind::Repeat(..)
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index f0d7fb89c4463..703f65d13a3a3 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -9,9 +9,9 @@ use rustc_hir::MatchSource::TryDesugar;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
     AssocItemConstraint, BinOpKind, BindingMode, Block, BodyId, Closure, ConstArg, ConstArgKind, Expr, ExprField,
-    ExprKind, FnRetTy, GenericArg, GenericArgs, HirId, HirIdMap, InlineAsmOperand, LetExpr, Lifetime, LifetimeKind,
-    Node, Pat, PatExpr, PatExprKind, PatField, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind,
-    StructTailExpr, TraitBoundModifiers, Ty, TyKind, TyPat, TyPatKind,
+    ExprKind, FnRetTy, GenericArg, GenericArgs, HirId, HirIdMap, InitBlock, InitKind, InlineAsmOperand, LetExpr,
+    Lifetime, LifetimeKind, Node, Pat, PatExpr, PatExprKind, PatField, PatKind, Path, PathSegment, PrimTy, QPath, Stmt,
+    StmtKind, StructTailExpr, TraitBoundModifiers, Ty, TyKind, TyPat, TyPatKind,
 };
 use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
 use rustc_lint::LateContext;
@@ -439,9 +439,11 @@ impl HirEqInterExpr<'_, '_, '_> {
                 // an invalid expressions is equal to anything.
                 | ExprKind::Err(..)
 
-                // For the time being, we always consider that two closures are unequal.
+                // For the time being, we always consider that two closures or inits are unequal.
                 // This behavior may change in the future.
                 | ExprKind::Closure(..)
+                | ExprKind::InitTail(_)
+                | ExprKind::InitBlock(_)
                 // For the time being, we always consider that two instances of InlineAsm are different.
                 // This behavior may change in the future.
                 | ExprKind::InlineAsm(_)
@@ -911,6 +913,34 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 // closures inherit TypeckResults
                 self.hash_expr(self.cx.tcx.hir_body(*body).value);
             },
+            ExprKind::InitBlock(InitBlock { body, .. }) => {
+                self.hash_expr(self.cx.tcx.hir_body(*body).value);
+            },
+            &ExprKind::InitTail(kind) => {
+                std::mem::discriminant(kind).hash(&mut self.s);
+                match kind {
+                    InitKind::Array(exprs) => self.hash_exprs(exprs),
+                    InitKind::Repeat(e, len) => {
+                        self.hash_expr(e);
+                        self.hash_const_arg(len);
+                    },
+                    InitKind::Tuple(exprs) => self.hash_exprs(exprs),
+                    InitKind::Struct(path, fields, expr) => {
+                        self.hash_qpath(path);
+
+                        for f in *fields {
+                            self.hash_name(f.ident.name);
+                            self.hash_expr(f.expr);
+                        }
+
+                        if let StructTailExpr::Base(e) = expr {
+                            self.hash_expr(e);
+                        }
+                    },
+                    InitKind::Free(expr) => self.hash_expr(expr),
+                    InitKind::Block(block, _label) => self.hash_block(block),
+                }
+            },
             ExprKind::ConstBlock(l_id) => {
                 self.hash_body(l_id.body);
             },
diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs
index 7a24d07fa1dfb..0230b8ab3445d 100644
--- a/src/tools/clippy/clippy_utils/src/sugg.rs
+++ b/src/tools/clippy/clippy_utils/src/sugg.rs
@@ -125,6 +125,7 @@ impl<'a> Sugg<'a> {
             | ExprKind::If(..)
             | ExprKind::Let(..)
             | ExprKind::Closure { .. }
+            | ExprKind::InitBlock(_)
             | ExprKind::Unary(..)
             | ExprKind::Match(..) => Sugg::MaybeParen(get_snippet(expr.span)),
             ExprKind::Continue(..)
@@ -133,6 +134,7 @@ impl<'a> Sugg<'a> {
             | ExprKind::Block(..)
             | ExprKind::Break(..)
             | ExprKind::Call(..)
+            | ExprKind::InitTail(_)
             | ExprKind::Field(..)
             | ExprKind::Index(..)
             | ExprKind::InlineAsm(..)
@@ -191,6 +193,8 @@ impl<'a> Sugg<'a> {
             },
             ast::ExprKind::Gen(..)
             | ast::ExprKind::Block(..)
+            | ast::ExprKind::InitBlock(_)
+            | ast::ExprKind::InitTail(_)
             | ast::ExprKind::Break(..)
             | ast::ExprKind::Call(..)
             | ast::ExprKind::Continue(..)
diff --git a/src/tools/clippy/clippy_utils/src/visitors.rs b/src/tools/clippy/clippy_utils/src/visitors.rs
index ba5cbc738361f..09215f8e0c7b2 100644
--- a/src/tools/clippy/clippy_utils/src/visitors.rs
+++ b/src/tools/clippy/clippy_utils/src/visitors.rs
@@ -695,6 +695,8 @@ pub fn for_each_unconsumed_temporary<'tcx, B>(
             | ExprKind::Lit(_)
             | ExprKind::ConstBlock(_)
             | ExprKind::Closure { .. }
+            | ExprKind::InitBlock(_)
+            | ExprKind::InitTail(_)
             | ExprKind::Path(_)
             | ExprKind::Continue(_)
             | ExprKind::InlineAsm(_)
diff --git a/src/tools/rustfmt/src/expr.rs b/src/tools/rustfmt/src/expr.rs
index 08aedff2b20da..5155cd01a9537 100644
--- a/src/tools/rustfmt/src/expr.rs
+++ b/src/tools/rustfmt/src/expr.rs
@@ -76,7 +76,8 @@ pub(crate) fn format_expr(
     };
 
     let expr_rw = match expr.kind {
-        ast::ExprKind::Array(ref expr_vec) => rewrite_array(
+        ast::ExprKind::Array(ref expr_vec)
+        | ast::ExprKind::InitTail(box ast::InitKind::Array(ref expr_vec)) => rewrite_array(
             "",
             expr_vec.iter(),
             expr.span,
@@ -414,6 +415,10 @@ pub(crate) fn format_expr(
                 ))
             }
         }
+        ast::ExprKind::InitTail(box ast::InitKind::Free(ref expr)) => {
+            format_expr(expr, expr_type, context, shape)
+        }
+        ast::ExprKind::InitBlock(ref block) => format_expr(&block.expr, expr_type, context, shape),
         ast::ExprKind::Underscore => Ok("_".to_owned()),
         ast::ExprKind::FormatArgs(..)
         | ast::ExprKind::Type(..)
diff --git a/src/tools/rustfmt/src/lib.rs b/src/tools/rustfmt/src/lib.rs
index 942b42ec5f20c..fbf42af787b8b 100644
--- a/src/tools/rustfmt/src/lib.rs
+++ b/src/tools/rustfmt/src/lib.rs
@@ -1,4 +1,5 @@
 #![feature(rustc_private)]
+#![feature(box_patterns)]
 #![deny(rust_2018_idioms)]
 #![warn(unreachable_pub)]
 #![recursion_limit = "256"]
diff --git a/src/tools/rustfmt/src/utils.rs b/src/tools/rustfmt/src/utils.rs
index fcd475b1784f5..9dbaf8ebb8d97 100644
--- a/src/tools/rustfmt/src/utils.rs
+++ b/src/tools/rustfmt/src/utils.rs
@@ -488,6 +488,10 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::Yield(YieldKind::Prefix(Some(ref expr))) => {
             is_block_expr(context, expr, repr)
         }
+        ast::ExprKind::InitBlock(box ast::InitBlock { ref expr, .. })
+        | ast::ExprKind::InitTail(box ast::InitKind::Free(ref expr)) => {
+            is_block_expr(context, expr, repr)
+        }
         ast::ExprKind::Closure(ref closure) => is_block_expr(context, &closure.body, repr),
         // This can only be a string lit
         ast::ExprKind::Lit(_) => {
@@ -518,6 +522,7 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::Use(..)
         | ast::ExprKind::Type(..)
         | ast::ExprKind::Yield(..)
+        | ast::ExprKind::InitTail(box ast::InitKind::Array(_))
         | ast::ExprKind::Underscore => false,
     }
 }
diff --git a/tests/ui/symbol-names/basic.legacy.stderr b/tests/ui/symbol-names/basic.legacy.stderr
index a028f4331725e..e81ae21aa7944 100644
--- a/tests/ui/symbol-names/basic.legacy.stderr
+++ b/tests/ui/symbol-names/basic.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN5basic4main17h1dddcfd03744167fE)
+error: symbol-name(_ZN5basic4main17h6ef66990d27e336dE)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(basic::main::h1dddcfd03744167f)
+error: demangling(basic::main::h6ef66990d27e336d)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
diff --git a/tests/ui/symbol-names/issue-60925.legacy.stderr b/tests/ui/symbol-names/issue-60925.legacy.stderr
index 14cbd877d9f8a..c7219496576f4 100644
--- a/tests/ui/symbol-names/issue-60925.legacy.stderr
+++ b/tests/ui/symbol-names/issue-60925.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h4b3099ec5dc5d306E)
+error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h92e2e8a95f28a395E)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::h4b3099ec5dc5d306)
+error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::h92e2e8a95f28a395)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]