rustc_hir: add Expr! pattern macro and try it out in a couple places.

src/librustc_hir/hir.rs

@@ -1330,6 +1330,18 @@ pub struct Expr<'hir> {
     pub span: Span,
 }
 
+/// `Expr` pattern alias to facilitate pattern-matching.
+///
+/// Usage examples:
+/// * `hir::Expr!(Unary(_, hir::Expr!(Lit(_))))`
+/// * `hir::Expr! { Loop(..), hir_id: loop_id }`
+pub macro Expr($variant:ident $($rest:tt)*) {
+    $crate::hir::Expr {
+        kind: $crate::hir::ExprKind::$variant $($rest)*,
+        ..
+    }
+}
+
 // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
 rustc_data_structures::static_assert_size!(Expr<'static>, 64);

src/librustc_hir/lib.rs

@@ -4,6 +4,7 @@
 
 #![feature(crate_visibility_modifier)]
 #![feature(const_fn)] // For the unsizing cast on `&[]`
+#![feature(decl_macro)]
 #![feature(in_band_lifetimes)]
 #![feature(specialization)]
 #![recursion_limit = "256"]

src/librustc_lint/builtin.rs

@@ -1885,10 +1885,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidValue {
             const TRANSMUTE_PATH: &[Symbol] =
                 &[sym::core, sym::intrinsics, kw::Invalid, sym::transmute];
 
-            if let hir::ExprKind::Call(ref path_expr, ref args) = expr.kind {
+            match expr {
                 // Find calls to `mem::{uninitialized,zeroed}` methods.
-                if let hir::ExprKind::Path(ref qpath) = path_expr.kind {
-                    let def_id = cx.tables.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
+                hir::Expr!(Call(hir::Expr! { Path(ref qpath), hir_id: path_hir_id }, ref args)) => {
+                    let def_id = cx.tables.qpath_res(qpath, *path_hir_id).opt_def_id()?;
 
                     if cx.tcx.is_diagnostic_item(sym::mem_zeroed, def_id) {
                         return Some(InitKind::Zeroed);
@@ -1900,25 +1900,30 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidValue {
                         }
                     }
                 }
-            } else if let hir::ExprKind::MethodCall(_, _, ref args) = expr.kind {
-                // Find problematic calls to `MaybeUninit::assume_init`.
-                let def_id = cx.tables.type_dependent_def_id(expr.hir_id)?;
-                if cx.tcx.is_diagnostic_item(sym::assume_init, def_id) {
-                    // This is a call to *some* method named `assume_init`.
-                    // See if the `self` parameter is one of the dangerous constructors.
-                    if let hir::ExprKind::Call(ref path_expr, _) = args[0].kind {
-                        if let hir::ExprKind::Path(ref qpath) = path_expr.kind {
-                            let def_id =
-                                cx.tables.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
-
-                            if cx.tcx.is_diagnostic_item(sym::maybe_uninit_zeroed, def_id) {
-                                return Some(InitKind::Zeroed);
-                            } else if cx.tcx.is_diagnostic_item(sym::maybe_uninit_uninit, def_id) {
-                                return Some(InitKind::Uninit);
-                            }
-                        }
+
+                // Find problematic calls to `MaybeUninit::assume_init`, where
+                // the `self` parameter is one of the dangerous constructors.
+                hir::Expr!(
+                    MethodCall(
+                        _,
+                        _,
+                        [hir::Expr!(Call(hir::Expr! { Path(ref qpath), hir_id: path_hir_id }, _)), ..],
+                    )
+                ) if cx.tcx.is_diagnostic_item(
+                    sym::assume_init,
+                    cx.tables.type_dependent_def_id(expr.hir_id)?,
+                ) =>
+                {
+                    let def_id = cx.tables.qpath_res(qpath, *path_hir_id).opt_def_id()?;
+
+                    if cx.tcx.is_diagnostic_item(sym::maybe_uninit_zeroed, def_id) {
+                        return Some(InitKind::Zeroed);
+                    } else if cx.tcx.is_diagnostic_item(sym::maybe_uninit_uninit, def_id) {
+                        return Some(InitKind::Uninit);
                     }
                 }
+
+                _ => {}
             }
 
             None

src/librustc_lint/lib.rs

@@ -33,6 +33,7 @@
 #![feature(crate_visibility_modifier)]
 #![feature(never_type)]
 #![feature(nll)]
+#![feature(slice_patterns)]
 #![recursion_limit = "256"]
 
 #[macro_use]

src/librustc_typeck/astconv.rs

@@ -2703,14 +2703,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         let expr = &tcx.hir().body(ast_const.body).value;
 
-        let lit_input = match expr.kind {
-            hir::ExprKind::Lit(ref lit) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }),
-            hir::ExprKind::Unary(hir::UnOp::UnNeg, ref expr) => match expr.kind {
-                hir::ExprKind::Lit(ref lit) => {
-                    Some(LitToConstInput { lit: &lit.node, ty, neg: true })
-                }
-                _ => None,
-            },
+        let lit_input = match expr {
+            hir::Expr!(Lit(ref lit)) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }),
+            hir::Expr!(Unary(hir::UnOp::UnNeg, hir::Expr!(Lit(ref lit)))) => {
+                Some(LitToConstInput { lit: &lit.node, ty, neg: true })
+            }
             _ => None,
         };