diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 491a9bbda79b1..dd7f2e44f98f7 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -1474,6 +1474,9 @@ impl Expr {
                 }
             }
 
+            ExprKind::InitBlock(..) => ExprPrecedence::Jump,
+            ExprKind::InitTail(..) => ExprPrecedence::Jump,
+
             ExprKind::Break(_ /*label*/, value)
             | ExprKind::Ret(value)
             | ExprKind::Yield(YieldKind::Prefix(value))
@@ -1595,6 +1598,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)]
 pub enum RangeLimits {
@@ -1712,6 +1728,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 989ebe14bf8fc..9e6bbf48ef089 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 f8ecff69a7635..2f42bfa159c63 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -1750,6 +1750,19 @@ macro_rules! common_visitor_and_walkers {
                     try_visit!(visit_span(vis, fn_decl_span));
                     try_visit!(visit_span(vis, 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_opt!(vis, visit_label, opt_label);
                     try_visit!(vis.visit_block(block));
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 8747e624a4a9e..eb8ba3ea976db 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,
@@ -1250,6 +1257,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 0706bdb119f01..4d23f9101e4b4 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,
@@ -886,7 +889,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;
 
@@ -894,19 +898,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..5677f0c7bad25 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
 
@@ -246,6 +252,9 @@ borrowck_value_moved_here =
 borrowck_var_borrow_by_use_in_closure =
     borrow occurs due to use in closure
 
+borrowck_var_borrow_by_use_in_init =
+    borrow occurs due to use in init
+
 borrowck_var_borrow_by_use_in_coroutine =
     borrow occurs due to use in coroutine
 
@@ -255,6 +264,12 @@ borrowck_var_borrow_by_use_place_in_closure =
         [false] borrows occur
     } due to use of {$place} in closure
 
+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_borrow_by_use_place_in_coroutine =
     {$is_single_var ->
         *[true] borrow occurs
@@ -273,6 +288,9 @@ borrowck_var_does_not_need_mut =
 borrowck_var_first_borrow_by_use_place_in_closure =
     first borrow occurs due to use of {$place} in closure
 
+borrowck_var_first_borrow_by_use_place_in_init =
+    first borrow occurs due to use of {$place} in init block
+
 borrowck_var_first_borrow_by_use_place_in_coroutine =
     first borrow occurs due to use of {$place} in coroutine
 
@@ -283,6 +301,9 @@ borrowck_var_here_defined = variable defined here
 borrowck_var_move_by_use_in_closure =
     move occurs due to use in closure
 
+borrowck_var_move_by_use_in_init =
+    move occurs due to use in init block
+
 borrowck_var_move_by_use_in_coroutine =
     move occurs due to use in coroutine
 
@@ -292,5 +313,8 @@ borrowck_var_mutable_borrow_by_use_place_in_closure =
 borrowck_var_second_borrow_by_use_place_in_closure =
     second borrow occurs due to use of {$place} in closure
 
+borrowck_var_second_borrow_by_use_place_in_init =
+    second borrow occurs due to use of {$place} in init block
+
 borrowck_var_second_borrow_by_use_place_in_coroutine =
     second borrow occurs due to use of {$place} in coroutine
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 82b300dcb17d9..e5e9a1d7fd390 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1803,6 +1803,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
+                    | ty::Init(_, _)
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
                     | ty::Coroutine(_, _)
@@ -1830,7 +1831,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 ebaa5a97a4aed..8a6b6d2e0f109 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 378ed6d0e1030..82ad177c420cf 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -100,6 +100,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 543d68d7f4519..88508645eda7b 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -496,6 +496,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 fc4d13af8c42a..a7b057d21a063 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -775,6 +775,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 459fe5935e06e..46eb21456f4c0 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,
         }
     }
@@ -310,6 +314,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 559a771931e9c..0f8c0d732fddf 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1602,6 +1602,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
@@ -2298,6 +2300,8 @@ impl Expr<'_> {
 
             ExprKind::Break(..)
             | ExprKind::Ret(..)
+            | ExprKind::InitTail(..)
+            | ExprKind::InitBlock(..)
             | ExprKind::Yield(..)
             | ExprKind::Become(..) => ExprPrecedence::Jump,
 
@@ -2395,6 +2399,8 @@ impl Expr<'_> {
             | ExprKind::If(..)
             | ExprKind::Match(..)
             | ExprKind::Closure { .. }
+            | ExprKind::InitTail(..)
+            | ExprKind::InitBlock(..)
             | ExprKind::Block(..)
             | ExprKind::Repeat(..)
             | ExprKind::Array(..)
@@ -2510,6 +2516,8 @@ impl Expr<'_> {
             | ExprKind::Continue(..)
             | ExprKind::Ret(..)
             | ExprKind::Become(..)
+            | ExprKind::InitTail(..)
+            | ExprKind::InitBlock(..)
             | ExprKind::Let(..)
             | ExprKind::Loop(..)
             | ExprKind::Assign(..)
@@ -2831,6 +2839,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),
 }
@@ -2848,6 +2862,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`].
@@ -4912,7 +4951,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 a0bc318e2ca66..8c55f51abde97 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -811,17 +811,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 {
@@ -829,7 +831,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) => {
@@ -892,7 +894,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 c11db63ba11ff..fe716470e1e09 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -353,6 +353,11 @@ 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);
+
     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 0a3e018b79a43..3e57b3c956f04 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -2313,6 +2313,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 bd25b4a326086..fbfdd40bc3c17 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -184,6 +184,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 573af01a62d49..0d08bbae980ad 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -378,7 +378,9 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         // 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/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 434375060dffe..4c5784315b010 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2288,7 +2288,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 c523a03e012e4..826f529825d83 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1444,21 +1444,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);
             }
@@ -1567,7 +1570,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 459c0498d500b..8d69ff67d18b1 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, _)
@@ -310,6 +331,39 @@ 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: const {
+                    &hir::FnDecl {
+                        inputs: &[],
+                        output: hir::FnRetTy::DefaultReturn(DUMMY_SP),
+                        c_variadic: false,
+                        implicit_self: hir::ImplicitSelfKind::None,
+                        lifetime_elision_allowed: false,
+                    }
+                },
+                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)]
@@ -353,6 +407,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),
         }
@@ -365,6 +420,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(
@@ -380,78 +436,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
@@ -469,6 +546,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) => {
@@ -497,7 +575,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
@@ -534,6 +612,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,
         }
     }
@@ -569,6 +676,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:
     ///
@@ -968,6 +1102,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 067ee0f0eb0b9..a454bdaa2c19c 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..39a98574c804c 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)?;
             }
 
@@ -561,7 +562,8 @@ 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)?;
             }
 
@@ -569,6 +571,9 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                 self.walk_captures(closure)?;
             }
 
+            hir::ExprKind::InitBlock(hir::InitBlock { .. }) => todo!("dxf investigate euv"),
+            hir::ExprKind::InitTail(_) => todo!("dxf investigate euv"),
+
             hir::ExprKind::Yield(value, _) => {
                 self.consume_expr(value)?;
             }
@@ -1413,6 +1418,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 eeb8d33ef65c3..be79850bcbdcd 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1846,7 +1846,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..92d54bc418729
--- /dev/null
+++ b/compiler/rustc_hir_typeck/src/init.rs
@@ -0,0 +1,125 @@
+#![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, exprs);
+                let mut coerce_err = CoerceMany::with_coercion_sites(err_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
+                        )
+                    };
+                    self.check_init_tail_inner(inner_kind, ret_ty, err_ty, expr);
+                }
+                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 ea8c2c6ce23a2..0e39bccd9963f 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 982cfa2e42be4..a70fd8f7376eb 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 cc3ad921489fc..bdf67214b62da 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1224,7 +1224,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 ea5485d8e5da7..1f259c1457a9e 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -1405,6 +1405,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 b0ec605a85fe5..2511248769fef 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 291707878a342..ddc67ee357c1f 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -294,7 +294,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 47ba850d50dd4..8b9a171678110 100644
--- a/compiler/rustc_middle/src/mir/mono.rs
+++ b/compiler/rustc_middle/src/mir/mono.rs
@@ -556,6 +556,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 6b262a2750059..916392eb04145 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/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 98b2ce01d89b2..60530b853a05b 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -539,6 +539,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
+            | ty::Init(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
@@ -2493,6 +2494,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 21b7500e46fe0..46e201b387aed 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 09379d9d8059f..74708f45a7edc 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 b780b1c5776bc..ba2ed07ab3d28 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1762,6 +1762,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 1dba4a7b040a7..fb29462a6cc48 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 af9c98bd87d0e..bda21b0a261e5 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..6846cfa0ba1e2 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,16 @@ impl<'tcx> Ty<'tcx> {
         Ty::new(tcx, Closure(def_id, closure_args))
     }
 
+    #[inline]
+    pub fn new_init(
+        tcx: TyCtxt<'tcx>,
+        def_id: DefId,
+        closure_args: GenericArgsRef<'tcx>,
+    ) -> Ty<'tcx> {
+        tcx.debug_assert_args_compatible(def_id, closure_args);
+        Ty::new(tcx, Init(def_id, closure_args))
+    }
+
     #[inline]
     pub fn new_coroutine_closure(
         tcx: TyCtxt<'tcx>,
@@ -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 69b8be3d9cbc3..399ef7694694f 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -599,9 +599,9 @@ 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)
     }
@@ -1173,6 +1173,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Bound(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Dynamic(..)
             | ty::Foreign(_)
             | ty::Coroutine(..)
@@ -1209,6 +1210,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(..)
@@ -1268,6 +1274,7 @@ impl<'tcx> Ty<'tcx> {
             ty::Adt(..)
             | ty::Bound(..)
             | ty::Closure(..)
+            | ty::Init(..)
             | ty::CoroutineClosure(..)
             | ty::Dynamic(..)
             | ty::Foreign(_)
@@ -1430,6 +1437,7 @@ impl<'tcx> Ty<'tcx> {
             ty::FnDef(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Dynamic(..)
             | ty::Coroutine(..) => false,
 
@@ -1552,6 +1560,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 08f3ce5fd67ef..061392d8bc0b0 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 cdbc74cdfa841..8d544a6631d64 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 131064f9832c0..5cb7c01efd9ec 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 098dc9dbaf0c9..5584acd9852e5 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(..) => {
@@ -1240,6 +1241,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 cfc0399b0ca96..77124c722e940 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -723,6 +723,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..f7eb81da09801 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 f8f489d7d0673..fa18523ea3013 100644
--- a/compiler/rustc_passes/src/check_export.rs
+++ b/compiler/rustc_passes/src/check_export.rs
@@ -293,6 +293,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 40bc18939d636..b5fb4b089b6a2 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 3088e189c2073..e080b23cf6333 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_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index e53cebc59baf3..02c0360af8744 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -404,6 +404,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 963f4c77d809d..7c4bdad9f3f69 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -187,7 +187,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();
@@ -637,6 +638,7 @@ impl<'tcx> EmbargoVisitor<'tcx> {
             | DefKind::GlobalAsm
             | DefKind::Impl { .. }
             | DefKind::Closure
+            | DefKind::Init
             | DefKind::SyntheticCoroutineBody => (),
         }
     }
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index eeb8cb893d75b..931e7f4030f36 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -262,6 +262,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 1e345b11c1466..c6191a0a3fc5c 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -364,6 +364,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_smir/src/rustc_smir/bridge.rs b/compiler/rustc_smir/src/rustc_smir/bridge.rs
index a31eb93d0e80d..d3fc15b653a6f 100644
--- a/compiler/rustc_smir/src/rustc_smir/bridge.rs
+++ b/compiler/rustc_smir/src/rustc_smir/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_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs
index e8b7a3fec0923..056021d7743d9 100644
--- a/compiler/rustc_smir/src/rustc_smir/mod.rs
+++ b/compiler/rustc_smir/src/rustc_smir/mod.rs
@@ -124,6 +124,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))
     }
@@ -210,6 +214,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_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs
index a19968d2ab77d..13ac06122586c 100644
--- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs
+++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs
@@ -48,6 +48,7 @@ impl Bridge for BridgeTys {
     type ForeignDef = stable_mir::ty::ForeignDef;
     type FnDef = stable_mir::ty::FnDef;
     type ClosureDef = stable_mir::ty::ClosureDef;
+    type InitDef = stable_mir::ty::InitDef;
     type CoroutineDef = stable_mir::ty::CoroutineDef;
     type CoroutineClosureDef = stable_mir::ty::CoroutineClosureDef;
     type AliasDef = stable_mir::ty::AliasDef;
diff --git a/compiler/rustc_smir/src/stable_mir/mod.rs b/compiler/rustc_smir/src/stable_mir/mod.rs
index 70c09c1285416..ff3d10ad604bd 100644
--- a/compiler/rustc_smir/src/stable_mir/mod.rs
+++ b/compiler/rustc_smir/src/stable_mir/mod.rs
@@ -262,6 +262,7 @@ bridge_impl!(ForeignModuleDef, stable_mir::ty::ForeignModuleDef);
 bridge_impl!(ForeignDef, stable_mir::ty::ForeignDef);
 bridge_impl!(FnDef, stable_mir::ty::FnDef);
 bridge_impl!(ClosureDef, stable_mir::ty::ClosureDef);
+bridge_impl!(InitDef, stable_mir::ty::InitDef);
 bridge_impl!(CoroutineDef, stable_mir::ty::CoroutineDef);
 bridge_impl!(CoroutineClosureDef, stable_mir::ty::CoroutineClosureDef);
 bridge_impl!(AliasDef, stable_mir::ty::AliasDef);
diff --git a/compiler/rustc_smir/src/stable_mir/ty.rs b/compiler/rustc_smir/src/stable_mir/ty.rs
index 004a7c0223461..4137e92908485 100644
--- a/compiler/rustc_smir/src/stable_mir/ty.rs
+++ b/compiler/rustc_smir/src/stable_mir/ty.rs
@@ -564,6 +564,7 @@ pub enum RigidTy {
     // FIXME(stable_mir): Movability here is redundant
     Coroutine(CoroutineDef, GenericArgs, Movability),
     CoroutineClosure(CoroutineClosureDef, GenericArgs),
+    Init(InitDef, GenericArgs),
     Dynamic(Vec<Binder<ExistentialPredicate>>, Region, DynKind),
     Never,
     Tuple(Vec<Ty>),
@@ -757,6 +758,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_smir/src/stable_mir/unstable/convert/internal.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs
index 37c93af392ec9..f7d2393c0b25f 100644
--- a/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs
+++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs
@@ -178,6 +178,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_smir/src/stable_mir/unstable/convert/stable/ty.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs
index 596c8b96bfcd0..36641691f4707 100644
--- a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs
@@ -459,6 +459,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),
@@ -974,6 +978,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(..) => {
diff --git a/compiler/rustc_smir/src/stable_mir/unstable/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs
index 77a772019ebe7..4ea91b84f95f1 100644
--- a/compiler/rustc_smir/src/stable_mir/unstable/mod.rs
+++ b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs
@@ -197,9 +197,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_smir/src/stable_mir/visitor.rs b/compiler/rustc_smir/src/stable_mir/visitor.rs
index 31a53d1b19d96..8a9904988988f 100644
--- a/compiler/rustc_smir/src/stable_mir/visitor.rs
+++ b/compiler/rustc_smir/src/stable_mir/visitor.rs
@@ -167,6 +167,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_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 09f01d8704e2a..bfbbd099f5b4e 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1199,6 +1199,11 @@ symbols! {
         infer_static_outlives_requirements,
         inherent_associated_types,
         inherit,
+        init,
+        init_error,
+        init_init,
+        init_layout,
+        init_trait,
         inlateout,
         inline,
         inline_const,
@@ -1216,6 +1221,7 @@ symbols! {
         intrinsics,
         intrinsics_unaligned_volatile_load,
         intrinsics_unaligned_volatile_store,
+        in_place_initialization,
         io_error_new,
         io_errorkind,
         io_stderr,
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 28d572b303ac5..73d1773fbe4ae 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
@@ -1680,6 +1680,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,
             }
         }
@@ -1771,6 +1772,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 176d308de9139..c637b6b7bb78f 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -372,7 +372,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..992374951b6ec 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1037,6 +1037,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 +1092,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(_)
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 81ce58a93fa9d..a40502db353ab 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -699,6 +699,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::CoroutineClosure(..)
                 | ty::Coroutine(_, _)
                 | ty::CoroutineWitness(..)
+                | ty::Init(..)
                 | ty::UnsafeBinder(_)
                 | ty::Never
                 | ty::Tuple(_)
@@ -864,6 +865,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)
                 | ty::Coroutine(..)
+                | ty::Init(..)
                 | ty::Never
                 | ty::Tuple(_)
                 | ty::CoroutineWitness(..)
@@ -1197,6 +1199,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::Never
             | ty::Alias(..)
             | ty::Param(_)
@@ -1236,6 +1239,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::Init(..)
             | ty::UnsafeBinder(_)
             | ty::Never
             | ty::Tuple(..)
@@ -1289,6 +1293,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 a6b77583fdcda..3a378b38b7c0f 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -1289,6 +1289,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 af3641c22ed82..5db544f47f810 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2128,6 +2128,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Array(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
+            | ty::Init(..)
             | ty::Never
             | ty::Error(_) => {
                 // safe for everything
@@ -2255,7 +2256,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 Where(hidden_types)
             }
 
-            ty::Closure(_, args) => {
+            ty::Closure(_, args) | ty::Init(_, args) => {
                 // (*) binder moved here
                 let ty = self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
                 if let ty::Infer(ty::TyVar(_)) = ty.kind() {
@@ -2373,7 +2374,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 t.rebind(tys.iter().collect())
             }
 
-            ty::Closure(_, args) => {
+            ty::Closure(_, args) | ty::Init(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
                 t.rebind(vec![ty])
             }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index d4e6a23f0eb6b..6edef62667b63 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -836,7 +836,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 a225b712d4b20..3645d0f0f5948 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 3b313edea6f40..533a3d112aaa8 100644
--- a/compiler/rustc_ty_utils/src/opaque_types.rs
+++ b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -320,11 +320,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 37cc2baa402a0..bdcf050f96bd1 100644
--- a/compiler/rustc_type_ir/src/flags.rs
+++ b/compiler/rustc_type_ir/src/flags.rs
@@ -242,6 +242,7 @@ impl<I: Interner> FlagComputation<I> {
 
             ty::Closure(_, args)
             | ty::Coroutine(_, args)
+            | ty::Init(_, args)
             | ty::CoroutineClosure(_, args)
             | ty::CoroutineWitness(_, 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 2754d40fd36ce..863248efb1474 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -175,6 +175,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/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index db6fbefcf05cc..58ef0cc35fb61 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 737550eb73e99..79c0da90b6228 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..0ac0b5d75eb77
--- /dev/null
+++ b/library/core/src/init.rs
@@ -0,0 +1,93 @@
+//! 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::ptr::Pointee;
+
+/// 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) -> crate::alloc::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`].
+    #[lang = "init_init"]
+    unsafe fn init(self, slot: *mut ()) -> Result<T::Metadata, Self::Error>;
+}
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 2f701171505c7..2bb32f44a7abe 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -363,6 +363,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 311b2cb932392..e089e8cdeddd1 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -516,6 +516,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 5cd5c434521c0..c1622cdfe3031 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2247,6 +2247,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 ca6f67eb6dfd6..ec58e648b74c8 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(_)
@@ -2047,6 +2048,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 7463d7b5c3bda..aac7f66233e8e 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 c37231d093129..0b82326686d6f 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -8,9 +8,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,
-    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, Pat, PatExpr, PatExprKind, PatField, PatKind, Path, PathSegment, PrimTy, QPath, Stmt,
+    StmtKind, StructTailExpr, TraitBoundModifiers, Ty, TyKind, TyPat, TyPatKind,
 };
 use rustc_lexer::{TokenKind, tokenize};
 use rustc_lint::LateContext;
@@ -438,9 +438,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(_)
@@ -910,6 +912,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 fc6e30a980476..287dff25e1da7 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 167262dcf06b3..9702e9343c3ac 100644
--- a/tests/ui/symbol-names/basic.legacy.stderr
+++ b/tests/ui/symbol-names/basic.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN5basic4main17hc88b9d80a69d119aE)
+error: symbol-name(_ZN5basic4main17h1a54387f675100e8E)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(basic::main::hc88b9d80a69d119a)
+error: demangling(basic::main::h1a54387f675100e8)
   --> $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 4e17bdc45777f..27c97f296a5ad 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$3foo17hbddb77d6f71afb32E)
+error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17he006e39976db47aaE)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::hbddb77d6f71afb32)
+error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::he006e39976db47aa)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]