thir: Add Become expression kind

Note that this doesn't implement `become` correctly, there is still no
early drop or tail calls involved. Moreother, it seems like MIR simply
can not represent tail calls in its current form so I'll probably need
to add new statement kinds or smh. to it in order to represent them...

Author: WaffleLapkin

compiler/rustc_middle/src/thir.rs

@@ -410,6 +410,10 @@ pub enum ExprKind<'tcx> {
     Return {
         value: Option<ExprId>,
     },
+    /// A `become` expression.
+    Become {
+        value: ExprId,
+    },
     /// An inline `const` block, e.g. `const {}`.
     ConstBlock {
         did: DefId,

compiler/rustc_middle/src/thir/visit.rs

@@ -100,6 +100,7 @@ pub fn walk_expr<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, expr: &Exp
                 visitor.visit_expr(&visitor.thir()[value])
             }
         }
+        Become { value } => visitor.visit_expr(&visitor.thir()[value]),
         ConstBlock { did: _, substs: _ } => {}
         Repeat { value, count: _ } => {
             visitor.visit_expr(&visitor.thir()[value]);

compiler/rustc_mir_build/src/build/expr/as_place.rs

@@ -549,6 +549,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | ExprKind::Break { .. }
             | ExprKind::Continue { .. }
             | ExprKind::Return { .. }
+            | ExprKind::Become { .. }
             | ExprKind::Literal { .. }
             | ExprKind::NamedConst { .. }
             | ExprKind::NonHirLiteral { .. }

compiler/rustc_mir_build/src/build/expr/as_rvalue.rs

@@ -532,6 +532,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | ExprKind::Break { .. }
             | ExprKind::Continue { .. }
             | ExprKind::Return { .. }
+            | ExprKind::Become { .. }
             | ExprKind::InlineAsm { .. }
             | ExprKind::PlaceTypeAscription { .. }
             | ExprKind::ValueTypeAscription { .. } => {

compiler/rustc_mir_build/src/build/expr/category.rs

@@ -82,7 +82,8 @@ impl Category {
             | ExprKind::Block { .. }
             | ExprKind::Break { .. }
             | ExprKind::Continue { .. }
-            | ExprKind::Return { .. } =>
+            | ExprKind::Return { .. }
+            | ExprKind::Become { .. } =>
             // FIXME(#27840) these probably want their own
             // category, like "nonterminating"
             {

compiler/rustc_mir_build/src/build/expr/into.rs

@@ -489,7 +489,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 block.unit()
             }
 
-            ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Return { .. } => {
+            ExprKind::Continue { .. }
+            | ExprKind::Break { .. }
+            | ExprKind::Return { .. }
+            | ExprKind::Become { .. } => {
                 unpack!(block = this.stmt_expr(block, expr, None));
                 // No assign, as these have type `!`.
                 block.unit()

compiler/rustc_mir_build/src/build/expr/stmt.rs

@@ -99,6 +99,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 BreakableTarget::Return,
                 source_info,
             ),
+            ExprKind::Become { value } => this.break_scope(
+                block,
+                Some(&this.thir[value]),
+                BreakableTarget::Become,
+                source_info,
+            ),
             _ => {
                 assert!(
                     statement_scope.is_some(),

compiler/rustc_mir_build/src/build/scope.rs

@@ -182,6 +182,7 @@ pub(crate) enum BreakableTarget {
     Continue(region::Scope),
     Break(region::Scope),
     Return,
+    Become,
 }
 
 rustc_index::newtype_index! {
@@ -627,10 +628,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 .unwrap_or_else(|| span_bug!(span, "no enclosing breakable scope found"))
         };
         let (break_index, destination) = match target {
-            BreakableTarget::Return => {
+            BreakableTarget::Return | BreakableTarget::Become => {
                 let scope = &self.scopes.breakable_scopes[0];
                 if scope.break_destination != Place::return_place() {
-                    span_bug!(span, "`return` in item with no return scope");
+                    span_bug!(span, "`return` or `become` in item with no return scope");
                 }
                 (0, Some(scope.break_destination))
             }
@@ -668,6 +669,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             (None, None) => {}
         }
 
+        // FIXME(explicit_tail_calls): this should drop stuff early for `become`
+
         let region_scope = self.scopes.breakable_scopes[break_index].region_scope;
         let scope_index = self.scopes.scope_index(region_scope, span);
         let drops = if destination.is_some() {

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -316,6 +316,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
             | ExprKind::Closure { .. }
             | ExprKind::Continue { .. }
             | ExprKind::Return { .. }
+            | ExprKind::Become { .. }
             | ExprKind::Yield { .. }
             | ExprKind::Loop { .. }
             | ExprKind::Let { .. }

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -694,8 +694,8 @@ impl<'tcx> Cx<'tcx> {
 
                 ExprKind::Repeat { value: self.mirror_expr(v), count: *count }
             }
-            hir::ExprKind::Ret(ref v) => ExprKind::Return { value: v.map(|v| self.mirror_expr(v)) },
-            hir::ExprKind::Become(_call) => unimplemented!("lol (lmao)"),
+            hir::ExprKind::Ret(v) => ExprKind::Return { value: v.map(|v| self.mirror_expr(v)) },
+            hir::ExprKind::Become(call) => ExprKind::Become { value: self.mirror_expr(call) },
             hir::ExprKind::Break(dest, ref value) => match dest.target_id {
                 Ok(target_id) => ExprKind::Break {
                     label: region::Scope { id: target_id.local_id, data: region::ScopeData::Node },