Rc-lang¿ª·¢ÖܼÇ15 RustÔ´Âëѧϰ֮desugar

pub enum DesugaringKind {
    /// We desugar `if c { i } else { e }` to `match $ExprKind::Use(c) { true => i, _ => e }`.
    /// However, we do not want to blame `c` for unreachability but rather say that `i`
    /// is unreachable. This desugaring kind allows us to avoid blaming `c`.
    /// This also applies to `while` loops.
    CondTemporary,
    QuestionMark,
    TryBlock,
    /// Desugaring of an `impl Trait` in return type position
    /// to an `type Foo = impl Trait;` and replacing the
    /// `impl Trait` with `Foo`.
    OpaqueTy,
    Async,
    Await,
    ForLoop,
    LetElse,
    WhileLoop,
}

// If `cond` kind is `let`, returns `let`. Otherwise, wraps and returns `cond`
// in a temporary block.
fn manage_let_cond(&mut self, cond: &'hir hir::Expr<'hir>) -> &'hir hir::Expr<'hir> {
    fn has_let_expr<'hir>(expr: &'hir hir::Expr<'hir>) -> bool {
        match expr.kind {
            hir::ExprKind::Binary(_, lhs, rhs) => has_let_expr(lhs) || has_let_expr(rhs),
            hir::ExprKind::Let(..) => true,
            _ => false,
        }
    }
    if has_let_expr(cond) {
        cond
    } else {
        let reason = DesugaringKind::CondTemporary;
        let span_block = self.mark_span_with_reason(reason, cond.span, None);
        self.expr_drop_temps(span_block, cond, AttrVec::new())
    }
}

let lowered_cond = self.lower_expr(cond);
let new_cond = self.manage_let_cond(lowered_cond);

/// Wrap the given `expr` in a terminating scope using `hir::ExprKind::DropTemps`.
///
/// In terms of drop order, it has the same effect as wrapping `expr` in
/// `{ let _t = $expr; _t }` but should provide better compile-time performance.
///
/// The drop order can be important in e.g. `if expr { .. }`.
pub(super) fn expr_drop_temps(
    &mut self,
    span: Span,
    expr: &'hir hir::Expr<'hir>,
    attrs: AttrVec,
) -> &'hir hir::Expr<'hir> {
    self.arena.alloc(self.expr_drop_temps_mut(span, expr, attrs))
}

pub(super) fn expr_drop_temps_mut(
    &mut self,
    span: Span,
    expr: &'hir hir::Expr<'hir>,
    attrs: AttrVec,
) -> hir::Expr<'hir> {
    self.expr(span, hir::ExprKind::DropTemps(expr), attrs)
}

#![allow(unused_variables)]
fn main() {
use std::num::ParseIntError;
fn try_to_parse() -> Result<i32, ParseIntError> {
    let x: i32 = "123".parse()?; // x = 123
    let y: i32 = "24a".parse()?; // returns an Err() immediately
    Ok(x + y)                    // Doesn't run.
}

let res = try_to_parse();
println!("{:?}", res);
assert!(res.is_err())
}

/// Desugar `ExprKind::Try` from: `<expr>?` into:
/// ```rust
/// match Try::branch(<expr>) {
///     ControlFlow::Continue(val) => #[allow(unreachable_code)] val,,
///     ControlFlow::Break(residual) =>
///         #[allow(unreachable_code)]
///         // If there is an enclosing `try {...}`:
///         break 'catch_target Try::from_residual(residual),
///         // Otherwise:
///         return Try::from_residual(residual),
/// }
/// ```

fn lower_expr_try(&mut self, span: Span, sub_expr: &Expr) -> hir::ExprKind<'hir>

/// A `match` block, with a source that indicates whether or not it is
/// the result of a desugaring, and if so, which kind.
Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource)

// `Try::branch(<expr>)`
let scrutinee = {
    // expand <expr>
    let sub_expr = self.lower_expr_mut(sub_expr);

    self.expr_call_lang_item_fn(
        unstable_span,
        hir::LangItem::TryTraitBranch,
        arena_vec![self; sub_expr],
        None,
    )
};

// `ControlFlow::Break(residual) =>
//     #[allow(unreachable_code)]
//     return Try::from_residual(residual),`
let break_arm = {
		... // Ê¡ÂÔ
    let break_pat = self.pat_cf_break(try_span, residual_local);
    self.arm(break_pat, ret_expr)
};

// `ControlFlow::Break(residual) =>
//     #[allow(unreachable_code)]
//     return Try::from_residual(residual),`
let break_arm = {
		... // Ê¡ÂÔ
    let break_pat = self.pat_cf_break(try_span, residual_local);
    self.arm(break_pat, ret_expr)
};

let attr = {
    // `allow(unreachable_code)`
    let allow = {
        let allow_ident = Ident::new(sym::allow, self.lower_span(span));
        let uc_ident = Ident::new(sym::unreachable_code, self.lower_span(span));
        let uc_nested = attr::mk_nested_word_item(uc_ident);
        attr::mk_list_item(allow_ident, vec![uc_nested])
    };
    attr::mk_attr_outer(allow)
};
let attrs = vec![attr];

/// Desugar `try { <stmts>; <expr> }` into `{ <stmts>; ::std::ops::Try::from_output(<expr>) }`,
/// `try { <stmts>; }` into `{ <stmts>; ::std::ops::Try::from_output(()) }`
/// and save the block id to use it as a break target for desugaring of the `?` operator.

fn lower_expr_try_block(&mut self, body: &Block) -> hir::ExprKind<'hir> {
    self.with_catch_scope(body.id, |this| {
        let mut block = this.lower_block_noalloc(body, true);

        // Final expression of the block (if present) or `()` with span at the end of block
        let (try_span, tail_expr) = if let Some(expr) = block.expr.take() {
            (
                this.mark_span_with_reason(
                    DesugaringKind::TryBlock,
                    expr.span,
                    this.allow_try_trait.clone(),
                ),
                expr,
            )
        } else {
            let try_span = this.mark_span_with_reason(
                DesugaringKind::TryBlock,
                this.sess.source_map().end_point(body.span),
                this.allow_try_trait.clone(),
            );

            (try_span, this.expr_unit(try_span))
        };

        let ok_wrapped_span =
            this.mark_span_with_reason(DesugaringKind::TryBlock, tail_expr.span, None);

        // `::std::ops::Try::from_output($tail_expr)`
        block.expr = Some(this.wrap_in_try_constructor(
            hir::LangItem::TryTraitFromOutput,
            try_span,
            tail_expr,
            ok_wrapped_span,
        ));

        hir::ExprKind::Block(this.arena.alloc(block), None)
    })
}

type Foo = impl Bar;

/// Desugaring of an `impl Trait` in return type position
/// to an `type Foo = impl Trait;` and replacing the
/// `impl Trait` with `Foo`.

fn lower_opaque_impl_trait(
        &mut self,
        span: Span,
        fn_def_id: Option<LocalDefId>,
        origin: hir::OpaqueTyOrigin,
        opaque_ty_node_id: NodeId,
        capturable_lifetimes: Option<&FxHashSet<hir::LifetimeName>>,
        lower_bounds: impl FnOnce(&mut Self) -> hir::GenericBounds<'hir>,
    ) -> hir::TyKind<'hir> 

// `impl Trait` now just becomes `Foo<'a, 'b, ..>`.
    hir::TyKind::OpaqueDef(hir::ItemId { def_id: opaque_ty_def_id }, lifetimes)
}

...
TyKind::ImplTrait(def_node_id, ref bounds) => {
  let span = t.span;
  match itctx {
      ImplTraitContext::ReturnPositionOpaqueTy { fn_def_id, origin } => self
          .lower_opaque_impl_trait(
              span,
              Some(fn_def_id),
              origin,
              def_node_id,
              None,
              |this| this.lower_param_bounds(bounds, itctx),
          ),
      ImplTraitContext::TypeAliasesOpaqueTy { ref capturable_lifetimes } => {
          // Reset capturable lifetimes, any nested impl trait
          // types will inherit lifetimes from this opaque type,
          // so don't need to capture them again.
          let nested_itctx = ImplTraitContext::TypeAliasesOpaqueTy {
              capturable_lifetimes: &mut FxHashSet::default(),
          };
          self.lower_opaque_impl_trait(
              span,
              None,
              hir::OpaqueTyOrigin::TyAlias,
              def_node_id,
              Some(capturable_lifetimes),
              |this| this.lower_param_bounds(bounds, nested_itctx),
          )
      }
...

/// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree,
/// and if so, what meaning it has.
#[derive(Debug)]
enum ImplTraitContext<'b, 'a> {
    /// Treat `impl Trait` as shorthand for a new universal generic parameter.
    /// Example: `fn foo(x: impl Debug)`, where `impl Debug` is conceptually
    /// equivalent to a fresh universal parameter like `fn foo<T: Debug>(x: T)`.
    ///
    /// Newly generated parameters should be inserted into the given `Vec`.
    Universal(&'b mut Vec<hir::GenericParam<'a>>, LocalDefId),

    /// Treat `impl Trait` as shorthand for a new opaque type.
    /// Example: `fn foo() -> impl Debug`, where `impl Debug` is conceptually
    /// equivalent to a new opaque type like `type T = impl Debug; fn foo() -> T`.
    ///
    ReturnPositionOpaqueTy {
        /// `DefId` for the parent function, used to look up necessary
        /// information later.
        fn_def_id: LocalDefId,
        /// Origin: Either OpaqueTyOrigin::FnReturn or OpaqueTyOrigin::AsyncFn,
        origin: hir::OpaqueTyOrigin,
    },
    /// Impl trait in type aliases.
    TypeAliasesOpaqueTy {
        /// Set of lifetimes that this opaque type can capture, if it uses
        /// them. This includes lifetimes bound since we entered this context.
        /// For example:
        ///
        /// ```
        /// type A<'b> = impl for<'a> Trait<'a, Out = impl Sized + 'a>;
        /// ```
        ///
        /// Here the inner opaque type captures `'a` because it uses it. It doesn't
        /// need to capture `'b` because it already inherits the lifetime
        /// parameter from `A`.
        // FIXME(impl_trait): but `required_region_bounds` will ICE later
        // anyway.
        capturable_lifetimes: &'b mut FxHashSet<hir::LifetimeName>,
    },
    /// `impl Trait` is not accepted in this position.
    Disallowed(ImplTraitPosition),
}

fn lower_expr_for(
        &mut self,
        e: &Expr,
        pat: &Pat,
        head: &Expr,
        body: &Block,
        opt_label: Option<Label>,
    ) -> hir::Expr<'hir> {

/// Desugar `ExprForLoop` from: `[opt_ident]: for <pat> in <head> <body>` into:
/// ```rust
/// {
///     let result = match IntoIterator::into_iter(<head>) {
///         mut iter => {
///             [opt_ident]: loop {
///                 match Iterator::next(&mut iter) {
///                     None => break,
///                     Some(<pat>) => <body>,
///                 };
///             }
///         }
///     };
///     result
/// }
/// ```

let mut expr = None;
        while let [s, tail @ ..] = ast_stmts {
            match s.kind {
                StmtKind::Local(ref local) => {
                    let hir_id = self.lower_node_id(s.id);
                    match &local.kind {
                        LocalKind::InitElse(init, els) => {
                            let e = self.lower_let_else(hir_id, local, init, els, tail);
                            expr = Some(e);
														// remaining statements are in let-else expression
                            break;

pub enum LocalKind {
	...
	/// Local declaration with an initializer and an `else` clause.
	/// Example: `let Some(x) = y else { return };`
	InitElse(P<Expr>, P<Block>),
}

fn lower_let_else(
        &mut self,
        stmt_hir_id: hir::HirId,
        local: &Local,
        init: &Expr,
        els: &Block,
        tail: &[Stmt],
    ) -> &'hir hir::Expr<'hir> {

fn lower_let_else(
        &mut self,
        stmt_hir_id: hir::HirId,
        local: &Local,
        init: &Expr,
        els: &Block,
        tail: &[Stmt],
    ) -> &'hir hir::Expr<'hir> {
	let ty = local
	      .ty
	      .as_ref()
	      .map(|t| self.lower_ty(t, ImplTraitContext::Disallowed(ImplTraitPosition::Variable)));
  let span = self.lower_span(local.span);
  let span = self.mark_span_with_reason(DesugaringKind::LetElse, span, None);
  let init = self.lower_expr(init);
  let local_hir_id = self.lower_node_id(local.id);
  self.lower_attrs(local_hir_id, &local.attrs);
  let let_expr = {
      let lex = self.arena.alloc(hir::Let {
          hir_id: local_hir_id,
          pat: self.lower_pat(&local.pat),
          ty,
          init,
          span,
      });
      self.arena.alloc(self.expr(span, hir::ExprKind::Let(lex), AttrVec::new()))
  };
  let then_expr = {
      let (stmts, expr) = self.lower_stmts(tail);
      let block = self.block_all(span, stmts, expr);
      self.arena.alloc(self.expr_block(block, AttrVec::new()))
  };
  let else_expr = {
      let block = self.lower_block(els, false);
      self.arena.alloc(self.expr_block(block, AttrVec::new()))
  };
  self.alias_attrs(let_expr.hir_id, local_hir_id);
  self.alias_attrs(else_expr.hir_id, local_hir_id);
  let if_expr = self.arena.alloc(hir::Expr {
      hir_id: stmt_hir_id,
      span,
      kind: hir::ExprKind::If(let_expr, then_expr, Some(else_expr)),
  });
  if !self.sess.features_untracked().let_else {
      feature_err(
          &self.sess.parse_sess,
          sym::let_else,
          local.span,
          "`let...else` statements are unstable",
      )
      .emit();
  }
  if_expr
}

let let_expr = {
    let lex = self.arena.alloc(hir::Let {
        hir_id: local_hir_id,
        pat: self.lower_pat(&local.pat),
        ty,
        init,
        span,
    });
    self.arena.alloc(self.expr(span, hir::ExprKind::Let(lex), AttrVec::new()))
};

/// Represents a `let <pat>[: <ty>] = <expr>` expression (not a Local), occurring in an `if-let` or
/// `let-else`, evaluating to a boolean. Typically the pattern is refutable.
///
/// In an if-let, imagine it as `if (let <pat> = <expr>) { ... }`; in a let-else, it is part of the
/// desugaring to if-let. Only let-else supports the type annotation at present.
#[derive(Debug, HashStable_Generic)]
pub struct Let<'hir> {
    pub hir_id: HirId,
    pub span: Span,
    pub pat: &'hir Pat<'hir>,
    pub ty: Option<&'hir Ty<'hir>>,
    pub init: &'hir Expr<'hir>,
}

pub enum ExprKind<'hir> {
	...
	/// A `let $pat = $expr` expression.
  ///
  /// These are not `Local` and only occur as expressions.
  /// The `let Some(x) = foo()` in `if let Some(x) = foo()` is an example of `Let(..)`.
  Let(&'hir Let<'hir>),
	...
}

let then_expr = {
    let (stmts, expr) = self.lower_stmts(tail);
    let block = self.block_all(span, stmts, expr);
    self.arena.alloc(self.expr_block(block, AttrVec::new()))
};

let else_expr = {
    let block = self.lower_block(els, false);
    self.arena.alloc(self.expr_block(block, AttrVec::new()))
};

#![feature(let_else)]
fn main() {
    let y:Option<i32> = None;
    let Some(x) = y else { 
        println!("fail") };
    println!("test");
}

error[E0308]: `else` clause of `let...else` does not diverge
 --> src/main.rs:4:26
  |
4 |       let Some(x) = y else { 
  |  __________________________^
5 | |         println!("fail") };
  | |__________________________^ expected `!`, found `()`
  |
  = note: expected type `!`
             found type `()`
  = help: try adding a diverging expression, such as `return` or `panic!(..)`
  = help: ...or use `match` instead of `let...else`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `playground` due to previous error

...
ExprKind::While(ref cond, ref body, opt_label) => {
      self.with_loop_scope(e.id, |this| {
          let span =
              this.mark_span_with_reason(DesugaringKind::WhileLoop, e.span, None);
          this.lower_expr_while_in_loop_scope(span, cond, body, opt_label)
      })
  }
...

// We desugar: `'label: while $cond $body` into:
//
// ```
// 'label: loop {
//   if { let _t = $cond; _t } {
//     $body
//   }
//   else {
//     break;
//   }
// }
// ```
//
// Wrap in a construct equivalent to `{ let _t = $cond; _t }`
// to preserve drop semantics since `while $cond { ... }` does not
// let temporaries live outside of `cond`.

fn lower_expr_while_in_loop_scope(
    &mut self,
    span: Span,
    cond: &Expr,
    body: &Block,
    opt_label: Option<Label>,
) -> hir::ExprKind<'hir> {
    let lowered_cond = self.with_loop_condition_scope(|t| t.lower_expr(cond));
    let new_cond = self.manage_let_cond(lowered_cond);
    let then = self.lower_block_expr(body);
    let expr_break = self.expr_break(span, ThinVec::new());
    let stmt_break = self.stmt_expr(span, expr_break);
    let else_blk = self.block_all(span, arena_vec![self; stmt_break], None);
    let else_expr = self.arena.alloc(self.expr_block(else_blk, ThinVec::new()));
    let if_kind = hir::ExprKind::If(new_cond, self.arena.alloc(then), Some(else_expr));
    let if_expr = self.expr(span, if_kind, ThinVec::new());
    let block = self.block_expr(self.arena.alloc(if_expr));
    let span = self.lower_span(span.with_hi(cond.span.hi()));
    let opt_label = self.lower_label(opt_label);
    hir::ExprKind::Loop(block, opt_label, hir::LoopSource::While, span)
}