diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index 591ceaf28a6c6..fe69c9e634635 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -32,6 +32,9 @@
 //! get confused if the spans from leaf AST nodes occur in multiple places
 //! in the HIR, especially for multiple identifiers.
 
+mod expr;
+mod item;
+
 use crate::dep_graph::DepGraph;
 use crate::hir::{self, ParamName};
 use crate::hir::HirVec;
@@ -53,7 +56,7 @@ use rustc_data_structures::indexed_vec::IndexVec;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_data_structures::sync::Lrc;
 
-use std::collections::{BTreeSet, BTreeMap};
+use std::collections::BTreeMap;
 use std::mem;
 use smallvec::SmallVec;
 use syntax::attr;
@@ -561,90 +564,11 @@ impl<'a> LoweringContext<'a> {
             }
         }
 
-        struct ItemLowerer<'tcx, 'interner> {
-            lctx: &'tcx mut LoweringContext<'interner>,
-        }
-
-        impl<'tcx, 'interner> ItemLowerer<'tcx, 'interner> {
-            fn with_trait_impl_ref<F>(&mut self, trait_impl_ref: &Option<TraitRef>, f: F)
-            where
-                F: FnOnce(&mut Self),
-            {
-                let old = self.lctx.is_in_trait_impl;
-                self.lctx.is_in_trait_impl = if let &None = trait_impl_ref {
-                    false
-                } else {
-                    true
-                };
-                f(self);
-                self.lctx.is_in_trait_impl = old;
-            }
-        }
-
-        impl<'tcx, 'interner> Visitor<'tcx> for ItemLowerer<'tcx, 'interner> {
-            fn visit_mod(&mut self, m: &'tcx Mod, _s: Span, _attrs: &[Attribute], n: NodeId) {
-                self.lctx.modules.insert(n, hir::ModuleItems {
-                    items: BTreeSet::new(),
-                    trait_items: BTreeSet::new(),
-                    impl_items: BTreeSet::new(),
-                });
-
-                let old = self.lctx.current_module;
-                self.lctx.current_module = n;
-                visit::walk_mod(self, m);
-                self.lctx.current_module = old;
-            }
-
-            fn visit_item(&mut self, item: &'tcx Item) {
-                let mut item_hir_id = None;
-                self.lctx.with_hir_id_owner(item.id, |lctx| {
-                    if let Some(hir_item) = lctx.lower_item(item) {
-                        item_hir_id = Some(hir_item.hir_id);
-                        lctx.insert_item(hir_item);
-                    }
-                });
-
-                if let Some(hir_id) = item_hir_id {
-                    self.lctx.with_parent_item_lifetime_defs(hir_id, |this| {
-                        let this = &mut ItemLowerer { lctx: this };
-                        if let ItemKind::Impl(.., ref opt_trait_ref, _, _) = item.node {
-                            this.with_trait_impl_ref(opt_trait_ref, |this| {
-                                visit::walk_item(this, item)
-                            });
-                        } else {
-                            visit::walk_item(this, item);
-                        }
-                    });
-                }
-            }
-
-            fn visit_trait_item(&mut self, item: &'tcx TraitItem) {
-                self.lctx.with_hir_id_owner(item.id, |lctx| {
-                    let hir_item = lctx.lower_trait_item(item);
-                    let id = hir::TraitItemId { hir_id: hir_item.hir_id };
-                    lctx.trait_items.insert(id, hir_item);
-                    lctx.modules.get_mut(&lctx.current_module).unwrap().trait_items.insert(id);
-                });
-
-                visit::walk_trait_item(self, item);
-            }
-
-            fn visit_impl_item(&mut self, item: &'tcx ImplItem) {
-                self.lctx.with_hir_id_owner(item.id, |lctx| {
-                    let hir_item = lctx.lower_impl_item(item);
-                    let id = hir::ImplItemId { hir_id: hir_item.hir_id };
-                    lctx.impl_items.insert(id, hir_item);
-                    lctx.modules.get_mut(&lctx.current_module).unwrap().impl_items.insert(id);
-                });
-                visit::walk_impl_item(self, item);
-            }
-        }
-
         self.lower_node_id(CRATE_NODE_ID);
         debug_assert!(self.node_id_to_hir_id[CRATE_NODE_ID] == hir::CRATE_HIR_ID);
 
         visit::walk_crate(&mut MiscCollector { lctx: &mut self, hir_id_owner: None }, c);
-        visit::walk_crate(&mut ItemLowerer { lctx: &mut self }, c);
+        visit::walk_crate(&mut item::ItemLowerer { lctx: &mut self }, c);
 
         let module = self.lower_mod(&c.module);
         let attrs = self.lower_attrs(&c.attrs);
@@ -783,57 +707,6 @@ impl<'a> LoweringContext<'a> {
         })
     }
 
-    fn generator_movability_for_fn(
-        &mut self,
-        decl: &ast::FnDecl,
-        fn_decl_span: Span,
-        generator_kind: Option<hir::GeneratorKind>,
-        movability: Movability,
-    ) -> Option<hir::GeneratorMovability> {
-        match generator_kind {
-            Some(hir::GeneratorKind::Gen) =>  {
-                if !decl.inputs.is_empty() {
-                    span_err!(
-                        self.sess,
-                        fn_decl_span,
-                        E0628,
-                        "generators cannot have explicit arguments"
-                    );
-                    self.sess.abort_if_errors();
-                }
-                Some(match movability {
-                    Movability::Movable => hir::GeneratorMovability::Movable,
-                    Movability::Static => hir::GeneratorMovability::Static,
-                })
-            },
-            Some(hir::GeneratorKind::Async) => {
-                bug!("non-`async` closure body turned `async` during lowering");
-            },
-            None => {
-                if movability == Movability::Static {
-                    span_err!(
-                        self.sess,
-                        fn_decl_span,
-                        E0697,
-                        "closures cannot be static"
-                    );
-                }
-                None
-            },
-        }
-    }
-
-    fn record_body(&mut self, arguments: HirVec<hir::Arg>, value: hir::Expr) -> hir::BodyId {
-        let body = hir::Body {
-            generator_kind: self.generator_kind,
-            arguments,
-            value,
-        };
-        let id = body.id();
-        self.bodies.insert(id, body);
-        id
-    }
-
     fn next_id(&mut self) -> hir::HirId {
         self.lower_node_id(self.sess.next_node_id())
     }
@@ -1037,38 +910,6 @@ impl<'a> LoweringContext<'a> {
         res
     }
 
-    // Same as the method above, but accepts `hir::GenericParam`s
-    // instead of `ast::GenericParam`s.
-    // This should only be used with generics that have already had their
-    // in-band lifetimes added. In practice, this means that this function is
-    // only used when lowering a child item of a trait or impl.
-    fn with_parent_item_lifetime_defs<T, F>(&mut self,
-        parent_hir_id: hir::HirId,
-        f: F
-    ) -> T where
-        F: FnOnce(&mut LoweringContext<'_>) -> T,
-    {
-        let old_len = self.in_scope_lifetimes.len();
-
-        let parent_generics = match self.items.get(&parent_hir_id).unwrap().node {
-            hir::ItemKind::Impl(_, _, _, ref generics, ..)
-            | hir::ItemKind::Trait(_, _, ref generics, ..) => {
-                &generics.params[..]
-            }
-            _ => &[],
-        };
-        let lt_def_names = parent_generics.iter().filter_map(|param| match param.kind {
-            hir::GenericParamKind::Lifetime { .. } => Some(param.name.ident().modern()),
-            _ => None,
-        });
-        self.in_scope_lifetimes.extend(lt_def_names);
-
-        let res = f(self);
-
-        self.in_scope_lifetimes.truncate(old_len);
-        res
-    }
-
     /// Appends in-band lifetime defs and argument-position `impl
     /// Trait` defs to the existing set of generics.
     ///
@@ -1130,131 +971,6 @@ impl<'a> LoweringContext<'a> {
         (lowered_generics, res)
     }
 
-    fn with_catch_scope<T, F>(&mut self, catch_id: NodeId, f: F) -> T
-    where
-        F: FnOnce(&mut LoweringContext<'_>) -> T,
-    {
-        let len = self.catch_scopes.len();
-        self.catch_scopes.push(catch_id);
-
-        let result = f(self);
-        assert_eq!(
-            len + 1,
-            self.catch_scopes.len(),
-            "catch scopes should be added and removed in stack order"
-        );
-
-        self.catch_scopes.pop().unwrap();
-
-        result
-    }
-
-    fn make_async_expr(
-        &mut self,
-        capture_clause: CaptureBy,
-        closure_node_id: NodeId,
-        ret_ty: Option<AstP<Ty>>,
-        span: Span,
-        body: impl FnOnce(&mut LoweringContext<'_>) -> hir::Expr,
-    ) -> hir::ExprKind {
-        let capture_clause = self.lower_capture_clause(capture_clause);
-        let output = match ret_ty {
-            Some(ty) => FunctionRetTy::Ty(ty),
-            None => FunctionRetTy::Default(span),
-        };
-        let ast_decl = FnDecl {
-            inputs: vec![],
-            output,
-            c_variadic: false
-        };
-        let decl = self.lower_fn_decl(&ast_decl, None, /* impl trait allowed */ false, None);
-        let body_id = self.lower_fn_body(&ast_decl, |this| {
-            this.generator_kind = Some(hir::GeneratorKind::Async);
-            body(this)
-        });
-        let generator = hir::Expr {
-            hir_id: self.lower_node_id(closure_node_id),
-            node: hir::ExprKind::Closure(capture_clause, decl, body_id, span,
-                Some(hir::GeneratorMovability::Static)),
-            span,
-            attrs: ThinVec::new(),
-        };
-
-        let unstable_span = self.mark_span_with_reason(
-            DesugaringKind::Async,
-            span,
-            self.allow_gen_future.clone(),
-        );
-        let gen_future = self.expr_std_path(
-            unstable_span, &[sym::future, sym::from_generator], None, ThinVec::new());
-        hir::ExprKind::Call(P(gen_future), hir_vec![generator])
-    }
-
-    fn lower_body(
-        &mut self,
-        f: impl FnOnce(&mut LoweringContext<'_>) -> (HirVec<hir::Arg>, hir::Expr),
-    ) -> hir::BodyId {
-        let prev_gen_kind = self.generator_kind.take();
-        let (arguments, result) = f(self);
-        let body_id = self.record_body(arguments, result);
-        self.generator_kind = prev_gen_kind;
-        body_id
-    }
-
-    fn lower_fn_body(
-        &mut self,
-        decl: &FnDecl,
-        body: impl FnOnce(&mut LoweringContext<'_>) -> hir::Expr,
-    ) -> hir::BodyId {
-        self.lower_body(|this| (
-            decl.inputs.iter().map(|x| this.lower_arg(x)).collect(),
-            body(this),
-        ))
-    }
-
-    fn lower_const_body(&mut self, expr: &Expr) -> hir::BodyId {
-        self.lower_body(|this| (hir_vec![], this.lower_expr(expr)))
-    }
-
-    fn with_loop_scope<T, F>(&mut self, loop_id: NodeId, f: F) -> T
-    where
-        F: FnOnce(&mut LoweringContext<'_>) -> T,
-    {
-        // We're no longer in the base loop's condition; we're in another loop.
-        let was_in_loop_condition = self.is_in_loop_condition;
-        self.is_in_loop_condition = false;
-
-        let len = self.loop_scopes.len();
-        self.loop_scopes.push(loop_id);
-
-        let result = f(self);
-        assert_eq!(
-            len + 1,
-            self.loop_scopes.len(),
-            "loop scopes should be added and removed in stack order"
-        );
-
-        self.loop_scopes.pop().unwrap();
-
-        self.is_in_loop_condition = was_in_loop_condition;
-
-        result
-    }
-
-    fn with_loop_condition_scope<T, F>(&mut self, f: F) -> T
-    where
-        F: FnOnce(&mut LoweringContext<'_>) -> T,
-    {
-        let was_in_loop_condition = self.is_in_loop_condition;
-        self.is_in_loop_condition = true;
-
-        let result = f(self);
-
-        self.is_in_loop_condition = was_in_loop_condition;
-
-        result
-    }
-
     fn with_dyn_type_scope<T, F>(&mut self, in_scope: bool, f: F) -> T
     where
         F: FnOnce(&mut LoweringContext<'_>) -> T,
@@ -1295,36 +1011,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_label(&mut self, label: Option<Label>) -> Option<hir::Label> {
-        label.map(|label| hir::Label {
-            ident: label.ident,
-        })
-    }
-
-    fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
-        let target_id = match destination {
-            Some((id, _)) => {
-                if let Some(loop_id) = self.resolver.get_label_res(id) {
-                    Ok(self.lower_node_id(loop_id))
-                } else {
-                    Err(hir::LoopIdError::UnresolvedLabel)
-                }
-            }
-            None => {
-                self.loop_scopes
-                    .last()
-                    .cloned()
-                    .map(|id| Ok(self.lower_node_id(id)))
-                    .unwrap_or(Err(hir::LoopIdError::OutsideLoopScope))
-                    .into()
-            }
-        };
-        hir::Destination {
-            label: self.lower_label(destination.map(|(_, label)| label)),
-            target_id,
-        }
-    }
-
     fn lower_attrs_extendable(&mut self, attrs: &[Attribute]) -> Vec<Attribute> {
         attrs
             .iter()
@@ -1378,20 +1064,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_arm(&mut self, arm: &Arm) -> hir::Arm {
-        hir::Arm {
-            hir_id: self.next_id(),
-            attrs: self.lower_attrs(&arm.attrs),
-            pats: arm.pats.iter().map(|x| self.lower_pat(x)).collect(),
-            guard: match arm.guard {
-                Some(ref x) => Some(hir::Guard::If(P(self.lower_expr(x)))),
-                _ => None,
-            },
-            body: P(self.lower_expr(&arm.body)),
-            span: arm.span,
-        }
-    }
-
     /// Given an associated type constraint like one of these:
     ///
     /// ```
@@ -1970,36 +1642,6 @@ impl<'a> LoweringContext<'a> {
         )
     }
 
-    fn lower_foreign_mod(&mut self, fm: &ForeignMod) -> hir::ForeignMod {
-        hir::ForeignMod {
-            abi: fm.abi,
-            items: fm.items
-                .iter()
-                .map(|x| self.lower_foreign_item(x))
-                .collect(),
-        }
-    }
-
-    fn lower_global_asm(&mut self, ga: &GlobalAsm) -> P<hir::GlobalAsm> {
-        P(hir::GlobalAsm {
-            asm: ga.asm,
-            ctxt: ga.ctxt,
-        })
-    }
-
-    fn lower_variant(&mut self, v: &Variant) -> hir::Variant {
-        Spanned {
-            node: hir::VariantKind {
-                ident: v.node.ident,
-                id: self.lower_node_id(v.node.id),
-                attrs: self.lower_attrs(&v.node.attrs),
-                data: self.lower_variant_data(&v.node.data),
-                disr_expr: v.node.disr_expr.as_ref().map(|e| self.lower_anon_const(e)),
-            },
-            span: v.span,
-        }
-    }
-
     fn lower_qpath(
         &mut self,
         id: NodeId,
@@ -2459,15 +2101,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_arg(&mut self, arg: &Arg) -> hir::Arg {
-        hir::Arg {
-            attrs: self.lower_attrs(&arg.attrs),
-            hir_id: self.lower_node_id(arg.id),
-            pat: self.lower_pat(&arg.pat),
-            span: arg.span,
-        }
-    }
-
     fn lower_fn_args_to_names(&mut self, decl: &FnDecl) -> hir::HirVec<Ident> {
         decl.inputs
             .iter()
@@ -2933,169 +2566,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_generics(
-        &mut self,
-        generics: &Generics,
-        itctx: ImplTraitContext<'_>)
-        -> hir::Generics
-    {
-        // Collect `?Trait` bounds in where clause and move them to parameter definitions.
-        // FIXME: this could probably be done with less rightward drift. It also looks like two
-        // control paths where `report_error` is called are the only paths that advance to after the
-        // match statement, so the error reporting could probably just be moved there.
-        let mut add_bounds: NodeMap<Vec<_>> = Default::default();
-        for pred in &generics.where_clause.predicates {
-            if let WherePredicate::BoundPredicate(ref bound_pred) = *pred {
-                'next_bound: for bound in &bound_pred.bounds {
-                    if let GenericBound::Trait(_, TraitBoundModifier::Maybe) = *bound {
-                        let report_error = |this: &mut Self| {
-                            this.diagnostic().span_err(
-                                bound_pred.bounded_ty.span,
-                                "`?Trait` bounds are only permitted at the \
-                                 point where a type parameter is declared",
-                            );
-                        };
-                        // Check if the where clause type is a plain type parameter.
-                        match bound_pred.bounded_ty.node {
-                            TyKind::Path(None, ref path)
-                                if path.segments.len() == 1
-                                    && bound_pred.bound_generic_params.is_empty() =>
-                            {
-                                if let Some(Res::Def(DefKind::TyParam, def_id)) = self.resolver
-                                    .get_partial_res(bound_pred.bounded_ty.id)
-                                    .map(|d| d.base_res())
-                                {
-                                    if let Some(node_id) =
-                                        self.resolver.definitions().as_local_node_id(def_id)
-                                    {
-                                        for param in &generics.params {
-                                            match param.kind {
-                                                GenericParamKind::Type { .. } => {
-                                                    if node_id == param.id {
-                                                        add_bounds.entry(param.id)
-                                                            .or_default()
-                                                            .push(bound.clone());
-                                                        continue 'next_bound;
-                                                    }
-                                                }
-                                                _ => {}
-                                            }
-                                        }
-                                    }
-                                }
-                                report_error(self)
-                            }
-                            _ => report_error(self),
-                        }
-                    }
-                }
-            }
-        }
-
-        hir::Generics {
-            params: self.lower_generic_params(&generics.params, &add_bounds, itctx),
-            where_clause: self.lower_where_clause(&generics.where_clause),
-            span: generics.span,
-        }
-    }
-
-    fn lower_where_clause(&mut self, wc: &WhereClause) -> hir::WhereClause {
-        self.with_anonymous_lifetime_mode(
-            AnonymousLifetimeMode::ReportError,
-            |this| {
-                hir::WhereClause {
-                    predicates: wc.predicates
-                        .iter()
-                        .map(|predicate| this.lower_where_predicate(predicate))
-                        .collect(),
-                    span: wc.span,
-                }
-            },
-        )
-    }
-
-    fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicate {
-        match *pred {
-            WherePredicate::BoundPredicate(WhereBoundPredicate {
-                ref bound_generic_params,
-                ref bounded_ty,
-                ref bounds,
-                span,
-            }) => {
-                self.with_in_scope_lifetime_defs(
-                    &bound_generic_params,
-                    |this| {
-                        hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
-                            bound_generic_params: this.lower_generic_params(
-                                bound_generic_params,
-                                &NodeMap::default(),
-                                ImplTraitContext::disallowed(),
-                            ),
-                            bounded_ty: this.lower_ty(bounded_ty, ImplTraitContext::disallowed()),
-                            bounds: bounds
-                                .iter()
-                                .filter_map(|bound| match *bound {
-                                    // Ignore `?Trait` bounds.
-                                    // They were copied into type parameters already.
-                                    GenericBound::Trait(_, TraitBoundModifier::Maybe) => None,
-                                    _ => Some(this.lower_param_bound(
-                                        bound,
-                                        ImplTraitContext::disallowed(),
-                                    )),
-                                })
-                                .collect(),
-                            span,
-                        })
-                    },
-                )
-            }
-            WherePredicate::RegionPredicate(WhereRegionPredicate {
-                ref lifetime,
-                ref bounds,
-                span,
-            }) => hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
-                span,
-                lifetime: self.lower_lifetime(lifetime),
-                bounds: self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
-            }),
-            WherePredicate::EqPredicate(WhereEqPredicate {
-                id,
-                ref lhs_ty,
-                ref rhs_ty,
-                span,
-            }) => {
-                hir::WherePredicate::EqPredicate(hir::WhereEqPredicate {
-                    hir_id: self.lower_node_id(id),
-                    lhs_ty: self.lower_ty(lhs_ty, ImplTraitContext::disallowed()),
-                    rhs_ty: self.lower_ty(rhs_ty, ImplTraitContext::disallowed()),
-                    span,
-                })
-            },
-        }
-    }
-
-    fn lower_variant_data(&mut self, vdata: &VariantData) -> hir::VariantData {
-        match *vdata {
-            VariantData::Struct(ref fields, recovered) => hir::VariantData::Struct(
-                fields.iter().enumerate().map(|f| self.lower_struct_field(f)).collect(),
-                recovered,
-            ),
-            VariantData::Tuple(ref fields, id) => {
-                hir::VariantData::Tuple(
-                    fields
-                        .iter()
-                        .enumerate()
-                        .map(|f| self.lower_struct_field(f))
-                        .collect(),
-                    self.lower_node_id(id),
-                )
-            },
-            VariantData::Unit(id) => {
-                hir::VariantData::Unit(self.lower_node_id(id))
-            },
-        }
-    }
-
     fn lower_trait_ref(&mut self, p: &TraitRef, itctx: ImplTraitContext<'_>) -> hir::TraitRef {
         let path = match self.lower_qpath(p.ref_id, &None, &p.path, ParamMode::Explicit, itctx) {
             hir::QPath::Resolved(None, path) => path,
@@ -3129,43 +2599,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_struct_field(&mut self, (index, f): (usize, &StructField)) -> hir::StructField {
-        let ty = if let TyKind::Path(ref qself, ref path) = f.ty.node {
-            let t = self.lower_path_ty(
-                &f.ty,
-                qself,
-                path,
-                ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
-                ImplTraitContext::disallowed()
-            );
-            P(t)
-        } else {
-            self.lower_ty(&f.ty, ImplTraitContext::disallowed())
-        };
-        hir::StructField {
-            span: f.span,
-            hir_id: self.lower_node_id(f.id),
-            ident: match f.ident {
-                Some(ident) => ident,
-                // FIXME(jseyfried): positional field hygiene.
-                None => Ident::new(sym::integer(index), f.span),
-            },
-            vis: self.lower_visibility(&f.vis, None),
-            ty,
-            attrs: self.lower_attrs(&f.attrs),
-        }
-    }
-
-    fn lower_field(&mut self, f: &Field) -> hir::Field {
-        hir::Field {
-            hir_id: self.next_id(),
-            ident: f.ident,
-            expr: P(self.lower_expr(&f.expr)),
-            span: f.span,
-            is_shorthand: f.is_shorthand,
-        }
-    }
-
     fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext<'_>) -> hir::MutTy {
         hir::MutTy {
             ty: self.lower_ty(&mt.ty, itctx),
@@ -3212,990 +2645,6 @@ impl<'a> LoweringContext<'a> {
         self.lower_block_with_stmts(b, targeted_by_break, vec![])
     }
 
-    fn lower_maybe_async_body(
-        &mut self,
-        decl: &FnDecl,
-        asyncness: IsAsync,
-        body: &Block,
-    ) -> hir::BodyId {
-        let closure_id = match asyncness {
-            IsAsync::Async { closure_id, .. } => closure_id,
-            IsAsync::NotAsync => return self.lower_fn_body(&decl, |this| {
-                let body = this.lower_block(body, false);
-                this.expr_block(body, ThinVec::new())
-            }),
-        };
-
-        self.lower_body(|this| {
-            let mut arguments: Vec<hir::Arg> = Vec::new();
-            let mut statements: Vec<hir::Stmt> = Vec::new();
-
-            // Async function arguments are lowered into the closure body so that they are
-            // captured and so that the drop order matches the equivalent non-async functions.
-            //
-            // from:
-            //
-            //     async fn foo(<pattern>: <ty>, <pattern>: <ty>, <pattern>: <ty>) {
-            //       async move {
-            //       }
-            //     }
-            //
-            // into:
-            //
-            //     fn foo(__arg0: <ty>, __arg1: <ty>, __arg2: <ty>) {
-            //       async move {
-            //         let __arg2 = __arg2;
-            //         let <pattern> = __arg2;
-            //         let __arg1 = __arg1;
-            //         let <pattern> = __arg1;
-            //         let __arg0 = __arg0;
-            //         let <pattern> = __arg0;
-            //       }
-            //     }
-            //
-            // If `<pattern>` is a simple ident, then it is lowered to a single
-            // `let <pattern> = <pattern>;` statement as an optimization.
-            for (index, argument) in decl.inputs.iter().enumerate() {
-                let argument = this.lower_arg(argument);
-                let span = argument.pat.span;
-
-                // Check if this is a binding pattern, if so, we can optimize and avoid adding a
-                // `let <pat> = __argN;` statement. In this case, we do not rename the argument.
-                let (ident, is_simple_argument) = match argument.pat.node {
-                    hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ident, _) =>
-                        (ident, true),
-                    _ => {
-                        // Replace the ident for bindings that aren't simple.
-                        let name = format!("__arg{}", index);
-                        let ident = Ident::from_str(&name);
-
-                        (ident, false)
-                    },
-                };
-
-                let desugared_span =
-                    this.mark_span_with_reason(DesugaringKind::Async, span, None);
-
-                // Construct an argument representing `__argN: <ty>` to replace the argument of the
-                // async function.
-                //
-                // If this is the simple case, this argument will end up being the same as the
-                // original argument, but with a different pattern id.
-                let mut stmt_attrs = ThinVec::new();
-                stmt_attrs.extend(argument.attrs.iter().cloned());
-                let (new_argument_pat, new_argument_id) = this.pat_ident(desugared_span, ident);
-                let new_argument = hir::Arg {
-                    attrs: argument.attrs,
-                    hir_id: argument.hir_id,
-                    pat: new_argument_pat,
-                    span: argument.span,
-                };
-
-
-                if is_simple_argument {
-                    // If this is the simple case, then we only insert one statement that is
-                    // `let <pat> = <pat>;`. We re-use the original argument's pattern so that
-                    // `HirId`s are densely assigned.
-                    let expr = this.expr_ident(desugared_span, ident, new_argument_id);
-                    let stmt = this.stmt_let_pat(
-                        stmt_attrs,
-                        desugared_span,
-                        Some(P(expr)),
-                        argument.pat,
-                        hir::LocalSource::AsyncFn
-                    );
-                    statements.push(stmt);
-                } else {
-                    // If this is not the simple case, then we construct two statements:
-                    //
-                    // ```
-                    // let __argN = __argN;
-                    // let <pat> = __argN;
-                    // ```
-                    //
-                    // The first statement moves the argument into the closure and thus ensures
-                    // that the drop order is correct.
-                    //
-                    // The second statement creates the bindings that the user wrote.
-
-                    // Construct the `let mut __argN = __argN;` statement. It must be a mut binding
-                    // because the user may have specified a `ref mut` binding in the next
-                    // statement.
-                    let (move_pat, move_id) = this.pat_ident_binding_mode(
-                        desugared_span, ident, hir::BindingAnnotation::Mutable);
-                    let move_expr = this.expr_ident(desugared_span, ident, new_argument_id);
-                    let move_stmt = this.stmt_let_pat(
-                        ThinVec::new(),
-                        desugared_span,
-                        Some(P(move_expr)),
-                        move_pat,
-                        hir::LocalSource::AsyncFn
-                    );
-
-                    // Construct the `let <pat> = __argN;` statement. We re-use the original
-                    // argument's pattern so that `HirId`s are densely assigned.
-                    let pattern_expr = this.expr_ident(desugared_span, ident, move_id);
-                    let pattern_stmt = this.stmt_let_pat(
-                        stmt_attrs,
-                        desugared_span,
-                        Some(P(pattern_expr)),
-                        argument.pat,
-                        hir::LocalSource::AsyncFn
-                    );
-
-                    statements.push(move_stmt);
-                    statements.push(pattern_stmt);
-                };
-
-                arguments.push(new_argument);
-            }
-
-            let async_expr = this.make_async_expr(
-                CaptureBy::Value, closure_id, None, body.span,
-                |this| {
-                    let body = this.lower_block_with_stmts(body, false, statements);
-                    this.expr_block(body, ThinVec::new())
-                });
-            (HirVec::from(arguments), this.expr(body.span, async_expr, ThinVec::new()))
-        })
-    }
-
-    fn lower_item_kind(
-        &mut self,
-        id: NodeId,
-        ident: &mut Ident,
-        attrs: &hir::HirVec<Attribute>,
-        vis: &mut hir::Visibility,
-        i: &ItemKind,
-    ) -> hir::ItemKind {
-        match *i {
-            ItemKind::ExternCrate(orig_name) => hir::ItemKind::ExternCrate(orig_name),
-            ItemKind::Use(ref use_tree) => {
-                // Start with an empty prefix.
-                let prefix = Path {
-                    segments: vec![],
-                    span: use_tree.span,
-                };
-
-                self.lower_use_tree(use_tree, &prefix, id, vis, ident, attrs)
-            }
-            ItemKind::Static(ref t, m, ref e) => {
-                hir::ItemKind::Static(
-                    self.lower_ty(
-                        t,
-                        if self.sess.features_untracked().impl_trait_in_bindings {
-                            ImplTraitContext::OpaqueTy(None)
-                        } else {
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
-                        }
-                    ),
-                    self.lower_mutability(m),
-                    self.lower_const_body(e),
-                )
-            }
-            ItemKind::Const(ref t, ref e) => {
-                hir::ItemKind::Const(
-                    self.lower_ty(
-                        t,
-                        if self.sess.features_untracked().impl_trait_in_bindings {
-                            ImplTraitContext::OpaqueTy(None)
-                        } else {
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
-                        }
-                    ),
-                    self.lower_const_body(e)
-                )
-            }
-            ItemKind::Fn(ref decl, header, ref generics, ref body) => {
-                let fn_def_id = self.resolver.definitions().local_def_id(id);
-                self.with_new_scopes(|this| {
-                    this.current_item = Some(ident.span);
-
-                    // Note: we don't need to change the return type from `T` to
-                    // `impl Future<Output = T>` here because lower_body
-                    // only cares about the input argument patterns in the function
-                    // declaration (decl), not the return types.
-                    let body_id = this.lower_maybe_async_body(&decl, header.asyncness.node, body);
-
-                    let (generics, fn_decl) = this.add_in_band_defs(
-                        generics,
-                        fn_def_id,
-                        AnonymousLifetimeMode::PassThrough,
-                        |this, idty| this.lower_fn_decl(
-                            &decl,
-                            Some((fn_def_id, idty)),
-                            true,
-                            header.asyncness.node.opt_return_id()
-                        ),
-                    );
-
-                    hir::ItemKind::Fn(
-                        fn_decl,
-                        this.lower_fn_header(header),
-                        generics,
-                        body_id,
-                    )
-                })
-            }
-            ItemKind::Mod(ref m) => hir::ItemKind::Mod(self.lower_mod(m)),
-            ItemKind::ForeignMod(ref nm) => hir::ItemKind::ForeignMod(self.lower_foreign_mod(nm)),
-            ItemKind::GlobalAsm(ref ga) => hir::ItemKind::GlobalAsm(self.lower_global_asm(ga)),
-            ItemKind::TyAlias(ref t, ref generics) => hir::ItemKind::TyAlias(
-                self.lower_ty(t, ImplTraitContext::disallowed()),
-                self.lower_generics(generics, ImplTraitContext::disallowed()),
-            ),
-            ItemKind::OpaqueTy(ref b, ref generics) => hir::ItemKind::OpaqueTy(
-                hir::OpaqueTy {
-                    generics: self.lower_generics(generics,
-                        ImplTraitContext::OpaqueTy(None)),
-                    bounds: self.lower_param_bounds(b,
-                        ImplTraitContext::OpaqueTy(None)),
-                    impl_trait_fn: None,
-                    origin: hir::OpaqueTyOrigin::TypeAlias,
-                },
-            ),
-            ItemKind::Enum(ref enum_definition, ref generics) => {
-                hir::ItemKind::Enum(
-                    hir::EnumDef {
-                        variants: enum_definition
-                            .variants
-                            .iter()
-                            .map(|x| self.lower_variant(x))
-                            .collect(),
-                    },
-                    self.lower_generics(generics, ImplTraitContext::disallowed()),
-                )
-            },
-            ItemKind::Struct(ref struct_def, ref generics) => {
-                let struct_def = self.lower_variant_data(struct_def);
-                hir::ItemKind::Struct(
-                    struct_def,
-                    self.lower_generics(generics, ImplTraitContext::disallowed()),
-                )
-            }
-            ItemKind::Union(ref vdata, ref generics) => {
-                let vdata = self.lower_variant_data(vdata);
-                hir::ItemKind::Union(
-                    vdata,
-                    self.lower_generics(generics, ImplTraitContext::disallowed()),
-                )
-            }
-            ItemKind::Impl(
-                unsafety,
-                polarity,
-                defaultness,
-                ref ast_generics,
-                ref trait_ref,
-                ref ty,
-                ref impl_items,
-            ) => {
-                let def_id = self.resolver.definitions().local_def_id(id);
-
-                // Lower the "impl header" first. This ordering is important
-                // for in-band lifetimes! Consider `'a` here:
-                //
-                //     impl Foo<'a> for u32 {
-                //         fn method(&'a self) { .. }
-                //     }
-                //
-                // Because we start by lowering the `Foo<'a> for u32`
-                // part, we will add `'a` to the list of generics on
-                // the impl. When we then encounter it later in the
-                // method, it will not be considered an in-band
-                // lifetime to be added, but rather a reference to a
-                // parent lifetime.
-                let lowered_trait_impl_id = self.lower_node_id(id);
-                let (generics, (trait_ref, lowered_ty)) = self.add_in_band_defs(
-                    ast_generics,
-                    def_id,
-                    AnonymousLifetimeMode::CreateParameter,
-                    |this, _| {
-                        let trait_ref = trait_ref.as_ref().map(|trait_ref| {
-                            this.lower_trait_ref(trait_ref, ImplTraitContext::disallowed())
-                        });
-
-                        if let Some(ref trait_ref) = trait_ref {
-                            if let Res::Def(DefKind::Trait, def_id) = trait_ref.path.res {
-                                this.trait_impls.entry(def_id).or_default().push(
-                                    lowered_trait_impl_id);
-                            }
-                        }
-
-                        let lowered_ty = this.lower_ty(ty, ImplTraitContext::disallowed());
-
-                        (trait_ref, lowered_ty)
-                    },
-                );
-
-                let new_impl_items = self.with_in_scope_lifetime_defs(
-                    &ast_generics.params,
-                    |this| {
-                        impl_items
-                            .iter()
-                            .map(|item| this.lower_impl_item_ref(item))
-                            .collect()
-                    },
-                );
-
-                hir::ItemKind::Impl(
-                    self.lower_unsafety(unsafety),
-                    self.lower_impl_polarity(polarity),
-                    self.lower_defaultness(defaultness, true /* [1] */),
-                    generics,
-                    trait_ref,
-                    lowered_ty,
-                    new_impl_items,
-                )
-            }
-            ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref items) => {
-                let bounds = self.lower_param_bounds(bounds, ImplTraitContext::disallowed());
-                let items = items
-                    .iter()
-                    .map(|item| self.lower_trait_item_ref(item))
-                    .collect();
-                hir::ItemKind::Trait(
-                    self.lower_is_auto(is_auto),
-                    self.lower_unsafety(unsafety),
-                    self.lower_generics(generics, ImplTraitContext::disallowed()),
-                    bounds,
-                    items,
-                )
-            }
-            ItemKind::TraitAlias(ref generics, ref bounds) => hir::ItemKind::TraitAlias(
-                self.lower_generics(generics, ImplTraitContext::disallowed()),
-                self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
-            ),
-            ItemKind::MacroDef(..)
-            | ItemKind::Mac(..) => bug!("`TyMac` should have been expanded by now"),
-        }
-
-        // [1] `defaultness.has_value()` is never called for an `impl`, always `true` in order to
-        //     not cause an assertion failure inside the `lower_defaultness` function.
-    }
-
-    fn lower_use_tree(
-        &mut self,
-        tree: &UseTree,
-        prefix: &Path,
-        id: NodeId,
-        vis: &mut hir::Visibility,
-        ident: &mut Ident,
-        attrs: &hir::HirVec<Attribute>,
-    ) -> hir::ItemKind {
-        debug!("lower_use_tree(tree={:?})", tree);
-        debug!("lower_use_tree: vis = {:?}", vis);
-
-        let path = &tree.prefix;
-        let segments = prefix
-            .segments
-            .iter()
-            .chain(path.segments.iter())
-            .cloned()
-            .collect();
-
-        match tree.kind {
-            UseTreeKind::Simple(rename, id1, id2) => {
-                *ident = tree.ident();
-
-                // First, apply the prefix to the path.
-                let mut path = Path {
-                    segments,
-                    span: path.span,
-                };
-
-                // Correctly resolve `self` imports.
-                if path.segments.len() > 1
-                    && path.segments.last().unwrap().ident.name == kw::SelfLower
-                {
-                    let _ = path.segments.pop();
-                    if rename.is_none() {
-                        *ident = path.segments.last().unwrap().ident;
-                    }
-                }
-
-                let mut resolutions = self.expect_full_res_from_use(id);
-                // We want to return *something* from this function, so hold onto the first item
-                // for later.
-                let ret_res = self.lower_res(resolutions.next().unwrap_or(Res::Err));
-
-                // Here, we are looping over namespaces, if they exist for the definition
-                // being imported. We only handle type and value namespaces because we
-                // won't be dealing with macros in the rest of the compiler.
-                // Essentially a single `use` which imports two names is desugared into
-                // two imports.
-                for (res, &new_node_id) in resolutions.zip([id1, id2].iter()) {
-                    let ident = *ident;
-                    let mut path = path.clone();
-                    for seg in &mut path.segments {
-                        seg.id = self.sess.next_node_id();
-                    }
-                    let span = path.span;
-
-                    self.with_hir_id_owner(new_node_id, |this| {
-                        let new_id = this.lower_node_id(new_node_id);
-                        let res = this.lower_res(res);
-                        let path =
-                            this.lower_path_extra(res, &path, ParamMode::Explicit, None);
-                        let item = hir::ItemKind::Use(P(path), hir::UseKind::Single);
-                        let vis = this.rebuild_vis(&vis);
-
-                        this.insert_item(
-                            hir::Item {
-                                hir_id: new_id,
-                                ident,
-                                attrs: attrs.into_iter().cloned().collect(),
-                                node: item,
-                                vis,
-                                span,
-                            },
-                        );
-                    });
-                }
-
-                let path =
-                    P(self.lower_path_extra(ret_res, &path, ParamMode::Explicit, None));
-                hir::ItemKind::Use(path, hir::UseKind::Single)
-            }
-            UseTreeKind::Glob => {
-                let path = P(self.lower_path(
-                    id,
-                    &Path {
-                        segments,
-                        span: path.span,
-                    },
-                    ParamMode::Explicit,
-                ));
-                hir::ItemKind::Use(path, hir::UseKind::Glob)
-            }
-            UseTreeKind::Nested(ref trees) => {
-                // Nested imports are desugared into simple imports.
-                // So, if we start with
-                //
-                // ```
-                // pub(x) use foo::{a, b};
-                // ```
-                //
-                // we will create three items:
-                //
-                // ```
-                // pub(x) use foo::a;
-                // pub(x) use foo::b;
-                // pub(x) use foo::{}; // <-- this is called the `ListStem`
-                // ```
-                //
-                // The first two are produced by recursively invoking
-                // `lower_use_tree` (and indeed there may be things
-                // like `use foo::{a::{b, c}}` and so forth).  They
-                // wind up being directly added to
-                // `self.items`. However, the structure of this
-                // function also requires us to return one item, and
-                // for that we return the `{}` import (called the
-                // `ListStem`).
-
-                let prefix = Path {
-                    segments,
-                    span: prefix.span.to(path.span),
-                };
-
-                // Add all the nested `PathListItem`s to the HIR.
-                for &(ref use_tree, id) in trees {
-                    let new_hir_id = self.lower_node_id(id);
-
-                    let mut prefix = prefix.clone();
-
-                    // Give the segments new node-ids since they are being cloned.
-                    for seg in &mut prefix.segments {
-                        seg.id = self.sess.next_node_id();
-                    }
-
-                    // Each `use` import is an item and thus are owners of the
-                    // names in the path. Up to this point the nested import is
-                    // the current owner, since we want each desugared import to
-                    // own its own names, we have to adjust the owner before
-                    // lowering the rest of the import.
-                    self.with_hir_id_owner(id, |this| {
-                        let mut vis = this.rebuild_vis(&vis);
-                        let mut ident = *ident;
-
-                        let item = this.lower_use_tree(use_tree,
-                                                       &prefix,
-                                                       id,
-                                                       &mut vis,
-                                                       &mut ident,
-                                                       attrs);
-
-                        this.insert_item(
-                            hir::Item {
-                                hir_id: new_hir_id,
-                                ident,
-                                attrs: attrs.into_iter().cloned().collect(),
-                                node: item,
-                                vis,
-                                span: use_tree.span,
-                            },
-                        );
-                    });
-                }
-
-                // Subtle and a bit hacky: we lower the privacy level
-                // of the list stem to "private" most of the time, but
-                // not for "restricted" paths. The key thing is that
-                // we don't want it to stay as `pub` (with no caveats)
-                // because that affects rustdoc and also the lints
-                // about `pub` items. But we can't *always* make it
-                // private -- particularly not for restricted paths --
-                // because it contains node-ids that would then be
-                // unused, failing the check that HirIds are "densely
-                // assigned".
-                match vis.node {
-                    hir::VisibilityKind::Public |
-                    hir::VisibilityKind::Crate(_) |
-                    hir::VisibilityKind::Inherited => {
-                        *vis = respan(prefix.span.shrink_to_lo(), hir::VisibilityKind::Inherited);
-                    }
-                    hir::VisibilityKind::Restricted { .. } => {
-                        // Do nothing here, as described in the comment on the match.
-                    }
-                }
-
-                let res = self.expect_full_res_from_use(id).next().unwrap_or(Res::Err);
-                let res = self.lower_res(res);
-                let path = P(self.lower_path_extra(res, &prefix, ParamMode::Explicit, None));
-                hir::ItemKind::Use(path, hir::UseKind::ListStem)
-            }
-        }
-    }
-
-    /// Paths like the visibility path in `pub(super) use foo::{bar, baz}` are repeated
-    /// many times in the HIR tree; for each occurrence, we need to assign distinct
-    /// `NodeId`s. (See, e.g., #56128.)
-    fn rebuild_use_path(&mut self, path: &hir::Path) -> hir::Path {
-        debug!("rebuild_use_path(path = {:?})", path);
-        let segments = path.segments.iter().map(|seg| hir::PathSegment {
-            ident: seg.ident,
-            hir_id: seg.hir_id.map(|_| self.next_id()),
-            res: seg.res,
-            args: None,
-            infer_args: seg.infer_args,
-        }).collect();
-        hir::Path {
-            span: path.span,
-            res: path.res,
-            segments,
-        }
-    }
-
-    fn rebuild_vis(&mut self, vis: &hir::Visibility) -> hir::Visibility {
-        let vis_kind = match vis.node {
-            hir::VisibilityKind::Public => hir::VisibilityKind::Public,
-            hir::VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
-            hir::VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
-            hir::VisibilityKind::Restricted { ref path, hir_id: _ } => {
-                hir::VisibilityKind::Restricted {
-                    path: P(self.rebuild_use_path(path)),
-                    hir_id: self.next_id(),
-                }
-            }
-        };
-        respan(vis.span, vis_kind)
-    }
-
-    fn lower_trait_item(&mut self, i: &TraitItem) -> hir::TraitItem {
-        let trait_item_def_id = self.resolver.definitions().local_def_id(i.id);
-
-        let (generics, node) = match i.node {
-            TraitItemKind::Const(ref ty, ref default) => (
-                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
-                hir::TraitItemKind::Const(
-                    self.lower_ty(ty, ImplTraitContext::disallowed()),
-                    default
-                        .as_ref()
-                        .map(|x| self.lower_const_body(x)),
-                ),
-            ),
-            TraitItemKind::Method(ref sig, None) => {
-                let names = self.lower_fn_args_to_names(&sig.decl);
-                let (generics, sig) = self.lower_method_sig(
-                    &i.generics,
-                    sig,
-                    trait_item_def_id,
-                    false,
-                    None,
-                );
-                (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Required(names)))
-            }
-            TraitItemKind::Method(ref sig, Some(ref body)) => {
-                let body_id = self.lower_fn_body(&sig.decl, |this| {
-                    let body = this.lower_block(body, false);
-                    this.expr_block(body, ThinVec::new())
-                });
-                let (generics, sig) = self.lower_method_sig(
-                    &i.generics,
-                    sig,
-                    trait_item_def_id,
-                    false,
-                    None,
-                );
-                (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Provided(body_id)))
-            }
-            TraitItemKind::Type(ref bounds, ref default) => {
-                let generics = self.lower_generics(&i.generics, ImplTraitContext::disallowed());
-                let node = hir::TraitItemKind::Type(
-                    self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
-                    default
-                        .as_ref()
-                        .map(|x| self.lower_ty(x, ImplTraitContext::disallowed())),
-                );
-
-                (generics, node)
-            },
-            TraitItemKind::Macro(..) => bug!("macro item shouldn't exist at this point"),
-        };
-
-        hir::TraitItem {
-            hir_id: self.lower_node_id(i.id),
-            ident: i.ident,
-            attrs: self.lower_attrs(&i.attrs),
-            generics,
-            node,
-            span: i.span,
-        }
-    }
-
-    fn lower_trait_item_ref(&mut self, i: &TraitItem) -> hir::TraitItemRef {
-        let (kind, has_default) = match i.node {
-            TraitItemKind::Const(_, ref default) => {
-                (hir::AssocItemKind::Const, default.is_some())
-            }
-            TraitItemKind::Type(_, ref default) => {
-                (hir::AssocItemKind::Type, default.is_some())
-            }
-            TraitItemKind::Method(ref sig, ref default) => (
-                hir::AssocItemKind::Method {
-                    has_self: sig.decl.has_self(),
-                },
-                default.is_some(),
-            ),
-            TraitItemKind::Macro(..) => unimplemented!(),
-        };
-        hir::TraitItemRef {
-            id: hir::TraitItemId { hir_id: self.lower_node_id(i.id) },
-            ident: i.ident,
-            span: i.span,
-            defaultness: self.lower_defaultness(Defaultness::Default, has_default),
-            kind,
-        }
-    }
-
-    fn lower_impl_item(&mut self, i: &ImplItem) -> hir::ImplItem {
-        let impl_item_def_id = self.resolver.definitions().local_def_id(i.id);
-
-        let (generics, node) = match i.node {
-            ImplItemKind::Const(ref ty, ref expr) => (
-                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
-                hir::ImplItemKind::Const(
-                    self.lower_ty(ty, ImplTraitContext::disallowed()),
-                    self.lower_const_body(expr),
-                ),
-            ),
-            ImplItemKind::Method(ref sig, ref body) => {
-                self.current_item = Some(i.span);
-                let body_id = self.lower_maybe_async_body(
-                    &sig.decl, sig.header.asyncness.node, body
-                );
-                let impl_trait_return_allow = !self.is_in_trait_impl;
-                let (generics, sig) = self.lower_method_sig(
-                    &i.generics,
-                    sig,
-                    impl_item_def_id,
-                    impl_trait_return_allow,
-                    sig.header.asyncness.node.opt_return_id(),
-                );
-
-                (generics, hir::ImplItemKind::Method(sig, body_id))
-            }
-            ImplItemKind::TyAlias(ref ty) => (
-                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
-                hir::ImplItemKind::TyAlias(self.lower_ty(ty, ImplTraitContext::disallowed())),
-            ),
-            ImplItemKind::OpaqueTy(ref bounds) => (
-                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
-                hir::ImplItemKind::OpaqueTy(
-                    self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
-                ),
-            ),
-            ImplItemKind::Macro(..) => bug!("`TyMac` should have been expanded by now"),
-        };
-
-        hir::ImplItem {
-            hir_id: self.lower_node_id(i.id),
-            ident: i.ident,
-            attrs: self.lower_attrs(&i.attrs),
-            generics,
-            vis: self.lower_visibility(&i.vis, None),
-            defaultness: self.lower_defaultness(i.defaultness, true /* [1] */),
-            node,
-            span: i.span,
-        }
-
-        // [1] since `default impl` is not yet implemented, this is always true in impls
-    }
-
-    fn lower_impl_item_ref(&mut self, i: &ImplItem) -> hir::ImplItemRef {
-        hir::ImplItemRef {
-            id: hir::ImplItemId { hir_id: self.lower_node_id(i.id) },
-            ident: i.ident,
-            span: i.span,
-            vis: self.lower_visibility(&i.vis, Some(i.id)),
-            defaultness: self.lower_defaultness(i.defaultness, true /* [1] */),
-            kind: match i.node {
-                ImplItemKind::Const(..) => hir::AssocItemKind::Const,
-                ImplItemKind::TyAlias(..) => hir::AssocItemKind::Type,
-                ImplItemKind::OpaqueTy(..) => hir::AssocItemKind::OpaqueTy,
-                ImplItemKind::Method(ref sig, _) => hir::AssocItemKind::Method {
-                    has_self: sig.decl.has_self(),
-                },
-                ImplItemKind::Macro(..) => unimplemented!(),
-            },
-        }
-
-        // [1] since `default impl` is not yet implemented, this is always true in impls
-    }
-
-    fn lower_mod(&mut self, m: &Mod) -> hir::Mod {
-        hir::Mod {
-            inner: m.inner,
-            item_ids: m.items.iter().flat_map(|x| self.lower_item_id(x)).collect(),
-        }
-    }
-
-    fn lower_item_id(&mut self, i: &Item) -> SmallVec<[hir::ItemId; 1]> {
-        let node_ids = match i.node {
-            ItemKind::Use(ref use_tree) => {
-                let mut vec = smallvec![i.id];
-                self.lower_item_id_use_tree(use_tree, i.id, &mut vec);
-                vec
-            }
-            ItemKind::MacroDef(..) => SmallVec::new(),
-            ItemKind::Fn(..) |
-            ItemKind::Impl(.., None, _, _) => smallvec![i.id],
-            ItemKind::Static(ref ty, ..) => {
-                let mut ids = smallvec![i.id];
-                if self.sess.features_untracked().impl_trait_in_bindings {
-                    let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
-                    visitor.visit_ty(ty);
-                }
-                ids
-            },
-            ItemKind::Const(ref ty, ..) => {
-                let mut ids = smallvec![i.id];
-                if self.sess.features_untracked().impl_trait_in_bindings {
-                    let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
-                    visitor.visit_ty(ty);
-                }
-                ids
-            },
-            _ => smallvec![i.id],
-        };
-
-        node_ids.into_iter().map(|node_id| hir::ItemId {
-            id: self.allocate_hir_id_counter(node_id)
-        }).collect()
-    }
-
-    fn lower_item_id_use_tree(&mut self,
-                              tree: &UseTree,
-                              base_id: NodeId,
-                              vec: &mut SmallVec<[NodeId; 1]>)
-    {
-        match tree.kind {
-            UseTreeKind::Nested(ref nested_vec) => for &(ref nested, id) in nested_vec {
-                vec.push(id);
-                self.lower_item_id_use_tree(nested, id, vec);
-            },
-            UseTreeKind::Glob => {}
-            UseTreeKind::Simple(_, id1, id2) => {
-                for (_, &id) in self.expect_full_res_from_use(base_id)
-                                    .skip(1)
-                                    .zip([id1, id2].iter())
-                {
-                    vec.push(id);
-                }
-            },
-        }
-    }
-
-    pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item> {
-        let mut ident = i.ident;
-        let mut vis = self.lower_visibility(&i.vis, None);
-        let mut attrs = self.lower_attrs_extendable(&i.attrs);
-        if self.resolver.has_derives(i.id, SpecialDerives::PARTIAL_EQ | SpecialDerives::EQ) {
-            // Add `#[structural_match]` if the item derived both `PartialEq` and `Eq`.
-            let ident = Ident::new(sym::structural_match, i.span);
-            attrs.push(attr::mk_attr_outer(attr::mk_word_item(ident)));
-        }
-        let attrs = attrs.into();
-
-        if let ItemKind::MacroDef(ref def) = i.node {
-            if !def.legacy || attr::contains_name(&i.attrs, sym::macro_export) {
-                let body = self.lower_token_stream(def.stream());
-                let hir_id = self.lower_node_id(i.id);
-                self.exported_macros.push(hir::MacroDef {
-                    name: ident.name,
-                    vis,
-                    attrs,
-                    hir_id,
-                    span: i.span,
-                    body,
-                    legacy: def.legacy,
-                });
-            } else {
-                self.non_exported_macro_attrs.extend(attrs.into_iter());
-            }
-            return None;
-        }
-
-        let node = self.lower_item_kind(i.id, &mut ident, &attrs, &mut vis, &i.node);
-
-        Some(hir::Item {
-            hir_id: self.lower_node_id(i.id),
-            ident,
-            attrs,
-            node,
-            vis,
-            span: i.span,
-        })
-    }
-
-    fn lower_foreign_item(&mut self, i: &ForeignItem) -> hir::ForeignItem {
-        let def_id = self.resolver.definitions().local_def_id(i.id);
-        hir::ForeignItem {
-            hir_id: self.lower_node_id(i.id),
-            ident: i.ident,
-            attrs: self.lower_attrs(&i.attrs),
-            node: match i.node {
-                ForeignItemKind::Fn(ref fdec, ref generics) => {
-                    let (generics, (fn_dec, fn_args)) = self.add_in_band_defs(
-                        generics,
-                        def_id,
-                        AnonymousLifetimeMode::PassThrough,
-                        |this, _| {
-                            (
-                                // Disallow impl Trait in foreign items
-                                this.lower_fn_decl(fdec, None, false, None),
-                                this.lower_fn_args_to_names(fdec),
-                            )
-                        },
-                    );
-
-                    hir::ForeignItemKind::Fn(fn_dec, fn_args, generics)
-                }
-                ForeignItemKind::Static(ref t, m) => {
-                    hir::ForeignItemKind::Static(
-                        self.lower_ty(t, ImplTraitContext::disallowed()), self.lower_mutability(m))
-                }
-                ForeignItemKind::Ty => hir::ForeignItemKind::Type,
-                ForeignItemKind::Macro(_) => panic!("shouldn't exist here"),
-            },
-            vis: self.lower_visibility(&i.vis, None),
-            span: i.span,
-        }
-    }
-
-    fn lower_method_sig(
-        &mut self,
-        generics: &Generics,
-        sig: &MethodSig,
-        fn_def_id: DefId,
-        impl_trait_return_allow: bool,
-        is_async: Option<NodeId>,
-    ) -> (hir::Generics, hir::MethodSig) {
-        let header = self.lower_fn_header(sig.header);
-        let (generics, decl) = self.add_in_band_defs(
-            generics,
-            fn_def_id,
-            AnonymousLifetimeMode::PassThrough,
-            |this, idty| this.lower_fn_decl(
-                &sig.decl,
-                Some((fn_def_id, idty)),
-                impl_trait_return_allow,
-                is_async,
-            ),
-        );
-        (generics, hir::MethodSig { header, decl })
-    }
-
-    fn lower_is_auto(&mut self, a: IsAuto) -> hir::IsAuto {
-        match a {
-            IsAuto::Yes => hir::IsAuto::Yes,
-            IsAuto::No => hir::IsAuto::No,
-        }
-    }
-
-    fn lower_fn_header(&mut self, h: FnHeader) -> hir::FnHeader {
-        hir::FnHeader {
-            unsafety: self.lower_unsafety(h.unsafety),
-            asyncness: self.lower_asyncness(h.asyncness.node),
-            constness: self.lower_constness(h.constness),
-            abi: h.abi,
-        }
-    }
-
-    fn lower_unsafety(&mut self, u: Unsafety) -> hir::Unsafety {
-        match u {
-            Unsafety::Unsafe => hir::Unsafety::Unsafe,
-            Unsafety::Normal => hir::Unsafety::Normal,
-        }
-    }
-
-    fn lower_constness(&mut self, c: Spanned<Constness>) -> hir::Constness {
-        match c.node {
-            Constness::Const => hir::Constness::Const,
-            Constness::NotConst => hir::Constness::NotConst,
-        }
-    }
-
-    fn lower_asyncness(&mut self, a: IsAsync) -> hir::IsAsync {
-        match a {
-            IsAsync::Async { .. } => hir::IsAsync::Async,
-            IsAsync::NotAsync => hir::IsAsync::NotAsync,
-        }
-    }
-
-    fn lower_unop(&mut self, u: UnOp) -> hir::UnOp {
-        match u {
-            UnOp::Deref => hir::UnDeref,
-            UnOp::Not => hir::UnNot,
-            UnOp::Neg => hir::UnNeg,
-        }
-    }
-
-    fn lower_binop(&mut self, b: BinOp) -> hir::BinOp {
-        Spanned {
-            node: match b.node {
-                BinOpKind::Add => hir::BinOpKind::Add,
-                BinOpKind::Sub => hir::BinOpKind::Sub,
-                BinOpKind::Mul => hir::BinOpKind::Mul,
-                BinOpKind::Div => hir::BinOpKind::Div,
-                BinOpKind::Rem => hir::BinOpKind::Rem,
-                BinOpKind::And => hir::BinOpKind::And,
-                BinOpKind::Or => hir::BinOpKind::Or,
-                BinOpKind::BitXor => hir::BinOpKind::BitXor,
-                BinOpKind::BitAnd => hir::BinOpKind::BitAnd,
-                BinOpKind::BitOr => hir::BinOpKind::BitOr,
-                BinOpKind::Shl => hir::BinOpKind::Shl,
-                BinOpKind::Shr => hir::BinOpKind::Shr,
-                BinOpKind::Eq => hir::BinOpKind::Eq,
-                BinOpKind::Lt => hir::BinOpKind::Lt,
-                BinOpKind::Le => hir::BinOpKind::Le,
-                BinOpKind::Ne => hir::BinOpKind::Ne,
-                BinOpKind::Ge => hir::BinOpKind::Ge,
-                BinOpKind::Gt => hir::BinOpKind::Gt,
-            },
-            span: b.span,
-        }
-    }
-
     fn lower_pat(&mut self, p: &Pat) -> P<hir::Pat> {
         let node = match p.node {
             PatKind::Wild => hir::PatKind::Wild,
@@ -4349,897 +2798,97 @@ impl<'a> LoweringContext<'a> {
             if let Some(rest_span) = rest_span {
                 self.ban_extra_rest_pat(rest_span, prev_rest_span.unwrap(), "slice");
             } else {
-                after.push(self.lower_pat(pat));
-            }
-        }
-
-        hir::PatKind::Slice(before.into(), slice, after.into())
-    }
-
-    fn lower_pat_ident(
-        &mut self,
-        p: &Pat,
-        binding_mode: &BindingMode,
-        ident: Ident,
-        lower_sub: impl FnOnce(&mut Self) -> Option<P<hir::Pat>>,
-    ) -> hir::PatKind {
-        match self.resolver.get_partial_res(p.id).map(|d| d.base_res()) {
-            // `None` can occur in body-less function signatures
-            res @ None | res @ Some(Res::Local(_)) => {
-                let canonical_id = match res {
-                    Some(Res::Local(id)) => id,
-                    _ => p.id,
-                };
-
-                hir::PatKind::Binding(
-                    self.lower_binding_mode(binding_mode),
-                    self.lower_node_id(canonical_id),
-                    ident,
-                    lower_sub(self),
-                )
-            }
-            Some(res) => hir::PatKind::Path(hir::QPath::Resolved(
-                None,
-                P(hir::Path {
-                    span: ident.span,
-                    res: self.lower_res(res),
-                    segments: hir_vec![hir::PathSegment::from_ident(ident)],
-                }),
-            )),
-        }
-    }
-
-    fn pat_wild_with_node_id_of(&mut self, p: &Pat) -> P<hir::Pat> {
-        self.pat_with_node_id_of(p, hir::PatKind::Wild)
-    }
-
-    /// Construct a `Pat` with the `HirId` of `p.id` lowered.
-    fn pat_with_node_id_of(&mut self, p: &Pat, node: hir::PatKind) -> P<hir::Pat> {
-        P(hir::Pat {
-            hir_id: self.lower_node_id(p.id),
-            node,
-            span: p.span,
-        })
-    }
-
-    /// Emit a friendly error for extra `..` patterns in a tuple/tuple struct/slice pattern.
-    fn ban_extra_rest_pat(&self, sp: Span, prev_sp: Span, ctx: &str) {
-        self.diagnostic()
-            .struct_span_err(sp, &format!("`..` can only be used once per {} pattern", ctx))
-            .span_label(sp, &format!("can only be used once per {} pattern", ctx))
-            .span_label(prev_sp, "previously used here")
-            .emit();
-    }
-
-    /// Used to ban the `..` pattern in places it shouldn't be semantically.
-    fn ban_illegal_rest_pat(&self, sp: Span) -> hir::PatKind {
-        self.diagnostic()
-            .struct_span_err(sp, "`..` patterns are not allowed here")
-            .note("only allowed in tuple, tuple struct, and slice patterns")
-            .emit();
-
-        // We're not in a list context so `..` can be reasonably treated
-        // as `_` because it should always be valid and roughly matches the
-        // intent of `..` (notice that the rest of a single slot is that slot).
-        hir::PatKind::Wild
-    }
-
-    fn lower_range_end(&mut self, e: &RangeEnd) -> hir::RangeEnd {
-        match *e {
-            RangeEnd::Included(_) => hir::RangeEnd::Included,
-            RangeEnd::Excluded => hir::RangeEnd::Excluded,
-        }
-    }
-
-    fn lower_anon_const(&mut self, c: &AnonConst) -> hir::AnonConst {
-        self.with_new_scopes(|this| {
-            hir::AnonConst {
-                hir_id: this.lower_node_id(c.id),
-                body: this.lower_const_body(&c.value),
-            }
-        })
-    }
-
-    fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> HirVec<hir::Expr> {
-        exprs.iter().map(|x| self.lower_expr(x)).collect()
-    }
-
-    fn lower_expr(&mut self, e: &Expr) -> hir::Expr {
-        let kind = match e.node {
-            ExprKind::Box(ref inner) => hir::ExprKind::Box(P(self.lower_expr(inner))),
-            ExprKind::Array(ref exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
-            ExprKind::Repeat(ref expr, ref count) => {
-                let expr = P(self.lower_expr(expr));
-                let count = self.lower_anon_const(count);
-                hir::ExprKind::Repeat(expr, count)
-            }
-            ExprKind::Tup(ref elts) => hir::ExprKind::Tup(self.lower_exprs(elts)),
-            ExprKind::Call(ref f, ref args) => {
-                let f = P(self.lower_expr(f));
-                hir::ExprKind::Call(f, self.lower_exprs(args))
-            }
-            ExprKind::MethodCall(ref seg, ref args) => {
-                let hir_seg = P(self.lower_path_segment(
-                    e.span,
-                    seg,
-                    ParamMode::Optional,
-                    0,
-                    ParenthesizedGenericArgs::Err,
-                    ImplTraitContext::disallowed(),
-                    None,
-                ));
-                let args = self.lower_exprs(args);
-                hir::ExprKind::MethodCall(hir_seg, seg.ident.span, args)
-            }
-            ExprKind::Binary(binop, ref lhs, ref rhs) => {
-                let binop = self.lower_binop(binop);
-                let lhs = P(self.lower_expr(lhs));
-                let rhs = P(self.lower_expr(rhs));
-                hir::ExprKind::Binary(binop, lhs, rhs)
-            }
-            ExprKind::Unary(op, ref ohs) => {
-                let op = self.lower_unop(op);
-                let ohs = P(self.lower_expr(ohs));
-                hir::ExprKind::Unary(op, ohs)
-            }
-            ExprKind::Lit(ref l) => hir::ExprKind::Lit(respan(l.span, l.node.clone())),
-            ExprKind::Cast(ref expr, ref ty) => {
-                let expr = P(self.lower_expr(expr));
-                hir::ExprKind::Cast(expr, self.lower_ty(ty, ImplTraitContext::disallowed()))
-            }
-            ExprKind::Type(ref expr, ref ty) => {
-                let expr = P(self.lower_expr(expr));
-                hir::ExprKind::Type(expr, self.lower_ty(ty, ImplTraitContext::disallowed()))
-            }
-            ExprKind::AddrOf(m, ref ohs) => {
-                let m = self.lower_mutability(m);
-                let ohs = P(self.lower_expr(ohs));
-                hir::ExprKind::AddrOf(m, ohs)
-            }
-            ExprKind::Let(ref pats, ref scrutinee) => {
-                // If we got here, the `let` expression is not allowed.
-                self.sess
-                    .struct_span_err(e.span, "`let` expressions are not supported here")
-                    .note("only supported directly in conditions of `if`- and `while`-expressions")
-                    .note("as well as when nested within `&&` and parenthesis in those conditions")
-                    .emit();
-
-                // For better recovery, we emit:
-                // ```
-                // match scrutinee { pats => true, _ => false }
-                // ```
-                // While this doesn't fully match the user's intent, it has key advantages:
-                // 1. We can avoid using `abort_if_errors`.
-                // 2. We can typeck both `pats` and `scrutinee`.
-                // 3. `pats` is allowed to be refutable.
-                // 4. The return type of the block is `bool` which seems like what the user wanted.
-                let scrutinee = self.lower_expr(scrutinee);
-                let then_arm = {
-                    let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
-                    let expr = self.expr_bool(e.span, true);
-                    self.arm(pats, P(expr))
-                };
-                let else_arm = {
-                    let pats = hir_vec![self.pat_wild(e.span)];
-                    let expr = self.expr_bool(e.span, false);
-                    self.arm(pats, P(expr))
-                };
-                hir::ExprKind::Match(
-                    P(scrutinee),
-                    vec![then_arm, else_arm].into(),
-                    hir::MatchSource::Normal,
-                )
-            }
-            // FIXME(#53667): handle lowering of && and parens.
-            ExprKind::If(ref cond, ref then, ref else_opt) => {
-                // `_ => else_block` where `else_block` is `{}` if there's `None`:
-                let else_pat = self.pat_wild(e.span);
-                let (else_expr, contains_else_clause) = match else_opt {
-                    None => (self.expr_block_empty(e.span), false),
-                    Some(els) => (self.lower_expr(els), true),
-                };
-                let else_arm = self.arm(hir_vec![else_pat], P(else_expr));
-
-                // Handle then + scrutinee:
-                let then_blk = self.lower_block(then, false);
-                let then_expr = self.expr_block(then_blk, ThinVec::new());
-                let (then_pats, scrutinee, desugar) = match cond.node {
-                    // `<pat> => <then>`:
-                    ExprKind::Let(ref pats, ref scrutinee) => {
-                        let scrutinee = self.lower_expr(scrutinee);
-                        let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
-                        let desugar = hir::MatchSource::IfLetDesugar { contains_else_clause };
-                        (pats, scrutinee, desugar)
-                    }
-                    // `true => <then>`:
-                    _ => {
-                        // Lower condition:
-                        let cond = self.lower_expr(cond);
-                        let span_block = self.mark_span_with_reason(
-                            DesugaringKind::CondTemporary, cond.span, None
-                        );
-                        // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
-                        // to preserve drop semantics since `if cond { ... }` does not
-                        // let temporaries live outside of `cond`.
-                        let cond = self.expr_drop_temps(span_block, P(cond), ThinVec::new());
-
-                        let desugar = hir::MatchSource::IfDesugar { contains_else_clause };
-                        let pats = hir_vec![self.pat_bool(e.span, true)];
-                        (pats, cond, desugar)
-                    }
-                };
-                let then_arm = self.arm(then_pats, P(then_expr));
-
-                hir::ExprKind::Match(P(scrutinee), vec![then_arm, else_arm].into(), desugar)
-            }
-            // FIXME(#53667): handle lowering of && and parens.
-            ExprKind::While(ref cond, ref body, opt_label) => self.with_loop_scope(e.id, |this| {
-                // Note that the block AND the condition are evaluated in the loop scope.
-                // This is done to allow `break` from inside the condition of the loop.
-
-                // `_ => break`:
-                let else_arm = {
-                    let else_pat = this.pat_wild(e.span);
-                    let else_expr = this.expr_break(e.span, ThinVec::new());
-                    this.arm(hir_vec![else_pat], else_expr)
-                };
-
-                // Handle then + scrutinee:
-                let then_blk = this.lower_block(body, false);
-                let then_expr = this.expr_block(then_blk, ThinVec::new());
-                let (then_pats, scrutinee, desugar, source) = match cond.node {
-                    ExprKind::Let(ref pats, ref scrutinee) => {
-                        // to:
-                        //
-                        //   [opt_ident]: loop {
-                        //     match <sub_expr> {
-                        //       <pat> => <body>,
-                        //       _ => break
-                        //     }
-                        //   }
-                        let scrutinee = this.with_loop_condition_scope(|t| t.lower_expr(scrutinee));
-                        let pats = pats.iter().map(|pat| this.lower_pat(pat)).collect();
-                        let desugar = hir::MatchSource::WhileLetDesugar;
-                        (pats, scrutinee, desugar, hir::LoopSource::WhileLet)
-                    }
-                    _ => {
-                        // We desugar: `'label: while $cond $body` into:
-                        //
-                        // ```
-                        // 'label: loop {
-                        //     match DropTemps($cond) {
-                        //         true => $body,
-                        //         _ => break,
-                        //     }
-                        // }
-                        // ```
-
-                        // Lower condition:
-                        let cond = this.with_loop_condition_scope(|this| this.lower_expr(cond));
-                        let span_block = this.mark_span_with_reason(
-                            DesugaringKind::CondTemporary, cond.span, None
-                        );
-                        // 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`.
-                        let cond = this.expr_drop_temps(span_block, P(cond), ThinVec::new());
-
-                        let desugar = hir::MatchSource::WhileDesugar;
-                        // `true => <then>`:
-                        let pats = hir_vec![this.pat_bool(e.span, true)];
-                        (pats, cond, desugar, hir::LoopSource::While)
-                    }
-                };
-                let then_arm = this.arm(then_pats, P(then_expr));
-
-                // `match <scrutinee> { ... }`
-                let match_expr = this.expr_match(
-                    scrutinee.span,
-                    P(scrutinee),
-                    hir_vec![then_arm, else_arm],
-                    desugar,
-                );
-
-                // `[opt_ident]: loop { ... }`
-                hir::ExprKind::Loop(
-                    P(this.block_expr(P(match_expr))),
-                    this.lower_label(opt_label),
-                    source
-                )
-            }),
-            ExprKind::Loop(ref body, opt_label) => self.with_loop_scope(e.id, |this| {
-                hir::ExprKind::Loop(
-                    this.lower_block(body, false),
-                    this.lower_label(opt_label),
-                    hir::LoopSource::Loop,
-                )
-            }),
-            ExprKind::TryBlock(ref body) => {
-                self.with_catch_scope(body.id, |this| {
-                    let unstable_span = this.mark_span_with_reason(
-                        DesugaringKind::TryBlock,
-                        body.span,
-                        this.allow_try_trait.clone(),
-                    );
-                    let mut block = this.lower_block(body, true).into_inner();
-                    let tail = block.expr.take().map_or_else(
-                        || {
-                            let span = this.sess.source_map().end_point(unstable_span);
-                            hir::Expr {
-                                span,
-                                node: hir::ExprKind::Tup(hir_vec![]),
-                                attrs: ThinVec::new(),
-                                hir_id: this.next_id(),
-                            }
-                        },
-                        |x: P<hir::Expr>| x.into_inner(),
-                    );
-                    block.expr = Some(this.wrap_in_try_constructor(
-                        sym::from_ok, tail, unstable_span));
-                    hir::ExprKind::Block(P(block), None)
-                })
-            }
-            ExprKind::Match(ref expr, ref arms) => hir::ExprKind::Match(
-                P(self.lower_expr(expr)),
-                arms.iter().map(|x| self.lower_arm(x)).collect(),
-                hir::MatchSource::Normal,
-            ),
-            ExprKind::Async(capture_clause, closure_node_id, ref block) => {
-                self.make_async_expr(capture_clause, closure_node_id, None, block.span, |this| {
-                    this.with_new_scopes(|this| {
-                        let block = this.lower_block(block, false);
-                        this.expr_block(block, ThinVec::new())
-                    })
-                })
-            }
-            ExprKind::Await(ref expr) => self.lower_await(e.span, expr),
-            ExprKind::Closure(
-                capture_clause, asyncness, movability, ref decl, ref body, fn_decl_span
-            ) => {
-                if let IsAsync::Async { closure_id, .. } = asyncness {
-                    let outer_decl = FnDecl {
-                        inputs: decl.inputs.clone(),
-                        output: FunctionRetTy::Default(fn_decl_span),
-                        c_variadic: false,
-                    };
-                    // We need to lower the declaration outside the new scope, because we
-                    // have to conserve the state of being inside a loop condition for the
-                    // closure argument types.
-                    let fn_decl = self.lower_fn_decl(&outer_decl, None, false, None);
-
-                    self.with_new_scopes(|this| {
-                        // FIXME(cramertj): allow `async` non-`move` closures with arguments.
-                        if capture_clause == CaptureBy::Ref &&
-                            !decl.inputs.is_empty()
-                        {
-                            struct_span_err!(
-                                this.sess,
-                                fn_decl_span,
-                                E0708,
-                                "`async` non-`move` closures with arguments \
-                                are not currently supported",
-                            )
-                                .help("consider using `let` statements to manually capture \
-                                       variables by reference before entering an \
-                                       `async move` closure")
-                                .emit();
-                        }
-
-                        // Transform `async |x: u8| -> X { ... }` into
-                        // `|x: u8| future_from_generator(|| -> X { ... })`.
-                        let body_id = this.lower_fn_body(&outer_decl, |this| {
-                            let async_ret_ty = if let FunctionRetTy::Ty(ty) = &decl.output {
-                                Some(ty.clone())
-                            } else { None };
-                            let async_body = this.make_async_expr(
-                                capture_clause, closure_id, async_ret_ty, body.span,
-                                |this| {
-                                    this.with_new_scopes(|this| this.lower_expr(body))
-                                });
-                            this.expr(fn_decl_span, async_body, ThinVec::new())
-                        });
-                        hir::ExprKind::Closure(
-                            this.lower_capture_clause(capture_clause),
-                            fn_decl,
-                            body_id,
-                            fn_decl_span,
-                            None,
-                        )
-                    })
-                } else {
-                    // Lower outside new scope to preserve `is_in_loop_condition`.
-                    let fn_decl = self.lower_fn_decl(decl, None, false, None);
-
-                    self.with_new_scopes(|this| {
-                        this.current_item = Some(fn_decl_span);
-                        let mut generator_kind = None;
-                        let body_id = this.lower_fn_body(decl, |this| {
-                            let e = this.lower_expr(body);
-                            generator_kind = this.generator_kind;
-                            e
-                        });
-                        let generator_option = this.generator_movability_for_fn(
-                            &decl,
-                            fn_decl_span,
-                            generator_kind,
-                            movability,
-                        );
-                        hir::ExprKind::Closure(
-                            this.lower_capture_clause(capture_clause),
-                            fn_decl,
-                            body_id,
-                            fn_decl_span,
-                            generator_option,
-                        )
-                    })
-                }
-            }
-            ExprKind::Block(ref blk, opt_label) => {
-                hir::ExprKind::Block(self.lower_block(blk,
-                                                      opt_label.is_some()),
-                                                      self.lower_label(opt_label))
-            }
-            ExprKind::Assign(ref el, ref er) => {
-                hir::ExprKind::Assign(P(self.lower_expr(el)), P(self.lower_expr(er)))
-            }
-            ExprKind::AssignOp(op, ref el, ref er) => hir::ExprKind::AssignOp(
-                self.lower_binop(op),
-                P(self.lower_expr(el)),
-                P(self.lower_expr(er)),
-            ),
-            ExprKind::Field(ref el, ident) => hir::ExprKind::Field(P(self.lower_expr(el)), ident),
-            ExprKind::Index(ref el, ref er) => {
-                hir::ExprKind::Index(P(self.lower_expr(el)), P(self.lower_expr(er)))
-            }
-            // Desugar `<start>..=<end>` into `std::ops::RangeInclusive::new(<start>, <end>)`.
-            ExprKind::Range(Some(ref e1), Some(ref e2), RangeLimits::Closed) => {
-                let id = self.next_id();
-                let e1 = self.lower_expr(e1);
-                let e2 = self.lower_expr(e2);
-                self.expr_call_std_assoc_fn(
-                    id,
-                    e.span,
-                    &[sym::ops, sym::RangeInclusive],
-                    "new",
-                    hir_vec![e1, e2],
-                )
-            }
-            ExprKind::Range(ref e1, ref e2, lims) => {
-                use syntax::ast::RangeLimits::*;
-
-                let path = match (e1, e2, lims) {
-                    (&None, &None, HalfOpen) => sym::RangeFull,
-                    (&Some(..), &None, HalfOpen) => sym::RangeFrom,
-                    (&None, &Some(..), HalfOpen) => sym::RangeTo,
-                    (&Some(..), &Some(..), HalfOpen) => sym::Range,
-                    (&None, &Some(..), Closed) => sym::RangeToInclusive,
-                    (&Some(..), &Some(..), Closed) => unreachable!(),
-                    (_, &None, Closed) => self.diagnostic()
-                        .span_fatal(e.span, "inclusive range with no end")
-                        .raise(),
-                };
-
-                let fields = e1.iter()
-                    .map(|e| ("start", e))
-                    .chain(e2.iter().map(|e| ("end", e)))
-                    .map(|(s, e)| {
-                        let expr = P(self.lower_expr(&e));
-                        let ident = Ident::new(Symbol::intern(s), e.span);
-                        self.field(ident, expr, e.span)
-                    })
-                    .collect::<P<[hir::Field]>>();
-
-                let is_unit = fields.is_empty();
-                let struct_path = [sym::ops, path];
-                let struct_path = self.std_path(e.span, &struct_path, None, is_unit);
-                let struct_path = hir::QPath::Resolved(None, P(struct_path));
-
-                return hir::Expr {
-                    hir_id: self.lower_node_id(e.id),
-                    node: if is_unit {
-                        hir::ExprKind::Path(struct_path)
-                    } else {
-                        hir::ExprKind::Struct(P(struct_path), fields, None)
-                    },
-                    span: e.span,
-                    attrs: e.attrs.clone(),
-                };
-            }
-            ExprKind::Path(ref qself, ref path) => {
-                let qpath = self.lower_qpath(
-                    e.id,
-                    qself,
-                    path,
-                    ParamMode::Optional,
-                    ImplTraitContext::disallowed(),
-                );
-                hir::ExprKind::Path(qpath)
-            }
-            ExprKind::Break(opt_label, ref opt_expr) => {
-                let destination = if self.is_in_loop_condition && opt_label.is_none() {
-                    hir::Destination {
-                        label: None,
-                        target_id: Err(hir::LoopIdError::UnlabeledCfInWhileCondition).into(),
-                    }
-                } else {
-                    self.lower_loop_destination(opt_label.map(|label| (e.id, label)))
-                };
-                hir::ExprKind::Break(
-                    destination,
-                    opt_expr.as_ref().map(|x| P(self.lower_expr(x))),
-                )
-            }
-            ExprKind::Continue(opt_label) => {
-                hir::ExprKind::Continue(if self.is_in_loop_condition && opt_label.is_none() {
-                    hir::Destination {
-                        label: None,
-                        target_id: Err(hir::LoopIdError::UnlabeledCfInWhileCondition).into(),
-                    }
-                } else {
-                    self.lower_loop_destination(opt_label.map(|label| (e.id, label)))
-                })
-            }
-            ExprKind::Ret(ref e) => hir::ExprKind::Ret(e.as_ref().map(|x| P(self.lower_expr(x)))),
-            ExprKind::InlineAsm(ref asm) => {
-                let hir_asm = hir::InlineAsm {
-                    inputs: asm.inputs.iter().map(|&(ref c, _)| c.clone()).collect(),
-                    outputs: asm.outputs
-                        .iter()
-                        .map(|out| hir::InlineAsmOutput {
-                            constraint: out.constraint.clone(),
-                            is_rw: out.is_rw,
-                            is_indirect: out.is_indirect,
-                            span: out.expr.span,
-                        })
-                        .collect(),
-                    asm: asm.asm.clone(),
-                    asm_str_style: asm.asm_str_style,
-                    clobbers: asm.clobbers.clone().into(),
-                    volatile: asm.volatile,
-                    alignstack: asm.alignstack,
-                    dialect: asm.dialect,
-                    ctxt: asm.ctxt,
-                };
-                let outputs = asm.outputs
-                    .iter()
-                    .map(|out| self.lower_expr(&out.expr))
-                    .collect();
-                let inputs = asm.inputs
-                    .iter()
-                    .map(|&(_, ref input)| self.lower_expr(input))
-                    .collect();
-                hir::ExprKind::InlineAsm(P(hir_asm), outputs, inputs)
-            }
-            ExprKind::Struct(ref path, ref fields, ref maybe_expr) => hir::ExprKind::Struct(
-                P(self.lower_qpath(
-                    e.id,
-                    &None,
-                    path,
-                    ParamMode::Optional,
-                    ImplTraitContext::disallowed(),
-                )),
-                fields.iter().map(|x| self.lower_field(x)).collect(),
-                maybe_expr.as_ref().map(|x| P(self.lower_expr(x))),
-            ),
-            ExprKind::Paren(ref ex) => {
-                let mut ex = self.lower_expr(ex);
-                // Include parens in span, but only if it is a super-span.
-                if e.span.contains(ex.span) {
-                    ex.span = e.span;
-                }
-                // Merge attributes into the inner expression.
-                let mut attrs = e.attrs.clone();
-                attrs.extend::<Vec<_>>(ex.attrs.into());
-                ex.attrs = attrs;
-                return ex;
-            }
-
-            ExprKind::Yield(ref opt_expr) => {
-                match self.generator_kind {
-                    Some(hir::GeneratorKind::Gen) => {},
-                    Some(hir::GeneratorKind::Async) => {
-                        span_err!(
-                            self.sess,
-                            e.span,
-                            E0727,
-                            "`async` generators are not yet supported",
-                        );
-                        self.sess.abort_if_errors();
-                    },
-                    None => {
-                        self.generator_kind = Some(hir::GeneratorKind::Gen);
-                    }
-                }
-                let expr = opt_expr
-                    .as_ref()
-                    .map(|x| self.lower_expr(x))
-                    .unwrap_or_else(|| self.expr_unit(e.span));
-                hir::ExprKind::Yield(P(expr), hir::YieldSource::Yield)
-            }
-
-            ExprKind::Err => hir::ExprKind::Err,
-
-            // Desugar `ExprForLoop`
-            // from: `[opt_ident]: for <pat> in <head> <body>`
-            ExprKind::ForLoop(ref pat, ref head, ref body, opt_label) => {
-                // to:
-                //
-                //   {
-                //     let result = match ::std::iter::IntoIterator::into_iter(<head>) {
-                //       mut iter => {
-                //         [opt_ident]: loop {
-                //           let mut __next;
-                //           match ::std::iter::Iterator::next(&mut iter) {
-                //             ::std::option::Option::Some(val) => __next = val,
-                //             ::std::option::Option::None => break
-                //           };
-                //           let <pat> = __next;
-                //           StmtKind::Expr(<body>);
-                //         }
-                //       }
-                //     };
-                //     result
-                //   }
-
-                // expand <head>
-                let mut head = self.lower_expr(head);
-                let head_sp = head.span;
-                let desugared_span = self.mark_span_with_reason(
-                    DesugaringKind::ForLoop,
-                    head_sp,
-                    None,
-                );
-                head.span = desugared_span;
-
-                let iter = Ident::with_empty_ctxt(sym::iter);
-
-                let next_ident = Ident::with_empty_ctxt(sym::__next);
-                let (next_pat, next_pat_hid) = self.pat_ident_binding_mode(
-                    desugared_span,
-                    next_ident,
-                    hir::BindingAnnotation::Mutable,
-                );
-
-                // `::std::option::Option::Some(val) => __next = val`
-                let pat_arm = {
-                    let val_ident = Ident::with_empty_ctxt(sym::val);
-                    let (val_pat, val_pat_hid) = self.pat_ident(pat.span, val_ident);
-                    let val_expr = P(self.expr_ident(pat.span, val_ident, val_pat_hid));
-                    let next_expr = P(self.expr_ident(pat.span, next_ident, next_pat_hid));
-                    let assign = P(self.expr(
-                        pat.span,
-                        hir::ExprKind::Assign(next_expr, val_expr),
-                        ThinVec::new(),
-                    ));
-                    let some_pat = self.pat_some(pat.span, val_pat);
-                    self.arm(hir_vec![some_pat], assign)
-                };
-
-                // `::std::option::Option::None => break`
-                let break_arm = {
-                    let break_expr =
-                        self.with_loop_scope(e.id, |this| this.expr_break(e.span, ThinVec::new()));
-                    let pat = self.pat_none(e.span);
-                    self.arm(hir_vec![pat], break_expr)
-                };
-
-                // `mut iter`
-                let (iter_pat, iter_pat_nid) = self.pat_ident_binding_mode(
-                    desugared_span,
-                    iter,
-                    hir::BindingAnnotation::Mutable
-                );
-
-                // `match ::std::iter::Iterator::next(&mut iter) { ... }`
-                let match_expr = {
-                    let iter = P(self.expr_ident(head_sp, iter, iter_pat_nid));
-                    let ref_mut_iter = self.expr_mut_addr_of(head_sp, iter);
-                    let next_path = &[sym::iter, sym::Iterator, sym::next];
-                    let next_expr = P(self.expr_call_std_path(
-                        head_sp,
-                        next_path,
-                        hir_vec![ref_mut_iter],
-                    ));
-                    let arms = hir_vec![pat_arm, break_arm];
-
-                    self.expr_match(head_sp, next_expr, arms, hir::MatchSource::ForLoopDesugar)
-                };
-                let match_stmt = self.stmt_expr(head_sp, match_expr);
-
-                let next_expr = P(self.expr_ident(head_sp, next_ident, next_pat_hid));
-
-                // `let mut __next`
-                let next_let = self.stmt_let_pat(
-                    ThinVec::new(),
-                    desugared_span,
-                    None,
-                    next_pat,
-                    hir::LocalSource::ForLoopDesugar,
-                );
-
-                // `let <pat> = __next`
-                let pat = self.lower_pat(pat);
-                let pat_let = self.stmt_let_pat(
-                    ThinVec::new(),
-                    head_sp,
-                    Some(next_expr),
-                    pat,
-                    hir::LocalSource::ForLoopDesugar,
-                );
-
-                let body_block = self.with_loop_scope(e.id, |this| this.lower_block(body, false));
-                let body_expr = self.expr_block(body_block, ThinVec::new());
-                let body_stmt = self.stmt_expr(body.span, body_expr);
-
-                let loop_block = P(self.block_all(
-                    e.span,
-                    hir_vec![next_let, match_stmt, pat_let, body_stmt],
-                    None,
-                ));
+                after.push(self.lower_pat(pat));
+            }
+        }
 
-                // `[opt_ident]: loop { ... }`
-                let loop_expr = hir::ExprKind::Loop(
-                    loop_block,
-                    self.lower_label(opt_label),
-                    hir::LoopSource::ForLoop,
-                );
-                let loop_expr = P(hir::Expr {
-                    hir_id: self.lower_node_id(e.id),
-                    node: loop_expr,
-                    span: e.span,
-                    attrs: ThinVec::new(),
-                });
+        hir::PatKind::Slice(before.into(), slice, after.into())
+    }
 
-                // `mut iter => { ... }`
-                let iter_arm = self.arm(hir_vec![iter_pat], loop_expr);
-
-                // `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
-                let into_iter_expr = {
-                    let into_iter_path =
-                        &[sym::iter, sym::IntoIterator, sym::into_iter];
-                    P(self.expr_call_std_path(
-                        head_sp,
-                        into_iter_path,
-                        hir_vec![head],
-                    ))
+    fn lower_pat_ident(
+        &mut self,
+        p: &Pat,
+        binding_mode: &BindingMode,
+        ident: Ident,
+        lower_sub: impl FnOnce(&mut Self) -> Option<P<hir::Pat>>,
+    ) -> hir::PatKind {
+        match self.resolver.get_partial_res(p.id).map(|d| d.base_res()) {
+            // `None` can occur in body-less function signatures
+            res @ None | res @ Some(Res::Local(_)) => {
+                let canonical_id = match res {
+                    Some(Res::Local(id)) => id,
+                    _ => p.id,
                 };
 
-                let match_expr = P(self.expr_match(
-                    head_sp,
-                    into_iter_expr,
-                    hir_vec![iter_arm],
-                    hir::MatchSource::ForLoopDesugar,
-                ));
-
-                // This is effectively `{ let _result = ...; _result }`.
-                // The construct was introduced in #21984 and is necessary to make sure that
-                // temporaries in the `head` expression are dropped and do not leak to the
-                // surrounding scope of the `match` since the `match` is not a terminating scope.
-                //
-                // Also, add the attributes to the outer returned expr node.
-                return self.expr_drop_temps(head_sp, match_expr, e.attrs.clone())
+                hir::PatKind::Binding(
+                    self.lower_binding_mode(binding_mode),
+                    self.lower_node_id(canonical_id),
+                    ident,
+                    lower_sub(self),
+                )
             }
+            Some(res) => hir::PatKind::Path(hir::QPath::Resolved(
+                None,
+                P(hir::Path {
+                    span: ident.span,
+                    res: self.lower_res(res),
+                    segments: hir_vec![hir::PathSegment::from_ident(ident)],
+                }),
+            )),
+        }
+    }
 
-            // Desugar `ExprKind::Try`
-            // from: `<expr>?`
-            ExprKind::Try(ref sub_expr) => {
-                // into:
-                //
-                // match Try::into_result(<expr>) {
-                //     Ok(val) => #[allow(unreachable_code)] val,
-                //     Err(err) => #[allow(unreachable_code)]
-                //                 // If there is an enclosing `catch {...}`
-                //                 break 'catch_target Try::from_error(From::from(err)),
-                //                 // Otherwise
-                //                 return Try::from_error(From::from(err)),
-                // }
-
-                let unstable_span = self.mark_span_with_reason(
-                    DesugaringKind::QuestionMark,
-                    e.span,
-                    self.allow_try_trait.clone(),
-                );
-                let try_span = self.sess.source_map().end_point(e.span);
-                let try_span = self.mark_span_with_reason(
-                    DesugaringKind::QuestionMark,
-                    try_span,
-                    self.allow_try_trait.clone(),
-                );
-
-                // `Try::into_result(<expr>)`
-                let discr = {
-                    // expand <expr>
-                    let sub_expr = self.lower_expr(sub_expr);
-
-                    let path = &[sym::ops, sym::Try, sym::into_result];
-                    P(self.expr_call_std_path(
-                        unstable_span,
-                        path,
-                        hir_vec![sub_expr],
-                    ))
-                };
-
-                // `#[allow(unreachable_code)]`
-                let attr = {
-                    // `allow(unreachable_code)`
-                    let allow = {
-                        let allow_ident = Ident::new(sym::allow, e.span);
-                        let uc_ident = Ident::new(sym::unreachable_code, e.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];
-
-                // `Ok(val) => #[allow(unreachable_code)] val,`
-                let ok_arm = {
-                    let val_ident = Ident::with_empty_ctxt(sym::val);
-                    let (val_pat, val_pat_nid) = self.pat_ident(e.span, val_ident);
-                    let val_expr = P(self.expr_ident_with_attrs(
-                        e.span,
-                        val_ident,
-                        val_pat_nid,
-                        ThinVec::from(attrs.clone()),
-                    ));
-                    let ok_pat = self.pat_ok(e.span, val_pat);
-
-                    self.arm(hir_vec![ok_pat], val_expr)
-                };
+    fn pat_wild_with_node_id_of(&mut self, p: &Pat) -> P<hir::Pat> {
+        self.pat_with_node_id_of(p, hir::PatKind::Wild)
+    }
 
-                // `Err(err) => #[allow(unreachable_code)]
-                //              return Try::from_error(From::from(err)),`
-                let err_arm = {
-                    let err_ident = Ident::with_empty_ctxt(sym::err);
-                    let (err_local, err_local_nid) = self.pat_ident(try_span, err_ident);
-                    let from_expr = {
-                        let from_path = &[sym::convert, sym::From, sym::from];
-                        let err_expr = self.expr_ident(try_span, err_ident, err_local_nid);
-                        self.expr_call_std_path(try_span, from_path, hir_vec![err_expr])
-                    };
-                    let from_err_expr =
-                        self.wrap_in_try_constructor(sym::from_error, from_expr, unstable_span);
-                    let thin_attrs = ThinVec::from(attrs);
-                    let catch_scope = self.catch_scopes.last().map(|x| *x);
-                    let ret_expr = if let Some(catch_node) = catch_scope {
-                        let target_id = Ok(self.lower_node_id(catch_node));
-                        P(self.expr(
-                            try_span,
-                            hir::ExprKind::Break(
-                                hir::Destination {
-                                    label: None,
-                                    target_id,
-                                },
-                                Some(from_err_expr),
-                            ),
-                            thin_attrs,
-                        ))
-                    } else {
-                        P(self.expr(try_span, hir::ExprKind::Ret(Some(from_err_expr)), thin_attrs))
-                    };
+    /// Construct a `Pat` with the `HirId` of `p.id` lowered.
+    fn pat_with_node_id_of(&mut self, p: &Pat, node: hir::PatKind) -> P<hir::Pat> {
+        P(hir::Pat {
+            hir_id: self.lower_node_id(p.id),
+            node,
+            span: p.span,
+        })
+    }
 
-                    let err_pat = self.pat_err(try_span, err_local);
-                    self.arm(hir_vec![err_pat], ret_expr)
-                };
+    /// Emit a friendly error for extra `..` patterns in a tuple/tuple struct/slice pattern.
+    fn ban_extra_rest_pat(&self, sp: Span, prev_sp: Span, ctx: &str) {
+        self.diagnostic()
+            .struct_span_err(sp, &format!("`..` can only be used once per {} pattern", ctx))
+            .span_label(sp, &format!("can only be used once per {} pattern", ctx))
+            .span_label(prev_sp, "previously used here")
+            .emit();
+    }
 
-                hir::ExprKind::Match(
-                    discr,
-                    hir_vec![err_arm, ok_arm],
-                    hir::MatchSource::TryDesugar,
-                )
-            }
+    /// Used to ban the `..` pattern in places it shouldn't be semantically.
+    fn ban_illegal_rest_pat(&self, sp: Span) -> hir::PatKind {
+        self.diagnostic()
+            .struct_span_err(sp, "`..` patterns are not allowed here")
+            .note("only allowed in tuple, tuple struct, and slice patterns")
+            .emit();
 
-            ExprKind::Mac(_) => panic!("Shouldn't exist here"),
-        };
+        // We're not in a list context so `..` can be reasonably treated
+        // as `_` because it should always be valid and roughly matches the
+        // intent of `..` (notice that the rest of a single slot is that slot).
+        hir::PatKind::Wild
+    }
 
-        hir::Expr {
-            hir_id: self.lower_node_id(e.id),
-            node: kind,
-            span: e.span,
-            attrs: e.attrs.clone(),
+    fn lower_range_end(&mut self, e: &RangeEnd) -> hir::RangeEnd {
+        match *e {
+            RangeEnd::Included(_) => hir::RangeEnd::Included,
+            RangeEnd::Excluded => hir::RangeEnd::Excluded,
         }
     }
 
+    fn lower_anon_const(&mut self, c: &AnonConst) -> hir::AnonConst {
+        self.with_new_scopes(|this| {
+            hir::AnonConst {
+                hir_id: this.lower_node_id(c.id),
+                body: this.lower_const_body(&c.value),
+            }
+        })
+    }
+
     fn lower_stmt(&mut self, s: &Stmt) -> SmallVec<[hir::Stmt; 1]> {
         let node = match s.node {
             StmtKind::Local(ref l) => {
@@ -5289,62 +2938,6 @@ impl<'a> LoweringContext<'a> {
         }]
     }
 
-    fn lower_capture_clause(&mut self, c: CaptureBy) -> hir::CaptureClause {
-        match c {
-            CaptureBy::Value => hir::CaptureByValue,
-            CaptureBy::Ref => hir::CaptureByRef,
-        }
-    }
-
-    /// If an `explicit_owner` is given, this method allocates the `HirId` in
-    /// the address space of that item instead of the item currently being
-    /// lowered. This can happen during `lower_impl_item_ref()` where we need to
-    /// lower a `Visibility` value although we haven't lowered the owning
-    /// `ImplItem` in question yet.
-    fn lower_visibility(
-        &mut self,
-        v: &Visibility,
-        explicit_owner: Option<NodeId>,
-    ) -> hir::Visibility {
-        let node = match v.node {
-            VisibilityKind::Public => hir::VisibilityKind::Public,
-            VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
-            VisibilityKind::Restricted { ref path, id } => {
-                debug!("lower_visibility: restricted path id = {:?}", id);
-                let lowered_id = if let Some(owner) = explicit_owner {
-                    self.lower_node_id_with_owner(id, owner)
-                } else {
-                    self.lower_node_id(id)
-                };
-                let res = self.expect_full_res(id);
-                let res = self.lower_res(res);
-                hir::VisibilityKind::Restricted {
-                    path: P(self.lower_path_extra(
-                        res,
-                        path,
-                        ParamMode::Explicit,
-                        explicit_owner,
-                    )),
-                    hir_id: lowered_id,
-                }
-            },
-            VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
-        };
-        respan(v.span, node)
-    }
-
-    fn lower_defaultness(&self, d: Defaultness, has_value: bool) -> hir::Defaultness {
-        match d {
-            Defaultness::Default => hir::Defaultness::Default {
-                has_value: has_value,
-            },
-            Defaultness::Final => {
-                assert!(has_value);
-                hir::Defaultness::Final
-            }
-        }
-    }
-
     fn lower_block_check_mode(&mut self, b: &BlockCheckMode) -> hir::BlockCheckMode {
         match *b {
             BlockCheckMode::Default => hir::DefaultBlock,
@@ -5368,13 +2961,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_impl_polarity(&mut self, i: ImplPolarity) -> hir::ImplPolarity {
-        match i {
-            ImplPolarity::Positive => hir::ImplPolarity::Positive,
-            ImplPolarity::Negative => hir::ImplPolarity::Negative,
-        }
-    }
-
     fn lower_trait_bound_modifier(&mut self, f: TraitBoundModifier) -> hir::TraitBoundModifier {
         match f {
             TraitBoundModifier::None => hir::TraitBoundModifier::None,
@@ -5384,165 +2970,6 @@ impl<'a> LoweringContext<'a> {
 
     // Helper methods for building HIR.
 
-    fn arm(&mut self, pats: hir::HirVec<P<hir::Pat>>, expr: P<hir::Expr>) -> hir::Arm {
-        hir::Arm {
-            hir_id: self.next_id(),
-            attrs: hir_vec![],
-            pats,
-            guard: None,
-            span: expr.span,
-            body: expr,
-        }
-    }
-
-    fn field(&mut self, ident: Ident, expr: P<hir::Expr>, span: Span) -> hir::Field {
-        hir::Field {
-            hir_id: self.next_id(),
-            ident,
-            span,
-            expr,
-            is_shorthand: false,
-        }
-    }
-
-    fn expr_break(&mut self, span: Span, attrs: ThinVec<Attribute>) -> P<hir::Expr> {
-        let expr_break = hir::ExprKind::Break(self.lower_loop_destination(None), None);
-        P(self.expr(span, expr_break, attrs))
-    }
-
-    fn expr_call(
-        &mut self,
-        span: Span,
-        e: P<hir::Expr>,
-        args: hir::HirVec<hir::Expr>,
-    ) -> hir::Expr {
-        self.expr(span, hir::ExprKind::Call(e, args), ThinVec::new())
-    }
-
-    // Note: associated functions must use `expr_call_std_path`.
-    fn expr_call_std_path(
-        &mut self,
-        span: Span,
-        path_components: &[Symbol],
-        args: hir::HirVec<hir::Expr>,
-    ) -> hir::Expr {
-        let path = P(self.expr_std_path(span, path_components, None, ThinVec::new()));
-        self.expr_call(span, path, args)
-    }
-
-    // Create an expression calling an associated function of an std type.
-    //
-    // Associated functions cannot be resolved through the normal `std_path` function,
-    // as they are resolved differently and so cannot use `expr_call_std_path`.
-    //
-    // This function accepts the path component (`ty_path_components`) separately from
-    // the name of the associated function (`assoc_fn_name`) in order to facilitate
-    // separate resolution of the type and creation of a path referring to its associated
-    // function.
-    fn expr_call_std_assoc_fn(
-        &mut self,
-        ty_path_id: hir::HirId,
-        span: Span,
-        ty_path_components: &[Symbol],
-        assoc_fn_name: &str,
-        args: hir::HirVec<hir::Expr>,
-    ) -> hir::ExprKind {
-        let ty_path = P(self.std_path(span, ty_path_components, None, false));
-        let ty = P(self.ty_path(ty_path_id, span, hir::QPath::Resolved(None, ty_path)));
-        let fn_seg = P(hir::PathSegment::from_ident(Ident::from_str(assoc_fn_name)));
-        let fn_path = hir::QPath::TypeRelative(ty, fn_seg);
-        let fn_expr = P(self.expr(span, hir::ExprKind::Path(fn_path), ThinVec::new()));
-        hir::ExprKind::Call(fn_expr, args)
-    }
-
-    fn expr_ident(&mut self, span: Span, ident: Ident, binding: hir::HirId) -> hir::Expr {
-        self.expr_ident_with_attrs(span, ident, binding, ThinVec::new())
-    }
-
-    fn expr_ident_with_attrs(
-        &mut self,
-        span: Span,
-        ident: Ident,
-        binding: hir::HirId,
-        attrs: ThinVec<Attribute>,
-    ) -> hir::Expr {
-        let expr_path = hir::ExprKind::Path(hir::QPath::Resolved(
-            None,
-            P(hir::Path {
-                span,
-                res: Res::Local(binding),
-                segments: hir_vec![hir::PathSegment::from_ident(ident)],
-            }),
-        ));
-
-        self.expr(span, expr_path, attrs)
-    }
-
-    fn expr_mut_addr_of(&mut self, span: Span, e: P<hir::Expr>) -> hir::Expr {
-        self.expr(span, hir::ExprKind::AddrOf(hir::MutMutable, e), ThinVec::new())
-    }
-
-    fn expr_std_path(
-        &mut self,
-        span: Span,
-        components: &[Symbol],
-        params: Option<P<hir::GenericArgs>>,
-        attrs: ThinVec<Attribute>,
-    ) -> hir::Expr {
-        let path = self.std_path(span, components, params, true);
-        self.expr(
-            span,
-            hir::ExprKind::Path(hir::QPath::Resolved(None, P(path))),
-            attrs,
-        )
-    }
-
-    /// 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 { .. }`.
-    fn expr_drop_temps(
-        &mut self,
-        span: Span,
-        expr: P<hir::Expr>,
-        attrs: ThinVec<Attribute>
-    ) -> hir::Expr {
-        self.expr(span, hir::ExprKind::DropTemps(expr), attrs)
-    }
-
-    fn expr_match(
-        &mut self,
-        span: Span,
-        arg: P<hir::Expr>,
-        arms: hir::HirVec<hir::Arm>,
-        source: hir::MatchSource,
-    ) -> hir::Expr {
-        self.expr(span, hir::ExprKind::Match(arg, arms, source), ThinVec::new())
-    }
-
-    fn expr_block(&mut self, b: P<hir::Block>, attrs: ThinVec<Attribute>) -> hir::Expr {
-        self.expr(b.span, hir::ExprKind::Block(b, None), attrs)
-    }
-
-    fn expr_unit(&mut self, sp: Span) -> hir::Expr {
-        self.expr_tuple(sp, hir_vec![])
-    }
-
-    fn expr_tuple(&mut self, sp: Span, exprs: hir::HirVec<hir::Expr>) -> hir::Expr {
-        self.expr(sp, hir::ExprKind::Tup(exprs), ThinVec::new())
-    }
-
-    fn expr(&mut self, span: Span, node: hir::ExprKind, attrs: ThinVec<Attribute>) -> hir::Expr {
-        hir::Expr {
-            hir_id: self.next_id(),
-            node,
-            span,
-            attrs,
-        }
-    }
-
     fn stmt(&mut self, span: Span, node: hir::StmtKind) -> hir::Stmt {
         hir::Stmt { span, node, hir_id: self.next_id() }
     }
@@ -5571,11 +2998,6 @@ impl<'a> LoweringContext<'a> {
         self.stmt(span, hir::StmtKind::Local(P(local)))
     }
 
-    fn expr_block_empty(&mut self, span: Span) -> hir::Expr {
-        let blk = self.block_all(span, hir_vec![], None);
-        self.expr_block(P(blk), ThinVec::new())
-    }
-
     fn block_expr(&mut self, expr: P<hir::Expr>) -> hir::Block {
         self.block_all(expr.span, hir::HirVec::new(), Some(expr))
     }
@@ -5596,29 +3018,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn expr_unsafe(&mut self, expr: P<hir::Expr>) -> hir::Expr {
-        let hir_id = self.next_id();
-        let span = expr.span;
-        self.expr(
-            span,
-            hir::ExprKind::Block(P(hir::Block {
-                stmts: hir_vec![],
-                expr: Some(expr),
-                hir_id,
-                rules: hir::UnsafeBlock(hir::CompilerGenerated),
-                span,
-                targeted_by_break: false,
-            }), None),
-            ThinVec::new(),
-        )
-    }
-
-    /// Constructs a `true` or `false` literal expression.
-    fn expr_bool(&mut self, span: Span, val: bool) -> hir::Expr {
-        let lit = Spanned { span, node: LitKind::Bool(val) };
-        self.expr(span, hir::ExprKind::Lit(lit), ThinVec::new())
-    }
-
     /// Constructs a `true` or `false` literal pattern.
     fn pat_bool(&mut self, span: Span, val: bool) -> P<hir::Pat> {
         let expr = self.expr_bool(span, val);
@@ -5911,180 +3310,6 @@ impl<'a> LoweringContext<'a> {
             )
         }
     }
-
-    fn wrap_in_try_constructor(
-        &mut self,
-        method: Symbol,
-        e: hir::Expr,
-        unstable_span: Span,
-    ) -> P<hir::Expr> {
-        let path = &[sym::ops, sym::Try, method];
-        let from_err = P(self.expr_std_path(unstable_span, path, None,
-                                            ThinVec::new()));
-        P(self.expr_call(e.span, from_err, hir_vec![e]))
-    }
-
-    fn lower_await(
-        &mut self,
-        await_span: Span,
-        expr: &ast::Expr,
-    ) -> hir::ExprKind {
-        // to:
-        //
-        // {
-        //     let mut pinned = <expr>;
-        //     loop {
-        //         match ::std::future::poll_with_tls_context(unsafe {
-        //             ::std::pin::Pin::new_unchecked(&mut pinned)
-        //         }) {
-        //             ::std::task::Poll::Ready(result) => break result,
-        //             ::std::task::Poll::Pending => {},
-        //         }
-        //         yield ();
-        //     }
-        // }
-        match self.generator_kind {
-            Some(hir::GeneratorKind::Async) => {},
-            Some(hir::GeneratorKind::Gen) |
-            None => {
-                let mut err = struct_span_err!(
-                    self.sess,
-                    await_span,
-                    E0728,
-                    "`await` is only allowed inside `async` functions and blocks"
-                );
-                err.span_label(await_span, "only allowed inside `async` functions and blocks");
-                if let Some(item_sp) = self.current_item {
-                    err.span_label(item_sp, "this is not `async`");
-                }
-                err.emit();
-            }
-        }
-        let span = self.mark_span_with_reason(
-            DesugaringKind::Await,
-            await_span,
-            None,
-        );
-        let gen_future_span = self.mark_span_with_reason(
-            DesugaringKind::Await,
-            await_span,
-            self.allow_gen_future.clone(),
-        );
-
-        // let mut pinned = <expr>;
-        let expr = P(self.lower_expr(expr));
-        let pinned_ident = Ident::with_empty_ctxt(sym::pinned);
-        let (pinned_pat, pinned_pat_hid) = self.pat_ident_binding_mode(
-            span,
-            pinned_ident,
-            hir::BindingAnnotation::Mutable,
-        );
-        let pinned_let = self.stmt_let_pat(
-            ThinVec::new(),
-            span,
-            Some(expr),
-            pinned_pat,
-            hir::LocalSource::AwaitDesugar,
-        );
-
-        // ::std::future::poll_with_tls_context(unsafe {
-        //     ::std::pin::Pin::new_unchecked(&mut pinned)
-        // })`
-        let poll_expr = {
-            let pinned = P(self.expr_ident(span, pinned_ident, pinned_pat_hid));
-            let ref_mut_pinned = self.expr_mut_addr_of(span, pinned);
-            let pin_ty_id = self.next_id();
-            let new_unchecked_expr_kind = self.expr_call_std_assoc_fn(
-                pin_ty_id,
-                span,
-                &[sym::pin, sym::Pin],
-                "new_unchecked",
-                hir_vec![ref_mut_pinned],
-            );
-            let new_unchecked = P(self.expr(span, new_unchecked_expr_kind, ThinVec::new()));
-            let unsafe_expr = self.expr_unsafe(new_unchecked);
-            P(self.expr_call_std_path(
-                gen_future_span,
-                &[sym::future, sym::poll_with_tls_context],
-                hir_vec![unsafe_expr],
-            ))
-        };
-
-        // `::std::task::Poll::Ready(result) => break result`
-        let loop_node_id = self.sess.next_node_id();
-        let loop_hir_id = self.lower_node_id(loop_node_id);
-        let ready_arm = {
-            let x_ident = Ident::with_empty_ctxt(sym::result);
-            let (x_pat, x_pat_hid) = self.pat_ident(span, x_ident);
-            let x_expr = P(self.expr_ident(span, x_ident, x_pat_hid));
-            let ready_pat = self.pat_std_enum(
-                span,
-                &[sym::task, sym::Poll, sym::Ready],
-                hir_vec![x_pat],
-            );
-            let break_x = self.with_loop_scope(loop_node_id, |this| {
-                let expr_break = hir::ExprKind::Break(
-                    this.lower_loop_destination(None),
-                    Some(x_expr),
-                );
-                P(this.expr(await_span, expr_break, ThinVec::new()))
-            });
-            self.arm(hir_vec![ready_pat], break_x)
-        };
-
-        // `::std::task::Poll::Pending => {}`
-        let pending_arm = {
-            let pending_pat = self.pat_std_enum(
-                span,
-                &[sym::task, sym::Poll, sym::Pending],
-                hir_vec![],
-            );
-            let empty_block = P(self.expr_block_empty(span));
-            self.arm(hir_vec![pending_pat], empty_block)
-        };
-
-        let match_stmt = {
-            let match_expr = self.expr_match(
-                span,
-                poll_expr,
-                hir_vec![ready_arm, pending_arm],
-                hir::MatchSource::AwaitDesugar,
-            );
-            self.stmt_expr(span, match_expr)
-        };
-
-        let yield_stmt = {
-            let unit = self.expr_unit(span);
-            let yield_expr = self.expr(
-                span,
-                hir::ExprKind::Yield(P(unit), hir::YieldSource::Await),
-                ThinVec::new(),
-            );
-            self.stmt_expr(span, yield_expr)
-        };
-
-        let loop_block = P(self.block_all(
-            span,
-            hir_vec![match_stmt, yield_stmt],
-            None,
-        ));
-
-        let loop_expr = P(hir::Expr {
-            hir_id: loop_hir_id,
-            node: hir::ExprKind::Loop(
-                loop_block,
-                None,
-                hir::LoopSource::Loop,
-            ),
-            span,
-            attrs: ThinVec::new(),
-        });
-
-        hir::ExprKind::Block(
-            P(self.block_all(span, hir_vec![pinned_let], Some(loop_expr))),
-            None,
-        )
-    }
 }
 
 fn body_ids(bodies: &BTreeMap<hir::BodyId, hir::Body>) -> Vec<hir::BodyId> {
diff --git a/src/librustc/hir/lowering/expr.rs b/src/librustc/hir/lowering/expr.rs
new file mode 100644
index 0000000000000..d273006fbe07e
--- /dev/null
+++ b/src/librustc/hir/lowering/expr.rs
@@ -0,0 +1,1497 @@
+use super::{LoweringContext, ParamMode, ParenthesizedGenericArgs, ImplTraitContext};
+use crate::hir::{self, HirVec};
+use crate::hir::def::Res;
+use crate::hir::ptr::P;
+
+use rustc_data_structures::thin_vec::ThinVec;
+
+use syntax::attr;
+use syntax::ptr::P as AstP;
+use syntax::ast::*;
+use syntax::source_map::{respan, DesugaringKind, Span, Spanned};
+use syntax::symbol::{sym, Symbol};
+
+impl LoweringContext<'_> {
+    fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> HirVec<hir::Expr> {
+        exprs.iter().map(|x| self.lower_expr(x)).collect()
+    }
+
+    pub(super) fn lower_expr(&mut self, e: &Expr) -> hir::Expr {
+        let kind = match e.node {
+            ExprKind::Box(ref inner) => hir::ExprKind::Box(P(self.lower_expr(inner))),
+            ExprKind::Array(ref exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
+            ExprKind::Repeat(ref expr, ref count) => {
+                let expr = P(self.lower_expr(expr));
+                let count = self.lower_anon_const(count);
+                hir::ExprKind::Repeat(expr, count)
+            }
+            ExprKind::Tup(ref elts) => hir::ExprKind::Tup(self.lower_exprs(elts)),
+            ExprKind::Call(ref f, ref args) => {
+                let f = P(self.lower_expr(f));
+                hir::ExprKind::Call(f, self.lower_exprs(args))
+            }
+            ExprKind::MethodCall(ref seg, ref args) => {
+                let hir_seg = P(self.lower_path_segment(
+                    e.span,
+                    seg,
+                    ParamMode::Optional,
+                    0,
+                    ParenthesizedGenericArgs::Err,
+                    ImplTraitContext::disallowed(),
+                    None,
+                ));
+                let args = self.lower_exprs(args);
+                hir::ExprKind::MethodCall(hir_seg, seg.ident.span, args)
+            }
+            ExprKind::Binary(binop, ref lhs, ref rhs) => {
+                let binop = self.lower_binop(binop);
+                let lhs = P(self.lower_expr(lhs));
+                let rhs = P(self.lower_expr(rhs));
+                hir::ExprKind::Binary(binop, lhs, rhs)
+            }
+            ExprKind::Unary(op, ref ohs) => {
+                let op = self.lower_unop(op);
+                let ohs = P(self.lower_expr(ohs));
+                hir::ExprKind::Unary(op, ohs)
+            }
+            ExprKind::Lit(ref l) => hir::ExprKind::Lit(respan(l.span, l.node.clone())),
+            ExprKind::Cast(ref expr, ref ty) => {
+                let expr = P(self.lower_expr(expr));
+                hir::ExprKind::Cast(expr, self.lower_ty(ty, ImplTraitContext::disallowed()))
+            }
+            ExprKind::Type(ref expr, ref ty) => {
+                let expr = P(self.lower_expr(expr));
+                hir::ExprKind::Type(expr, self.lower_ty(ty, ImplTraitContext::disallowed()))
+            }
+            ExprKind::AddrOf(m, ref ohs) => {
+                let m = self.lower_mutability(m);
+                let ohs = P(self.lower_expr(ohs));
+                hir::ExprKind::AddrOf(m, ohs)
+            }
+            ExprKind::Let(ref pats, ref scrutinee) => self.lower_expr_let(e.span, pats, scrutinee),
+            ExprKind::If(ref cond, ref then, ref else_opt) => {
+                self.lower_expr_if(e.span, cond, then, else_opt.as_deref())
+            }
+            ExprKind::While(ref cond, ref body, opt_label) => self.with_loop_scope(e.id, |this| {
+                this.lower_expr_while_in_loop_scope(e.span, cond, body, opt_label)
+            }),
+            ExprKind::Loop(ref body, opt_label) => self.with_loop_scope(e.id, |this| {
+                hir::ExprKind::Loop(
+                    this.lower_block(body, false),
+                    this.lower_label(opt_label),
+                    hir::LoopSource::Loop,
+                )
+            }),
+            ExprKind::TryBlock(ref body) => self.lower_expr_try_block(body),
+            ExprKind::Match(ref expr, ref arms) => hir::ExprKind::Match(
+                P(self.lower_expr(expr)),
+                arms.iter().map(|x| self.lower_arm(x)).collect(),
+                hir::MatchSource::Normal,
+            ),
+            ExprKind::Async(capture_clause, closure_node_id, ref block) => {
+                self.make_async_expr(capture_clause, closure_node_id, None, block.span, |this| {
+                    this.with_new_scopes(|this| {
+                        let block = this.lower_block(block, false);
+                        this.expr_block(block, ThinVec::new())
+                    })
+                })
+            }
+            ExprKind::Await(ref expr) => self.lower_expr_await(e.span, expr),
+            ExprKind::Closure(
+                capture_clause, asyncness, movability, ref decl, ref body, fn_decl_span
+            ) => if let IsAsync::Async { closure_id, .. } = asyncness {
+                self.lower_expr_async_closure(capture_clause, closure_id, decl, body, fn_decl_span)
+            } else {
+                self.lower_expr_closure(capture_clause, movability, decl, body, fn_decl_span)
+            }
+            ExprKind::Block(ref blk, opt_label) => {
+                hir::ExprKind::Block(self.lower_block(blk,
+                                                      opt_label.is_some()),
+                                                      self.lower_label(opt_label))
+            }
+            ExprKind::Assign(ref el, ref er) => {
+                hir::ExprKind::Assign(P(self.lower_expr(el)), P(self.lower_expr(er)))
+            }
+            ExprKind::AssignOp(op, ref el, ref er) => hir::ExprKind::AssignOp(
+                self.lower_binop(op),
+                P(self.lower_expr(el)),
+                P(self.lower_expr(er)),
+            ),
+            ExprKind::Field(ref el, ident) => hir::ExprKind::Field(P(self.lower_expr(el)), ident),
+            ExprKind::Index(ref el, ref er) => {
+                hir::ExprKind::Index(P(self.lower_expr(el)), P(self.lower_expr(er)))
+            }
+            ExprKind::Range(Some(ref e1), Some(ref e2), RangeLimits::Closed) => {
+                self.lower_expr_range_closed(e.span, e1, e2)
+            }
+            ExprKind::Range(ref e1, ref e2, lims) => {
+                self.lower_expr_range(e.span, e1.as_deref(), e2.as_deref(), lims)
+            }
+            ExprKind::Path(ref qself, ref path) => {
+                let qpath = self.lower_qpath(
+                    e.id,
+                    qself,
+                    path,
+                    ParamMode::Optional,
+                    ImplTraitContext::disallowed(),
+                );
+                hir::ExprKind::Path(qpath)
+            }
+            ExprKind::Break(opt_label, ref opt_expr) => {
+                hir::ExprKind::Break(
+                    self.lower_jump_destination(e.id, opt_label),
+                    opt_expr.as_ref().map(|x| P(self.lower_expr(x))),
+                )
+            }
+            ExprKind::Continue(opt_label) => {
+                hir::ExprKind::Continue(self.lower_jump_destination(e.id, opt_label))
+            }
+            ExprKind::Ret(ref e) => hir::ExprKind::Ret(e.as_ref().map(|x| P(self.lower_expr(x)))),
+            ExprKind::InlineAsm(ref asm) => self.lower_expr_asm(asm),
+            ExprKind::Struct(ref path, ref fields, ref maybe_expr) => hir::ExprKind::Struct(
+                P(self.lower_qpath(
+                    e.id,
+                    &None,
+                    path,
+                    ParamMode::Optional,
+                    ImplTraitContext::disallowed(),
+                )),
+                fields.iter().map(|x| self.lower_field(x)).collect(),
+                maybe_expr.as_ref().map(|x| P(self.lower_expr(x))),
+            ),
+            ExprKind::Paren(ref ex) => {
+                let mut ex = self.lower_expr(ex);
+                // Include parens in span, but only if it is a super-span.
+                if e.span.contains(ex.span) {
+                    ex.span = e.span;
+                }
+                // Merge attributes into the inner expression.
+                let mut attrs = e.attrs.clone();
+                attrs.extend::<Vec<_>>(ex.attrs.into());
+                ex.attrs = attrs;
+                return ex;
+            }
+
+            ExprKind::Yield(ref opt_expr) => self.lower_expr_yield(e.span, opt_expr.as_deref()),
+
+            ExprKind::Err => hir::ExprKind::Err,
+
+            // Desugar `ExprForLoop`
+            // from: `[opt_ident]: for <pat> in <head> <body>`
+            ExprKind::ForLoop(ref pat, ref head, ref body, opt_label) => {
+                return self.lower_expr_for(e, pat, head, body, opt_label);
+            }
+            ExprKind::Try(ref sub_expr) => self.lower_expr_try(e.span, sub_expr),
+            ExprKind::Mac(_) => panic!("Shouldn't exist here"),
+        };
+
+        hir::Expr {
+            hir_id: self.lower_node_id(e.id),
+            node: kind,
+            span: e.span,
+            attrs: e.attrs.clone(),
+        }
+    }
+
+    fn lower_unop(&mut self, u: UnOp) -> hir::UnOp {
+        match u {
+            UnOp::Deref => hir::UnDeref,
+            UnOp::Not => hir::UnNot,
+            UnOp::Neg => hir::UnNeg,
+        }
+    }
+
+    fn lower_binop(&mut self, b: BinOp) -> hir::BinOp {
+        Spanned {
+            node: match b.node {
+                BinOpKind::Add => hir::BinOpKind::Add,
+                BinOpKind::Sub => hir::BinOpKind::Sub,
+                BinOpKind::Mul => hir::BinOpKind::Mul,
+                BinOpKind::Div => hir::BinOpKind::Div,
+                BinOpKind::Rem => hir::BinOpKind::Rem,
+                BinOpKind::And => hir::BinOpKind::And,
+                BinOpKind::Or => hir::BinOpKind::Or,
+                BinOpKind::BitXor => hir::BinOpKind::BitXor,
+                BinOpKind::BitAnd => hir::BinOpKind::BitAnd,
+                BinOpKind::BitOr => hir::BinOpKind::BitOr,
+                BinOpKind::Shl => hir::BinOpKind::Shl,
+                BinOpKind::Shr => hir::BinOpKind::Shr,
+                BinOpKind::Eq => hir::BinOpKind::Eq,
+                BinOpKind::Lt => hir::BinOpKind::Lt,
+                BinOpKind::Le => hir::BinOpKind::Le,
+                BinOpKind::Ne => hir::BinOpKind::Ne,
+                BinOpKind::Ge => hir::BinOpKind::Ge,
+                BinOpKind::Gt => hir::BinOpKind::Gt,
+            },
+            span: b.span,
+        }
+    }
+
+    /// Emit an error and lower `ast::ExprKind::Let(pats, scrutinee)` into:
+    /// ```rust
+    /// match scrutinee { pats => true, _ => false }
+    /// ```
+    fn lower_expr_let(
+        &mut self,
+        span: Span,
+        pats: &[AstP<Pat>],
+        scrutinee: &Expr
+    ) -> hir::ExprKind {
+        // If we got here, the `let` expression is not allowed.
+        self.sess
+            .struct_span_err(span, "`let` expressions are not supported here")
+            .note("only supported directly in conditions of `if`- and `while`-expressions")
+            .note("as well as when nested within `&&` and parenthesis in those conditions")
+            .emit();
+
+        // For better recovery, we emit:
+        // ```
+        // match scrutinee { pats => true, _ => false }
+        // ```
+        // While this doesn't fully match the user's intent, it has key advantages:
+        // 1. We can avoid using `abort_if_errors`.
+        // 2. We can typeck both `pats` and `scrutinee`.
+        // 3. `pats` is allowed to be refutable.
+        // 4. The return type of the block is `bool` which seems like what the user wanted.
+        let scrutinee = self.lower_expr(scrutinee);
+        let then_arm = {
+            let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
+            let expr = self.expr_bool(span, true);
+            self.arm(pats, P(expr))
+        };
+        let else_arm = {
+            let pats = hir_vec![self.pat_wild(span)];
+            let expr = self.expr_bool(span, false);
+            self.arm(pats, P(expr))
+        };
+        hir::ExprKind::Match(
+            P(scrutinee),
+            vec![then_arm, else_arm].into(),
+            hir::MatchSource::Normal,
+        )
+    }
+
+    fn lower_expr_if(
+        &mut self,
+        span: Span,
+        cond: &Expr,
+        then: &Block,
+        else_opt: Option<&Expr>,
+    ) -> hir::ExprKind {
+        // FIXME(#53667): handle lowering of && and parens.
+
+        // `_ => else_block` where `else_block` is `{}` if there's `None`:
+        let else_pat = self.pat_wild(span);
+        let (else_expr, contains_else_clause) = match else_opt {
+            None => (self.expr_block_empty(span), false),
+            Some(els) => (self.lower_expr(els), true),
+        };
+        let else_arm = self.arm(hir_vec![else_pat], P(else_expr));
+
+        // Handle then + scrutinee:
+        let then_blk = self.lower_block(then, false);
+        let then_expr = self.expr_block(then_blk, ThinVec::new());
+        let (then_pats, scrutinee, desugar) = match cond.node {
+            // `<pat> => <then>`:
+            ExprKind::Let(ref pats, ref scrutinee) => {
+                let scrutinee = self.lower_expr(scrutinee);
+                let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
+                let desugar = hir::MatchSource::IfLetDesugar { contains_else_clause };
+                (pats, scrutinee, desugar)
+            }
+            // `true => <then>`:
+            _ => {
+                // Lower condition:
+                let cond = self.lower_expr(cond);
+                let span_block = self.mark_span_with_reason(
+                    DesugaringKind::CondTemporary,
+                    cond.span,
+                    None
+                );
+                // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
+                // to preserve drop semantics since `if cond { ... }` does not
+                // let temporaries live outside of `cond`.
+                let cond = self.expr_drop_temps(span_block, P(cond), ThinVec::new());
+
+                let desugar = hir::MatchSource::IfDesugar { contains_else_clause };
+                let pats = hir_vec![self.pat_bool(span, true)];
+                (pats, cond, desugar)
+            }
+        };
+        let then_arm = self.arm(then_pats, P(then_expr));
+
+        hir::ExprKind::Match(P(scrutinee), vec![then_arm, else_arm].into(), desugar)
+    }
+
+    fn lower_expr_while_in_loop_scope(
+        &mut self,
+        span: Span,
+        cond: &Expr,
+        body: &Block,
+        opt_label: Option<Label>
+    ) -> hir::ExprKind {
+        // FIXME(#53667): handle lowering of && and parens.
+
+        // Note that the block AND the condition are evaluated in the loop scope.
+        // This is done to allow `break` from inside the condition of the loop.
+
+        // `_ => break`:
+        let else_arm = {
+            let else_pat = self.pat_wild(span);
+            let else_expr = self.expr_break(span, ThinVec::new());
+            self.arm(hir_vec![else_pat], else_expr)
+        };
+
+        // Handle then + scrutinee:
+        let then_blk = self.lower_block(body, false);
+        let then_expr = self.expr_block(then_blk, ThinVec::new());
+        let (then_pats, scrutinee, desugar, source) = match cond.node {
+            ExprKind::Let(ref pats, ref scrutinee) => {
+                // to:
+                //
+                //   [opt_ident]: loop {
+                //     match <sub_expr> {
+                //       <pat> => <body>,
+                //       _ => break
+                //     }
+                //   }
+                let scrutinee = self.with_loop_condition_scope(|t| t.lower_expr(scrutinee));
+                let pats = pats.iter().map(|pat| self.lower_pat(pat)).collect();
+                let desugar = hir::MatchSource::WhileLetDesugar;
+                (pats, scrutinee, desugar, hir::LoopSource::WhileLet)
+            }
+            _ => {
+                // We desugar: `'label: while $cond $body` into:
+                //
+                // ```
+                // 'label: loop {
+                //     match DropTemps($cond) {
+                //         true => $body,
+                //         _ => break,
+                //     }
+                // }
+                // ```
+
+                // Lower condition:
+                let cond = self.with_loop_condition_scope(|this| this.lower_expr(cond));
+                let span_block = self.mark_span_with_reason(
+                    DesugaringKind::CondTemporary,
+                    cond.span,
+                    None,
+                );
+                // 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`.
+                let cond = self.expr_drop_temps(span_block, P(cond), ThinVec::new());
+
+                let desugar = hir::MatchSource::WhileDesugar;
+                // `true => <then>`:
+                let pats = hir_vec![self.pat_bool(span, true)];
+                (pats, cond, desugar, hir::LoopSource::While)
+            }
+        };
+        let then_arm = self.arm(then_pats, P(then_expr));
+
+        // `match <scrutinee> { ... }`
+        let match_expr = self.expr_match(
+            scrutinee.span,
+            P(scrutinee),
+            hir_vec![then_arm, else_arm],
+            desugar,
+        );
+
+        // `[opt_ident]: loop { ... }`
+        hir::ExprKind::Loop(
+            P(self.block_expr(P(match_expr))),
+            self.lower_label(opt_label),
+            source
+        )
+    }
+
+    fn lower_expr_try_block(&mut self, body: &Block) -> hir::ExprKind {
+        self.with_catch_scope(body.id, |this| {
+            let unstable_span = this.mark_span_with_reason(
+                DesugaringKind::TryBlock,
+                body.span,
+                this.allow_try_trait.clone(),
+            );
+            let mut block = this.lower_block(body, true).into_inner();
+            let tail = block.expr.take().map_or_else(
+                || this.expr_unit(this.sess.source_map().end_point(unstable_span)),
+                |x: P<hir::Expr>| x.into_inner(),
+            );
+            block.expr = Some(this.wrap_in_try_constructor(sym::from_ok, tail, unstable_span));
+            hir::ExprKind::Block(P(block), None)
+        })
+    }
+
+    fn wrap_in_try_constructor(
+        &mut self,
+        method: Symbol,
+        e: hir::Expr,
+        unstable_span: Span,
+    ) -> P<hir::Expr> {
+        let path = &[sym::ops, sym::Try, method];
+        let from_err = P(self.expr_std_path(unstable_span, path, None, ThinVec::new()));
+        P(self.expr_call(e.span, from_err, hir_vec![e]))
+    }
+
+    fn lower_arm(&mut self, arm: &Arm) -> hir::Arm {
+        hir::Arm {
+            hir_id: self.next_id(),
+            attrs: self.lower_attrs(&arm.attrs),
+            pats: arm.pats.iter().map(|x| self.lower_pat(x)).collect(),
+            guard: match arm.guard {
+                Some(ref x) => Some(hir::Guard::If(P(self.lower_expr(x)))),
+                _ => None,
+            },
+            body: P(self.lower_expr(&arm.body)),
+            span: arm.span,
+        }
+    }
+
+    pub(super) fn make_async_expr(
+        &mut self,
+        capture_clause: CaptureBy,
+        closure_node_id: NodeId,
+        ret_ty: Option<AstP<Ty>>,
+        span: Span,
+        body: impl FnOnce(&mut LoweringContext<'_>) -> hir::Expr,
+    ) -> hir::ExprKind {
+        let capture_clause = self.lower_capture_clause(capture_clause);
+        let output = match ret_ty {
+            Some(ty) => FunctionRetTy::Ty(ty),
+            None => FunctionRetTy::Default(span),
+        };
+        let ast_decl = FnDecl {
+            inputs: vec![],
+            output,
+            c_variadic: false
+        };
+        let decl = self.lower_fn_decl(&ast_decl, None, /* impl trait allowed */ false, None);
+        let body_id = self.lower_fn_body(&ast_decl, |this| {
+            this.generator_kind = Some(hir::GeneratorKind::Async);
+            body(this)
+        });
+
+        // `static || -> <ret_ty> { body }`:
+        let generator_node = hir::ExprKind::Closure(
+            capture_clause,
+            decl,
+            body_id,
+            span,
+            Some(hir::GeneratorMovability::Static)
+        );
+        let generator = hir::Expr {
+            hir_id: self.lower_node_id(closure_node_id),
+            node: generator_node,
+            span,
+            attrs: ThinVec::new(),
+        };
+
+        // `future::from_generator`:
+        let unstable_span = self.mark_span_with_reason(
+            DesugaringKind::Async,
+            span,
+            self.allow_gen_future.clone(),
+        );
+        let gen_future = self.expr_std_path(
+            unstable_span,
+            &[sym::future, sym::from_generator],
+            None,
+            ThinVec::new()
+        );
+
+        // `future::from_generator(generator)`:
+        hir::ExprKind::Call(P(gen_future), hir_vec![generator])
+    }
+
+    /// Desugar `<expr>.await` into:
+    /// ```rust
+    /// {
+    ///     let mut pinned = <expr>;
+    ///     loop {
+    ///         match ::std::future::poll_with_tls_context(unsafe {
+    ///             ::std::pin::Pin::new_unchecked(&mut pinned)
+    ///         }) {
+    ///             ::std::task::Poll::Ready(result) => break result,
+    ///             ::std::task::Poll::Pending => {},
+    ///         }
+    ///         yield ();
+    ///     }
+    /// }
+    /// ```
+    fn lower_expr_await(&mut self, await_span: Span, expr: &Expr) -> hir::ExprKind {
+        match self.generator_kind {
+            Some(hir::GeneratorKind::Async) => {},
+            Some(hir::GeneratorKind::Gen) |
+            None => {
+                let mut err = struct_span_err!(
+                    self.sess,
+                    await_span,
+                    E0728,
+                    "`await` is only allowed inside `async` functions and blocks"
+                );
+                err.span_label(await_span, "only allowed inside `async` functions and blocks");
+                if let Some(item_sp) = self.current_item {
+                    err.span_label(item_sp, "this is not `async`");
+                }
+                err.emit();
+            }
+        }
+        let span = self.mark_span_with_reason(
+            DesugaringKind::Await,
+            await_span,
+            None,
+        );
+        let gen_future_span = self.mark_span_with_reason(
+            DesugaringKind::Await,
+            await_span,
+            self.allow_gen_future.clone(),
+        );
+
+        // let mut pinned = <expr>;
+        let expr = P(self.lower_expr(expr));
+        let pinned_ident = Ident::with_empty_ctxt(sym::pinned);
+        let (pinned_pat, pinned_pat_hid) = self.pat_ident_binding_mode(
+            span,
+            pinned_ident,
+            hir::BindingAnnotation::Mutable,
+        );
+        let pinned_let = self.stmt_let_pat(
+            ThinVec::new(),
+            span,
+            Some(expr),
+            pinned_pat,
+            hir::LocalSource::AwaitDesugar,
+        );
+
+        // ::std::future::poll_with_tls_context(unsafe {
+        //     ::std::pin::Pin::new_unchecked(&mut pinned)
+        // })`
+        let poll_expr = {
+            let pinned = P(self.expr_ident(span, pinned_ident, pinned_pat_hid));
+            let ref_mut_pinned = self.expr_mut_addr_of(span, pinned);
+            let pin_ty_id = self.next_id();
+            let new_unchecked_expr_kind = self.expr_call_std_assoc_fn(
+                pin_ty_id,
+                span,
+                &[sym::pin, sym::Pin],
+                "new_unchecked",
+                hir_vec![ref_mut_pinned],
+            );
+            let new_unchecked = P(self.expr(span, new_unchecked_expr_kind, ThinVec::new()));
+            let unsafe_expr = self.expr_unsafe(new_unchecked);
+            P(self.expr_call_std_path(
+                gen_future_span,
+                &[sym::future, sym::poll_with_tls_context],
+                hir_vec![unsafe_expr],
+            ))
+        };
+
+        // `::std::task::Poll::Ready(result) => break result`
+        let loop_node_id = self.sess.next_node_id();
+        let loop_hir_id = self.lower_node_id(loop_node_id);
+        let ready_arm = {
+            let x_ident = Ident::with_empty_ctxt(sym::result);
+            let (x_pat, x_pat_hid) = self.pat_ident(span, x_ident);
+            let x_expr = P(self.expr_ident(span, x_ident, x_pat_hid));
+            let ready_pat = self.pat_std_enum(
+                span,
+                &[sym::task, sym::Poll, sym::Ready],
+                hir_vec![x_pat],
+            );
+            let break_x = self.with_loop_scope(loop_node_id, |this| {
+                let expr_break = hir::ExprKind::Break(
+                    this.lower_loop_destination(None),
+                    Some(x_expr),
+                );
+                P(this.expr(await_span, expr_break, ThinVec::new()))
+            });
+            self.arm(hir_vec![ready_pat], break_x)
+        };
+
+        // `::std::task::Poll::Pending => {}`
+        let pending_arm = {
+            let pending_pat = self.pat_std_enum(
+                span,
+                &[sym::task, sym::Poll, sym::Pending],
+                hir_vec![],
+            );
+            let empty_block = P(self.expr_block_empty(span));
+            self.arm(hir_vec![pending_pat], empty_block)
+        };
+
+        let match_stmt = {
+            let match_expr = self.expr_match(
+                span,
+                poll_expr,
+                hir_vec![ready_arm, pending_arm],
+                hir::MatchSource::AwaitDesugar,
+            );
+            self.stmt_expr(span, match_expr)
+        };
+
+        let yield_stmt = {
+            let unit = self.expr_unit(span);
+            let yield_expr = self.expr(
+                span,
+                hir::ExprKind::Yield(P(unit), hir::YieldSource::Await),
+                ThinVec::new(),
+            );
+            self.stmt_expr(span, yield_expr)
+        };
+
+        let loop_block = P(self.block_all(
+            span,
+            hir_vec![match_stmt, yield_stmt],
+            None,
+        ));
+
+        let loop_expr = P(hir::Expr {
+            hir_id: loop_hir_id,
+            node: hir::ExprKind::Loop(
+                loop_block,
+                None,
+                hir::LoopSource::Loop,
+            ),
+            span,
+            attrs: ThinVec::new(),
+        });
+
+        hir::ExprKind::Block(
+            P(self.block_all(span, hir_vec![pinned_let], Some(loop_expr))),
+            None,
+        )
+    }
+
+    fn lower_expr_closure(
+        &mut self,
+        capture_clause: CaptureBy,
+        movability: Movability,
+        decl: &FnDecl,
+        body: &Expr,
+        fn_decl_span: Span,
+    ) -> hir::ExprKind {
+        // Lower outside new scope to preserve `is_in_loop_condition`.
+        let fn_decl = self.lower_fn_decl(decl, None, false, None);
+
+        self.with_new_scopes(|this| {
+            this.current_item = Some(fn_decl_span);
+            let mut generator_kind = None;
+            let body_id = this.lower_fn_body(decl, |this| {
+                let e = this.lower_expr(body);
+                generator_kind = this.generator_kind;
+                e
+            });
+            let generator_option = this.generator_movability_for_fn(
+                &decl,
+                fn_decl_span,
+                generator_kind,
+                movability,
+            );
+            hir::ExprKind::Closure(
+                this.lower_capture_clause(capture_clause),
+                fn_decl,
+                body_id,
+                fn_decl_span,
+                generator_option,
+            )
+        })
+    }
+
+    fn lower_capture_clause(&mut self, c: CaptureBy) -> hir::CaptureClause {
+        match c {
+            CaptureBy::Value => hir::CaptureByValue,
+            CaptureBy::Ref => hir::CaptureByRef,
+        }
+    }
+
+    fn generator_movability_for_fn(
+        &mut self,
+        decl: &FnDecl,
+        fn_decl_span: Span,
+        generator_kind: Option<hir::GeneratorKind>,
+        movability: Movability,
+    ) -> Option<hir::GeneratorMovability> {
+        match generator_kind {
+            Some(hir::GeneratorKind::Gen) =>  {
+                if !decl.inputs.is_empty() {
+                    span_err!(
+                        self.sess,
+                        fn_decl_span,
+                        E0628,
+                        "generators cannot have explicit arguments"
+                    );
+                    self.sess.abort_if_errors();
+                }
+                Some(match movability {
+                    Movability::Movable => hir::GeneratorMovability::Movable,
+                    Movability::Static => hir::GeneratorMovability::Static,
+                })
+            },
+            Some(hir::GeneratorKind::Async) => {
+                bug!("non-`async` closure body turned `async` during lowering");
+            },
+            None => {
+                if movability == Movability::Static {
+                    span_err!(
+                        self.sess,
+                        fn_decl_span,
+                        E0697,
+                        "closures cannot be static"
+                    );
+                }
+                None
+            },
+        }
+    }
+
+    fn lower_expr_async_closure(
+        &mut self,
+        capture_clause: CaptureBy,
+        closure_id: NodeId,
+        decl: &FnDecl,
+        body: &Expr,
+        fn_decl_span: Span,
+    ) -> hir::ExprKind {
+        let outer_decl = FnDecl {
+            inputs: decl.inputs.clone(),
+            output: FunctionRetTy::Default(fn_decl_span),
+            c_variadic: false,
+        };
+        // We need to lower the declaration outside the new scope, because we
+        // have to conserve the state of being inside a loop condition for the
+        // closure argument types.
+        let fn_decl = self.lower_fn_decl(&outer_decl, None, false, None);
+
+        self.with_new_scopes(|this| {
+            // FIXME(cramertj): allow `async` non-`move` closures with arguments.
+            if capture_clause == CaptureBy::Ref && !decl.inputs.is_empty() {
+                struct_span_err!(
+                    this.sess,
+                    fn_decl_span,
+                    E0708,
+                    "`async` non-`move` closures with arguments are not currently supported",
+                )
+                .help(
+                    "consider using `let` statements to manually capture \
+                    variables by reference before entering an `async move` closure"
+                )
+                .emit();
+            }
+
+            // Transform `async |x: u8| -> X { ... }` into
+            // `|x: u8| future_from_generator(|| -> X { ... })`.
+            let body_id = this.lower_fn_body(&outer_decl, |this| {
+                let async_ret_ty = if let FunctionRetTy::Ty(ty) = &decl.output {
+                    Some(ty.clone())
+                } else {
+                    None
+                };
+                let async_body = this.make_async_expr(
+                    capture_clause, closure_id, async_ret_ty, body.span,
+                    |this| {
+                        this.with_new_scopes(|this| this.lower_expr(body))
+                    }
+                );
+                this.expr(fn_decl_span, async_body, ThinVec::new())
+            });
+            hir::ExprKind::Closure(
+                this.lower_capture_clause(capture_clause),
+                fn_decl,
+                body_id,
+                fn_decl_span,
+                None,
+            )
+        })
+    }
+
+    /// Desugar `<start>..=<end>` into `std::ops::RangeInclusive::new(<start>, <end>)`.
+    fn lower_expr_range_closed(&mut self, span: Span, e1: &Expr, e2: &Expr) -> hir::ExprKind {
+        let id = self.next_id();
+        let e1 = self.lower_expr(e1);
+        let e2 = self.lower_expr(e2);
+        self.expr_call_std_assoc_fn(
+            id,
+            span,
+            &[sym::ops, sym::RangeInclusive],
+            "new",
+            hir_vec![e1, e2],
+        )
+    }
+
+    fn lower_expr_range(
+        &mut self,
+        span: Span,
+        e1: Option<&Expr>,
+        e2: Option<&Expr>,
+        lims: RangeLimits,
+    ) -> hir::ExprKind {
+        use syntax::ast::RangeLimits::*;
+
+        let path = match (e1, e2, lims) {
+            (None, None, HalfOpen) => sym::RangeFull,
+            (Some(..), None, HalfOpen) => sym::RangeFrom,
+            (None, Some(..), HalfOpen) => sym::RangeTo,
+            (Some(..), Some(..), HalfOpen) => sym::Range,
+            (None, Some(..), Closed) => sym::RangeToInclusive,
+            (Some(..), Some(..), Closed) => unreachable!(),
+            (_, None, Closed) => self.diagnostic()
+                .span_fatal(span, "inclusive range with no end")
+                .raise(),
+        };
+
+        let fields = e1.iter()
+            .map(|e| ("start", e))
+            .chain(e2.iter().map(|e| ("end", e)))
+            .map(|(s, e)| {
+                let expr = P(self.lower_expr(&e));
+                let ident = Ident::new(Symbol::intern(s), e.span);
+                self.field(ident, expr, e.span)
+            })
+            .collect::<P<[hir::Field]>>();
+
+        let is_unit = fields.is_empty();
+        let struct_path = [sym::ops, path];
+        let struct_path = self.std_path(span, &struct_path, None, is_unit);
+        let struct_path = hir::QPath::Resolved(None, P(struct_path));
+
+        if is_unit {
+            hir::ExprKind::Path(struct_path)
+        } else {
+            hir::ExprKind::Struct(P(struct_path), fields, None)
+        }
+    }
+
+    fn lower_label(&mut self, label: Option<Label>) -> Option<hir::Label> {
+        label.map(|label| hir::Label {
+            ident: label.ident,
+        })
+    }
+
+    fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
+        let target_id = match destination {
+            Some((id, _)) => {
+                if let Some(loop_id) = self.resolver.get_label_res(id) {
+                    Ok(self.lower_node_id(loop_id))
+                } else {
+                    Err(hir::LoopIdError::UnresolvedLabel)
+                }
+            }
+            None => {
+                self.loop_scopes
+                    .last()
+                    .cloned()
+                    .map(|id| Ok(self.lower_node_id(id)))
+                    .unwrap_or(Err(hir::LoopIdError::OutsideLoopScope))
+                    .into()
+            }
+        };
+        hir::Destination {
+            label: self.lower_label(destination.map(|(_, label)| label)),
+            target_id,
+        }
+    }
+
+    fn lower_jump_destination(&mut self, id: NodeId, opt_label: Option<Label>) -> hir::Destination {
+        if self.is_in_loop_condition && opt_label.is_none() {
+            hir::Destination {
+                label: None,
+                target_id: Err(hir::LoopIdError::UnlabeledCfInWhileCondition).into(),
+            }
+        } else {
+            self.lower_loop_destination(opt_label.map(|label| (id, label)))
+        }
+    }
+
+    fn with_catch_scope<T, F>(&mut self, catch_id: NodeId, f: F) -> T
+    where
+        F: FnOnce(&mut LoweringContext<'_>) -> T,
+    {
+        let len = self.catch_scopes.len();
+        self.catch_scopes.push(catch_id);
+
+        let result = f(self);
+        assert_eq!(
+            len + 1,
+            self.catch_scopes.len(),
+            "catch scopes should be added and removed in stack order"
+        );
+
+        self.catch_scopes.pop().unwrap();
+
+        result
+    }
+
+    fn with_loop_scope<T, F>(&mut self, loop_id: NodeId, f: F) -> T
+    where
+        F: FnOnce(&mut LoweringContext<'_>) -> T,
+    {
+        // We're no longer in the base loop's condition; we're in another loop.
+        let was_in_loop_condition = self.is_in_loop_condition;
+        self.is_in_loop_condition = false;
+
+        let len = self.loop_scopes.len();
+        self.loop_scopes.push(loop_id);
+
+        let result = f(self);
+        assert_eq!(
+            len + 1,
+            self.loop_scopes.len(),
+            "loop scopes should be added and removed in stack order"
+        );
+
+        self.loop_scopes.pop().unwrap();
+
+        self.is_in_loop_condition = was_in_loop_condition;
+
+        result
+    }
+
+    fn with_loop_condition_scope<T, F>(&mut self, f: F) -> T
+    where
+        F: FnOnce(&mut LoweringContext<'_>) -> T,
+    {
+        let was_in_loop_condition = self.is_in_loop_condition;
+        self.is_in_loop_condition = true;
+
+        let result = f(self);
+
+        self.is_in_loop_condition = was_in_loop_condition;
+
+        result
+    }
+
+    fn lower_expr_asm(&mut self, asm: &InlineAsm) -> hir::ExprKind {
+        let hir_asm = hir::InlineAsm {
+            inputs: asm.inputs.iter().map(|&(ref c, _)| c.clone()).collect(),
+            outputs: asm.outputs
+                .iter()
+                .map(|out| hir::InlineAsmOutput {
+                    constraint: out.constraint.clone(),
+                    is_rw: out.is_rw,
+                    is_indirect: out.is_indirect,
+                    span: out.expr.span,
+                })
+                .collect(),
+            asm: asm.asm.clone(),
+            asm_str_style: asm.asm_str_style,
+            clobbers: asm.clobbers.clone().into(),
+            volatile: asm.volatile,
+            alignstack: asm.alignstack,
+            dialect: asm.dialect,
+            ctxt: asm.ctxt,
+        };
+
+        let outputs = asm.outputs
+            .iter()
+            .map(|out| self.lower_expr(&out.expr))
+            .collect();
+
+        let inputs = asm.inputs
+            .iter()
+            .map(|&(_, ref input)| self.lower_expr(input))
+            .collect();
+
+        hir::ExprKind::InlineAsm(P(hir_asm), outputs, inputs)
+    }
+
+    fn lower_field(&mut self, f: &Field) -> hir::Field {
+        hir::Field {
+            hir_id: self.next_id(),
+            ident: f.ident,
+            expr: P(self.lower_expr(&f.expr)),
+            span: f.span,
+            is_shorthand: f.is_shorthand,
+        }
+    }
+
+    fn lower_expr_yield(&mut self, span: Span, opt_expr: Option<&Expr>) -> hir::ExprKind {
+        match self.generator_kind {
+            Some(hir::GeneratorKind::Gen) => {},
+            Some(hir::GeneratorKind::Async) => {
+                span_err!(
+                    self.sess,
+                    span,
+                    E0727,
+                    "`async` generators are not yet supported",
+                );
+                self.sess.abort_if_errors();
+            },
+            None => self.generator_kind = Some(hir::GeneratorKind::Gen),
+        }
+
+        let expr = opt_expr
+            .as_ref()
+            .map(|x| self.lower_expr(x))
+            .unwrap_or_else(|| self.expr_unit(span));
+
+        hir::ExprKind::Yield(P(expr), hir::YieldSource::Yield)
+    }
+
+    /// Desugar `ExprForLoop` from: `[opt_ident]: for <pat> in <head> <body>` into:
+    /// ```rust
+    /// {
+    ///     let result = match ::std::iter::IntoIterator::into_iter(<head>) {
+    ///         mut iter => {
+    ///             [opt_ident]: loop {
+    ///                 let mut __next;
+    ///                 match ::std::iter::Iterator::next(&mut iter) {
+    ///                     ::std::option::Option::Some(val) => __next = val,
+    ///                     ::std::option::Option::None => break
+    ///                 };
+    ///                 let <pat> = __next;
+    ///                 StmtKind::Expr(<body>);
+    ///             }
+    ///         }
+    ///     };
+    ///     result
+    /// }
+    /// ```
+    fn lower_expr_for(
+        &mut self,
+        e: &Expr,
+        pat: &Pat,
+        head: &Expr,
+        body: &Block,
+        opt_label: Option<Label>,
+    ) -> hir::Expr {
+        // expand <head>
+        let mut head = self.lower_expr(head);
+        let head_sp = head.span;
+        let desugared_span = self.mark_span_with_reason(
+            DesugaringKind::ForLoop,
+            head_sp,
+            None,
+        );
+        head.span = desugared_span;
+
+        let iter = Ident::with_empty_ctxt(sym::iter);
+
+        let next_ident = Ident::with_empty_ctxt(sym::__next);
+        let (next_pat, next_pat_hid) = self.pat_ident_binding_mode(
+            desugared_span,
+            next_ident,
+            hir::BindingAnnotation::Mutable,
+        );
+
+        // `::std::option::Option::Some(val) => __next = val`
+        let pat_arm = {
+            let val_ident = Ident::with_empty_ctxt(sym::val);
+            let (val_pat, val_pat_hid) = self.pat_ident(pat.span, val_ident);
+            let val_expr = P(self.expr_ident(pat.span, val_ident, val_pat_hid));
+            let next_expr = P(self.expr_ident(pat.span, next_ident, next_pat_hid));
+            let assign = P(self.expr(
+                pat.span,
+                hir::ExprKind::Assign(next_expr, val_expr),
+                ThinVec::new(),
+            ));
+            let some_pat = self.pat_some(pat.span, val_pat);
+            self.arm(hir_vec![some_pat], assign)
+        };
+
+        // `::std::option::Option::None => break`
+        let break_arm = {
+            let break_expr =
+                self.with_loop_scope(e.id, |this| this.expr_break(e.span, ThinVec::new()));
+            let pat = self.pat_none(e.span);
+            self.arm(hir_vec![pat], break_expr)
+        };
+
+        // `mut iter`
+        let (iter_pat, iter_pat_nid) = self.pat_ident_binding_mode(
+            desugared_span,
+            iter,
+            hir::BindingAnnotation::Mutable
+        );
+
+        // `match ::std::iter::Iterator::next(&mut iter) { ... }`
+        let match_expr = {
+            let iter = P(self.expr_ident(head_sp, iter, iter_pat_nid));
+            let ref_mut_iter = self.expr_mut_addr_of(head_sp, iter);
+            let next_path = &[sym::iter, sym::Iterator, sym::next];
+            let next_expr = P(self.expr_call_std_path(
+                head_sp,
+                next_path,
+                hir_vec![ref_mut_iter],
+            ));
+            let arms = hir_vec![pat_arm, break_arm];
+
+            self.expr_match(head_sp, next_expr, arms, hir::MatchSource::ForLoopDesugar)
+        };
+        let match_stmt = self.stmt_expr(head_sp, match_expr);
+
+        let next_expr = P(self.expr_ident(head_sp, next_ident, next_pat_hid));
+
+        // `let mut __next`
+        let next_let = self.stmt_let_pat(
+            ThinVec::new(),
+            desugared_span,
+            None,
+            next_pat,
+            hir::LocalSource::ForLoopDesugar,
+        );
+
+        // `let <pat> = __next`
+        let pat = self.lower_pat(pat);
+        let pat_let = self.stmt_let_pat(
+            ThinVec::new(),
+            head_sp,
+            Some(next_expr),
+            pat,
+            hir::LocalSource::ForLoopDesugar,
+        );
+
+        let body_block = self.with_loop_scope(e.id, |this| this.lower_block(body, false));
+        let body_expr = self.expr_block(body_block, ThinVec::new());
+        let body_stmt = self.stmt_expr(body.span, body_expr);
+
+        let loop_block = P(self.block_all(
+            e.span,
+            hir_vec![next_let, match_stmt, pat_let, body_stmt],
+            None,
+        ));
+
+        // `[opt_ident]: loop { ... }`
+        let loop_expr = hir::ExprKind::Loop(
+            loop_block,
+            self.lower_label(opt_label),
+            hir::LoopSource::ForLoop,
+        );
+        let loop_expr = P(hir::Expr {
+            hir_id: self.lower_node_id(e.id),
+            node: loop_expr,
+            span: e.span,
+            attrs: ThinVec::new(),
+        });
+
+        // `mut iter => { ... }`
+        let iter_arm = self.arm(hir_vec![iter_pat], loop_expr);
+
+        // `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
+        let into_iter_expr = {
+            let into_iter_path =
+                &[sym::iter, sym::IntoIterator, sym::into_iter];
+            P(self.expr_call_std_path(
+                head_sp,
+                into_iter_path,
+                hir_vec![head],
+            ))
+        };
+
+        let match_expr = P(self.expr_match(
+            head_sp,
+            into_iter_expr,
+            hir_vec![iter_arm],
+            hir::MatchSource::ForLoopDesugar,
+        ));
+
+        // This is effectively `{ let _result = ...; _result }`.
+        // The construct was introduced in #21984 and is necessary to make sure that
+        // temporaries in the `head` expression are dropped and do not leak to the
+        // surrounding scope of the `match` since the `match` is not a terminating scope.
+        //
+        // Also, add the attributes to the outer returned expr node.
+        self.expr_drop_temps(head_sp, match_expr, e.attrs.clone())
+    }
+
+    /// Desugar `ExprKind::Try` from: `<expr>?` into:
+    /// ```rust
+    /// match Try::into_result(<expr>) {
+    ///     Ok(val) => #[allow(unreachable_code)] val,
+    ///     Err(err) => #[allow(unreachable_code)]
+    ///                 // If there is an enclosing `try {...}`:
+    ///                 break 'catch_target Try::from_error(From::from(err)),
+    ///                 // Otherwise:
+    ///                 return Try::from_error(From::from(err)),
+    /// }
+    /// ```
+    fn lower_expr_try(&mut self, span: Span, sub_expr: &Expr) -> hir::ExprKind {
+        let unstable_span = self.mark_span_with_reason(
+            DesugaringKind::QuestionMark,
+            span,
+            self.allow_try_trait.clone(),
+        );
+        let try_span = self.sess.source_map().end_point(span);
+        let try_span = self.mark_span_with_reason(
+            DesugaringKind::QuestionMark,
+            try_span,
+            self.allow_try_trait.clone(),
+        );
+
+        // `Try::into_result(<expr>)`
+        let scrutinee = {
+            // expand <expr>
+            let sub_expr = self.lower_expr(sub_expr);
+
+            let path = &[sym::ops, sym::Try, sym::into_result];
+            P(self.expr_call_std_path(unstable_span, path, hir_vec![sub_expr]))
+        };
+
+        // `#[allow(unreachable_code)]`
+        let attr = {
+            // `allow(unreachable_code)`
+            let allow = {
+                let allow_ident = Ident::new(sym::allow, span);
+                let uc_ident = Ident::new(sym::unreachable_code, 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];
+
+        // `Ok(val) => #[allow(unreachable_code)] val,`
+        let ok_arm = {
+            let val_ident = Ident::with_empty_ctxt(sym::val);
+            let (val_pat, val_pat_nid) = self.pat_ident(span, val_ident);
+            let val_expr = P(self.expr_ident_with_attrs(
+                span,
+                val_ident,
+                val_pat_nid,
+                ThinVec::from(attrs.clone()),
+            ));
+            let ok_pat = self.pat_ok(span, val_pat);
+
+            self.arm(hir_vec![ok_pat], val_expr)
+        };
+
+        // `Err(err) => #[allow(unreachable_code)]
+        //              return Try::from_error(From::from(err)),`
+        let err_arm = {
+            let err_ident = Ident::with_empty_ctxt(sym::err);
+            let (err_local, err_local_nid) = self.pat_ident(try_span, err_ident);
+            let from_expr = {
+                let from_path = &[sym::convert, sym::From, sym::from];
+                let err_expr = self.expr_ident(try_span, err_ident, err_local_nid);
+                self.expr_call_std_path(try_span, from_path, hir_vec![err_expr])
+            };
+            let from_err_expr =
+                self.wrap_in_try_constructor(sym::from_error, from_expr, unstable_span);
+            let thin_attrs = ThinVec::from(attrs);
+            let catch_scope = self.catch_scopes.last().map(|x| *x);
+            let ret_expr = if let Some(catch_node) = catch_scope {
+                let target_id = Ok(self.lower_node_id(catch_node));
+                P(self.expr(
+                    try_span,
+                    hir::ExprKind::Break(
+                        hir::Destination {
+                            label: None,
+                            target_id,
+                        },
+                        Some(from_err_expr),
+                    ),
+                    thin_attrs,
+                ))
+            } else {
+                P(self.expr(try_span, hir::ExprKind::Ret(Some(from_err_expr)), thin_attrs))
+            };
+
+            let err_pat = self.pat_err(try_span, err_local);
+            self.arm(hir_vec![err_pat], ret_expr)
+        };
+
+        hir::ExprKind::Match(
+            scrutinee,
+            hir_vec![err_arm, ok_arm],
+            hir::MatchSource::TryDesugar,
+        )
+    }
+
+    // =========================================================================
+    // Helper methods for building HIR.
+    // =========================================================================
+
+    /// Constructs a `true` or `false` literal expression.
+    pub(super) fn expr_bool(&mut self, span: Span, val: bool) -> hir::Expr {
+        let lit = Spanned { span, node: LitKind::Bool(val) };
+        self.expr(span, hir::ExprKind::Lit(lit), ThinVec::new())
+    }
+
+    /// 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 { .. }`.
+    fn expr_drop_temps(
+        &mut self,
+        span: Span,
+        expr: P<hir::Expr>,
+        attrs: ThinVec<Attribute>
+    ) -> hir::Expr {
+        self.expr(span, hir::ExprKind::DropTemps(expr), attrs)
+    }
+
+    fn expr_match(
+        &mut self,
+        span: Span,
+        arg: P<hir::Expr>,
+        arms: hir::HirVec<hir::Arm>,
+        source: hir::MatchSource,
+    ) -> hir::Expr {
+        self.expr(span, hir::ExprKind::Match(arg, arms, source), ThinVec::new())
+    }
+
+    fn expr_break(&mut self, span: Span, attrs: ThinVec<Attribute>) -> P<hir::Expr> {
+        let expr_break = hir::ExprKind::Break(self.lower_loop_destination(None), None);
+        P(self.expr(span, expr_break, attrs))
+    }
+
+    fn expr_mut_addr_of(&mut self, span: Span, e: P<hir::Expr>) -> hir::Expr {
+        self.expr(span, hir::ExprKind::AddrOf(hir::MutMutable, e), ThinVec::new())
+    }
+
+    fn expr_unit(&mut self, sp: Span) -> hir::Expr {
+        self.expr_tuple(sp, hir_vec![])
+    }
+
+    fn expr_tuple(&mut self, sp: Span, exprs: hir::HirVec<hir::Expr>) -> hir::Expr {
+        self.expr(sp, hir::ExprKind::Tup(exprs), ThinVec::new())
+    }
+
+    fn expr_call(
+        &mut self,
+        span: Span,
+        e: P<hir::Expr>,
+        args: hir::HirVec<hir::Expr>,
+    ) -> hir::Expr {
+        self.expr(span, hir::ExprKind::Call(e, args), ThinVec::new())
+    }
+
+    // Note: associated functions must use `expr_call_std_path`.
+    fn expr_call_std_path(
+        &mut self,
+        span: Span,
+        path_components: &[Symbol],
+        args: hir::HirVec<hir::Expr>,
+    ) -> hir::Expr {
+        let path = P(self.expr_std_path(span, path_components, None, ThinVec::new()));
+        self.expr_call(span, path, args)
+    }
+
+    // Create an expression calling an associated function of an std type.
+    //
+    // Associated functions cannot be resolved through the normal `std_path` function,
+    // as they are resolved differently and so cannot use `expr_call_std_path`.
+    //
+    // This function accepts the path component (`ty_path_components`) separately from
+    // the name of the associated function (`assoc_fn_name`) in order to facilitate
+    // separate resolution of the type and creation of a path referring to its associated
+    // function.
+    fn expr_call_std_assoc_fn(
+        &mut self,
+        ty_path_id: hir::HirId,
+        span: Span,
+        ty_path_components: &[Symbol],
+        assoc_fn_name: &str,
+        args: hir::HirVec<hir::Expr>,
+    ) -> hir::ExprKind {
+        let ty_path = P(self.std_path(span, ty_path_components, None, false));
+        let ty = P(self.ty_path(ty_path_id, span, hir::QPath::Resolved(None, ty_path)));
+        let fn_seg = P(hir::PathSegment::from_ident(Ident::from_str(assoc_fn_name)));
+        let fn_path = hir::QPath::TypeRelative(ty, fn_seg);
+        let fn_expr = P(self.expr(span, hir::ExprKind::Path(fn_path), ThinVec::new()));
+        hir::ExprKind::Call(fn_expr, args)
+    }
+
+    fn expr_std_path(
+        &mut self,
+        span: Span,
+        components: &[Symbol],
+        params: Option<P<hir::GenericArgs>>,
+        attrs: ThinVec<Attribute>,
+    ) -> hir::Expr {
+        let path = self.std_path(span, components, params, true);
+        self.expr(
+            span,
+            hir::ExprKind::Path(hir::QPath::Resolved(None, P(path))),
+            attrs,
+        )
+    }
+
+    pub(super) fn expr_ident(&mut self, sp: Span, ident: Ident, binding: hir::HirId) -> hir::Expr {
+        self.expr_ident_with_attrs(sp, ident, binding, ThinVec::new())
+    }
+
+    fn expr_ident_with_attrs(
+        &mut self,
+        span: Span,
+        ident: Ident,
+        binding: hir::HirId,
+        attrs: ThinVec<Attribute>,
+    ) -> hir::Expr {
+        let expr_path = hir::ExprKind::Path(hir::QPath::Resolved(
+            None,
+            P(hir::Path {
+                span,
+                res: Res::Local(binding),
+                segments: hir_vec![hir::PathSegment::from_ident(ident)],
+            }),
+        ));
+
+        self.expr(span, expr_path, attrs)
+    }
+
+    fn expr_unsafe(&mut self, expr: P<hir::Expr>) -> hir::Expr {
+        let hir_id = self.next_id();
+        let span = expr.span;
+        self.expr(
+            span,
+            hir::ExprKind::Block(P(hir::Block {
+                stmts: hir_vec![],
+                expr: Some(expr),
+                hir_id,
+                rules: hir::UnsafeBlock(hir::CompilerGenerated),
+                span,
+                targeted_by_break: false,
+            }), None),
+            ThinVec::new(),
+        )
+    }
+
+    fn expr_block_empty(&mut self, span: Span) -> hir::Expr {
+        let blk = self.block_all(span, hir_vec![], None);
+        self.expr_block(P(blk), ThinVec::new())
+    }
+
+    pub(super) fn expr_block(&mut self, b: P<hir::Block>, attrs: ThinVec<Attribute>) -> hir::Expr {
+        self.expr(b.span, hir::ExprKind::Block(b, None), attrs)
+    }
+
+    pub(super) fn expr(
+        &mut self,
+        span: Span,
+        node: hir::ExprKind,
+        attrs: ThinVec<Attribute>
+    ) -> hir::Expr {
+        hir::Expr {
+            hir_id: self.next_id(),
+            node,
+            span,
+            attrs,
+        }
+    }
+
+    fn field(&mut self, ident: Ident, expr: P<hir::Expr>, span: Span) -> hir::Field {
+        hir::Field {
+            hir_id: self.next_id(),
+            ident,
+            span,
+            expr,
+            is_shorthand: false,
+        }
+    }
+
+    fn arm(&mut self, pats: hir::HirVec<P<hir::Pat>>, expr: P<hir::Expr>) -> hir::Arm {
+        hir::Arm {
+            hir_id: self.next_id(),
+            attrs: hir_vec![],
+            pats,
+            guard: None,
+            span: expr.span,
+            body: expr,
+        }
+    }
+}
diff --git a/src/librustc/hir/lowering/item.rs b/src/librustc/hir/lowering/item.rs
new file mode 100644
index 0000000000000..6b717e75199c7
--- /dev/null
+++ b/src/librustc/hir/lowering/item.rs
@@ -0,0 +1,1410 @@
+use super::LoweringContext;
+use super::ImplTraitContext;
+use super::ImplTraitPosition;
+use super::ImplTraitTypeIdVisitor;
+use super::AnonymousLifetimeMode;
+use super::ParamMode;
+
+use crate::hir::{self, HirVec};
+use crate::hir::ptr::P;
+use crate::hir::def_id::DefId;
+use crate::hir::def::{Res, DefKind};
+use crate::util::nodemap::NodeMap;
+
+use rustc_data_structures::thin_vec::ThinVec;
+
+use std::collections::BTreeSet;
+use smallvec::SmallVec;
+use syntax::attr;
+use syntax::ast::*;
+use syntax::visit::{self, Visitor};
+use syntax::ext::base::SpecialDerives;
+use syntax::source_map::{respan, DesugaringKind, Spanned};
+use syntax::symbol::{kw, sym};
+use syntax_pos::Span;
+
+pub(super) struct ItemLowerer<'tcx, 'interner> {
+    pub(super) lctx: &'tcx mut LoweringContext<'interner>,
+}
+
+impl<'tcx, 'interner> ItemLowerer<'tcx, 'interner> {
+    fn with_trait_impl_ref<F>(&mut self, trait_impl_ref: &Option<TraitRef>, f: F)
+    where
+        F: FnOnce(&mut Self),
+    {
+        let old = self.lctx.is_in_trait_impl;
+        self.lctx.is_in_trait_impl = if let &None = trait_impl_ref {
+            false
+        } else {
+            true
+        };
+        f(self);
+        self.lctx.is_in_trait_impl = old;
+    }
+}
+
+impl<'tcx, 'interner> Visitor<'tcx> for ItemLowerer<'tcx, 'interner> {
+    fn visit_mod(&mut self, m: &'tcx Mod, _s: Span, _attrs: &[Attribute], n: NodeId) {
+        self.lctx.modules.insert(n, hir::ModuleItems {
+            items: BTreeSet::new(),
+            trait_items: BTreeSet::new(),
+            impl_items: BTreeSet::new(),
+        });
+
+        let old = self.lctx.current_module;
+        self.lctx.current_module = n;
+        visit::walk_mod(self, m);
+        self.lctx.current_module = old;
+    }
+
+    fn visit_item(&mut self, item: &'tcx Item) {
+        let mut item_hir_id = None;
+        self.lctx.with_hir_id_owner(item.id, |lctx| {
+            if let Some(hir_item) = lctx.lower_item(item) {
+                item_hir_id = Some(hir_item.hir_id);
+                lctx.insert_item(hir_item);
+            }
+        });
+
+        if let Some(hir_id) = item_hir_id {
+            self.lctx.with_parent_item_lifetime_defs(hir_id, |this| {
+                let this = &mut ItemLowerer { lctx: this };
+                if let ItemKind::Impl(.., ref opt_trait_ref, _, _) = item.node {
+                    this.with_trait_impl_ref(opt_trait_ref, |this| {
+                        visit::walk_item(this, item)
+                    });
+                } else {
+                    visit::walk_item(this, item);
+                }
+            });
+        }
+    }
+
+    fn visit_trait_item(&mut self, item: &'tcx TraitItem) {
+        self.lctx.with_hir_id_owner(item.id, |lctx| {
+            let hir_item = lctx.lower_trait_item(item);
+            let id = hir::TraitItemId { hir_id: hir_item.hir_id };
+            lctx.trait_items.insert(id, hir_item);
+            lctx.modules.get_mut(&lctx.current_module).unwrap().trait_items.insert(id);
+        });
+
+        visit::walk_trait_item(self, item);
+    }
+
+    fn visit_impl_item(&mut self, item: &'tcx ImplItem) {
+        self.lctx.with_hir_id_owner(item.id, |lctx| {
+            let hir_item = lctx.lower_impl_item(item);
+            let id = hir::ImplItemId { hir_id: hir_item.hir_id };
+            lctx.impl_items.insert(id, hir_item);
+            lctx.modules.get_mut(&lctx.current_module).unwrap().impl_items.insert(id);
+        });
+        visit::walk_impl_item(self, item);
+    }
+}
+
+impl LoweringContext<'_> {
+    // Same as the method above, but accepts `hir::GenericParam`s
+    // instead of `ast::GenericParam`s.
+    // This should only be used with generics that have already had their
+    // in-band lifetimes added. In practice, this means that this function is
+    // only used when lowering a child item of a trait or impl.
+    fn with_parent_item_lifetime_defs<T>(
+        &mut self,
+        parent_hir_id: hir::HirId,
+        f: impl FnOnce(&mut LoweringContext<'_>) -> T,
+    ) -> T {
+        let old_len = self.in_scope_lifetimes.len();
+
+        let parent_generics = match self.items.get(&parent_hir_id).unwrap().node {
+            hir::ItemKind::Impl(_, _, _, ref generics, ..)
+            | hir::ItemKind::Trait(_, _, ref generics, ..) => {
+                &generics.params[..]
+            }
+            _ => &[],
+        };
+        let lt_def_names = parent_generics.iter().filter_map(|param| match param.kind {
+            hir::GenericParamKind::Lifetime { .. } => Some(param.name.ident().modern()),
+            _ => None,
+        });
+        self.in_scope_lifetimes.extend(lt_def_names);
+
+        let res = f(self);
+
+        self.in_scope_lifetimes.truncate(old_len);
+        res
+    }
+
+    pub(super) fn lower_mod(&mut self, m: &Mod) -> hir::Mod {
+        hir::Mod {
+            inner: m.inner,
+            item_ids: m.items.iter().flat_map(|x| self.lower_item_id(x)).collect(),
+        }
+    }
+
+    pub(super) fn lower_item_id(&mut self, i: &Item) -> SmallVec<[hir::ItemId; 1]> {
+        let node_ids = match i.node {
+            ItemKind::Use(ref use_tree) => {
+                let mut vec = smallvec![i.id];
+                self.lower_item_id_use_tree(use_tree, i.id, &mut vec);
+                vec
+            }
+            ItemKind::MacroDef(..) => SmallVec::new(),
+            ItemKind::Fn(..) |
+            ItemKind::Impl(.., None, _, _) => smallvec![i.id],
+            ItemKind::Static(ref ty, ..) => {
+                let mut ids = smallvec![i.id];
+                if self.sess.features_untracked().impl_trait_in_bindings {
+                    let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
+                    visitor.visit_ty(ty);
+                }
+                ids
+            },
+            ItemKind::Const(ref ty, ..) => {
+                let mut ids = smallvec![i.id];
+                if self.sess.features_untracked().impl_trait_in_bindings {
+                    let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
+                    visitor.visit_ty(ty);
+                }
+                ids
+            },
+            _ => smallvec![i.id],
+        };
+
+        node_ids.into_iter().map(|node_id| hir::ItemId {
+            id: self.allocate_hir_id_counter(node_id)
+        }).collect()
+    }
+
+    fn lower_item_id_use_tree(
+        &mut self,
+        tree: &UseTree,
+        base_id: NodeId,
+        vec: &mut SmallVec<[NodeId; 1]>
+    ) {
+        match tree.kind {
+            UseTreeKind::Nested(ref nested_vec) => for &(ref nested, id) in nested_vec {
+                vec.push(id);
+                self.lower_item_id_use_tree(nested, id, vec);
+            },
+            UseTreeKind::Glob => {}
+            UseTreeKind::Simple(_, id1, id2) => {
+                for (_, &id) in self.expect_full_res_from_use(base_id)
+                                    .skip(1)
+                                    .zip([id1, id2].iter())
+                {
+                    vec.push(id);
+                }
+            },
+        }
+    }
+
+    pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item> {
+        let mut ident = i.ident;
+        let mut vis = self.lower_visibility(&i.vis, None);
+        let mut attrs = self.lower_attrs_extendable(&i.attrs);
+        if self.resolver.has_derives(i.id, SpecialDerives::PARTIAL_EQ | SpecialDerives::EQ) {
+            // Add `#[structural_match]` if the item derived both `PartialEq` and `Eq`.
+            let ident = Ident::new(sym::structural_match, i.span);
+            attrs.push(attr::mk_attr_outer(attr::mk_word_item(ident)));
+        }
+        let attrs = attrs.into();
+
+        if let ItemKind::MacroDef(ref def) = i.node {
+            if !def.legacy || attr::contains_name(&i.attrs, sym::macro_export) {
+                let body = self.lower_token_stream(def.stream());
+                let hir_id = self.lower_node_id(i.id);
+                self.exported_macros.push(hir::MacroDef {
+                    name: ident.name,
+                    vis,
+                    attrs,
+                    hir_id,
+                    span: i.span,
+                    body,
+                    legacy: def.legacy,
+                });
+            } else {
+                self.non_exported_macro_attrs.extend(attrs.into_iter());
+            }
+            return None;
+        }
+
+        let node = self.lower_item_kind(i.id, &mut ident, &attrs, &mut vis, &i.node);
+
+        Some(hir::Item {
+            hir_id: self.lower_node_id(i.id),
+            ident,
+            attrs,
+            node,
+            vis,
+            span: i.span,
+        })
+    }
+
+    fn lower_item_kind(
+        &mut self,
+        id: NodeId,
+        ident: &mut Ident,
+        attrs: &hir::HirVec<Attribute>,
+        vis: &mut hir::Visibility,
+        i: &ItemKind,
+    ) -> hir::ItemKind {
+        match *i {
+            ItemKind::ExternCrate(orig_name) => hir::ItemKind::ExternCrate(orig_name),
+            ItemKind::Use(ref use_tree) => {
+                // Start with an empty prefix.
+                let prefix = Path {
+                    segments: vec![],
+                    span: use_tree.span,
+                };
+
+                self.lower_use_tree(use_tree, &prefix, id, vis, ident, attrs)
+            }
+            ItemKind::Static(ref t, m, ref e) => {
+                hir::ItemKind::Static(
+                    self.lower_ty(
+                        t,
+                        if self.sess.features_untracked().impl_trait_in_bindings {
+                            ImplTraitContext::OpaqueTy(None)
+                        } else {
+                            ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
+                        }
+                    ),
+                    self.lower_mutability(m),
+                    self.lower_const_body(e),
+                )
+            }
+            ItemKind::Const(ref t, ref e) => {
+                hir::ItemKind::Const(
+                    self.lower_ty(
+                        t,
+                        if self.sess.features_untracked().impl_trait_in_bindings {
+                            ImplTraitContext::OpaqueTy(None)
+                        } else {
+                            ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
+                        }
+                    ),
+                    self.lower_const_body(e)
+                )
+            }
+            ItemKind::Fn(ref decl, header, ref generics, ref body) => {
+                let fn_def_id = self.resolver.definitions().local_def_id(id);
+                self.with_new_scopes(|this| {
+                    this.current_item = Some(ident.span);
+
+                    // Note: we don't need to change the return type from `T` to
+                    // `impl Future<Output = T>` here because lower_body
+                    // only cares about the input argument patterns in the function
+                    // declaration (decl), not the return types.
+                    let body_id = this.lower_maybe_async_body(&decl, header.asyncness.node, body);
+
+                    let (generics, fn_decl) = this.add_in_band_defs(
+                        generics,
+                        fn_def_id,
+                        AnonymousLifetimeMode::PassThrough,
+                        |this, idty| this.lower_fn_decl(
+                            &decl,
+                            Some((fn_def_id, idty)),
+                            true,
+                            header.asyncness.node.opt_return_id()
+                        ),
+                    );
+
+                    hir::ItemKind::Fn(
+                        fn_decl,
+                        this.lower_fn_header(header),
+                        generics,
+                        body_id,
+                    )
+                })
+            }
+            ItemKind::Mod(ref m) => hir::ItemKind::Mod(self.lower_mod(m)),
+            ItemKind::ForeignMod(ref nm) => hir::ItemKind::ForeignMod(self.lower_foreign_mod(nm)),
+            ItemKind::GlobalAsm(ref ga) => hir::ItemKind::GlobalAsm(self.lower_global_asm(ga)),
+            ItemKind::TyAlias(ref t, ref generics) => hir::ItemKind::TyAlias(
+                self.lower_ty(t, ImplTraitContext::disallowed()),
+                self.lower_generics(generics, ImplTraitContext::disallowed()),
+            ),
+            ItemKind::OpaqueTy(ref b, ref generics) => hir::ItemKind::OpaqueTy(
+                hir::OpaqueTy {
+                    generics: self.lower_generics(generics,
+                        ImplTraitContext::OpaqueTy(None)),
+                    bounds: self.lower_param_bounds(b,
+                        ImplTraitContext::OpaqueTy(None)),
+                    impl_trait_fn: None,
+                    origin: hir::OpaqueTyOrigin::TypeAlias,
+                },
+            ),
+            ItemKind::Enum(ref enum_definition, ref generics) => {
+                hir::ItemKind::Enum(
+                    hir::EnumDef {
+                        variants: enum_definition
+                            .variants
+                            .iter()
+                            .map(|x| self.lower_variant(x))
+                            .collect(),
+                    },
+                    self.lower_generics(generics, ImplTraitContext::disallowed()),
+                )
+            },
+            ItemKind::Struct(ref struct_def, ref generics) => {
+                let struct_def = self.lower_variant_data(struct_def);
+                hir::ItemKind::Struct(
+                    struct_def,
+                    self.lower_generics(generics, ImplTraitContext::disallowed()),
+                )
+            }
+            ItemKind::Union(ref vdata, ref generics) => {
+                let vdata = self.lower_variant_data(vdata);
+                hir::ItemKind::Union(
+                    vdata,
+                    self.lower_generics(generics, ImplTraitContext::disallowed()),
+                )
+            }
+            ItemKind::Impl(
+                unsafety,
+                polarity,
+                defaultness,
+                ref ast_generics,
+                ref trait_ref,
+                ref ty,
+                ref impl_items,
+            ) => {
+                let def_id = self.resolver.definitions().local_def_id(id);
+
+                // Lower the "impl header" first. This ordering is important
+                // for in-band lifetimes! Consider `'a` here:
+                //
+                //     impl Foo<'a> for u32 {
+                //         fn method(&'a self) { .. }
+                //     }
+                //
+                // Because we start by lowering the `Foo<'a> for u32`
+                // part, we will add `'a` to the list of generics on
+                // the impl. When we then encounter it later in the
+                // method, it will not be considered an in-band
+                // lifetime to be added, but rather a reference to a
+                // parent lifetime.
+                let lowered_trait_impl_id = self.lower_node_id(id);
+                let (generics, (trait_ref, lowered_ty)) = self.add_in_band_defs(
+                    ast_generics,
+                    def_id,
+                    AnonymousLifetimeMode::CreateParameter,
+                    |this, _| {
+                        let trait_ref = trait_ref.as_ref().map(|trait_ref| {
+                            this.lower_trait_ref(trait_ref, ImplTraitContext::disallowed())
+                        });
+
+                        if let Some(ref trait_ref) = trait_ref {
+                            if let Res::Def(DefKind::Trait, def_id) = trait_ref.path.res {
+                                this.trait_impls.entry(def_id).or_default().push(
+                                    lowered_trait_impl_id);
+                            }
+                        }
+
+                        let lowered_ty = this.lower_ty(ty, ImplTraitContext::disallowed());
+
+                        (trait_ref, lowered_ty)
+                    },
+                );
+
+                let new_impl_items = self.with_in_scope_lifetime_defs(
+                    &ast_generics.params,
+                    |this| {
+                        impl_items
+                            .iter()
+                            .map(|item| this.lower_impl_item_ref(item))
+                            .collect()
+                    },
+                );
+
+                hir::ItemKind::Impl(
+                    self.lower_unsafety(unsafety),
+                    self.lower_impl_polarity(polarity),
+                    self.lower_defaultness(defaultness, true /* [1] */),
+                    generics,
+                    trait_ref,
+                    lowered_ty,
+                    new_impl_items,
+                )
+            }
+            ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref items) => {
+                let bounds = self.lower_param_bounds(bounds, ImplTraitContext::disallowed());
+                let items = items
+                    .iter()
+                    .map(|item| self.lower_trait_item_ref(item))
+                    .collect();
+                hir::ItemKind::Trait(
+                    self.lower_is_auto(is_auto),
+                    self.lower_unsafety(unsafety),
+                    self.lower_generics(generics, ImplTraitContext::disallowed()),
+                    bounds,
+                    items,
+                )
+            }
+            ItemKind::TraitAlias(ref generics, ref bounds) => hir::ItemKind::TraitAlias(
+                self.lower_generics(generics, ImplTraitContext::disallowed()),
+                self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
+            ),
+            ItemKind::MacroDef(..)
+            | ItemKind::Mac(..) => bug!("`TyMac` should have been expanded by now"),
+        }
+
+        // [1] `defaultness.has_value()` is never called for an `impl`, always `true` in order to
+        //     not cause an assertion failure inside the `lower_defaultness` function.
+    }
+
+    fn lower_use_tree(
+        &mut self,
+        tree: &UseTree,
+        prefix: &Path,
+        id: NodeId,
+        vis: &mut hir::Visibility,
+        ident: &mut Ident,
+        attrs: &hir::HirVec<Attribute>,
+    ) -> hir::ItemKind {
+        debug!("lower_use_tree(tree={:?})", tree);
+        debug!("lower_use_tree: vis = {:?}", vis);
+
+        let path = &tree.prefix;
+        let segments = prefix
+            .segments
+            .iter()
+            .chain(path.segments.iter())
+            .cloned()
+            .collect();
+
+        match tree.kind {
+            UseTreeKind::Simple(rename, id1, id2) => {
+                *ident = tree.ident();
+
+                // First, apply the prefix to the path.
+                let mut path = Path {
+                    segments,
+                    span: path.span,
+                };
+
+                // Correctly resolve `self` imports.
+                if path.segments.len() > 1
+                    && path.segments.last().unwrap().ident.name == kw::SelfLower
+                {
+                    let _ = path.segments.pop();
+                    if rename.is_none() {
+                        *ident = path.segments.last().unwrap().ident;
+                    }
+                }
+
+                let mut resolutions = self.expect_full_res_from_use(id);
+                // We want to return *something* from this function, so hold onto the first item
+                // for later.
+                let ret_res = self.lower_res(resolutions.next().unwrap_or(Res::Err));
+
+                // Here, we are looping over namespaces, if they exist for the definition
+                // being imported. We only handle type and value namespaces because we
+                // won't be dealing with macros in the rest of the compiler.
+                // Essentially a single `use` which imports two names is desugared into
+                // two imports.
+                for (res, &new_node_id) in resolutions.zip([id1, id2].iter()) {
+                    let ident = *ident;
+                    let mut path = path.clone();
+                    for seg in &mut path.segments {
+                        seg.id = self.sess.next_node_id();
+                    }
+                    let span = path.span;
+
+                    self.with_hir_id_owner(new_node_id, |this| {
+                        let new_id = this.lower_node_id(new_node_id);
+                        let res = this.lower_res(res);
+                        let path =
+                            this.lower_path_extra(res, &path, ParamMode::Explicit, None);
+                        let item = hir::ItemKind::Use(P(path), hir::UseKind::Single);
+                        let vis = this.rebuild_vis(&vis);
+
+                        this.insert_item(
+                            hir::Item {
+                                hir_id: new_id,
+                                ident,
+                                attrs: attrs.into_iter().cloned().collect(),
+                                node: item,
+                                vis,
+                                span,
+                            },
+                        );
+                    });
+                }
+
+                let path =
+                    P(self.lower_path_extra(ret_res, &path, ParamMode::Explicit, None));
+                hir::ItemKind::Use(path, hir::UseKind::Single)
+            }
+            UseTreeKind::Glob => {
+                let path = P(self.lower_path(
+                    id,
+                    &Path {
+                        segments,
+                        span: path.span,
+                    },
+                    ParamMode::Explicit,
+                ));
+                hir::ItemKind::Use(path, hir::UseKind::Glob)
+            }
+            UseTreeKind::Nested(ref trees) => {
+                // Nested imports are desugared into simple imports.
+                // So, if we start with
+                //
+                // ```
+                // pub(x) use foo::{a, b};
+                // ```
+                //
+                // we will create three items:
+                //
+                // ```
+                // pub(x) use foo::a;
+                // pub(x) use foo::b;
+                // pub(x) use foo::{}; // <-- this is called the `ListStem`
+                // ```
+                //
+                // The first two are produced by recursively invoking
+                // `lower_use_tree` (and indeed there may be things
+                // like `use foo::{a::{b, c}}` and so forth).  They
+                // wind up being directly added to
+                // `self.items`. However, the structure of this
+                // function also requires us to return one item, and
+                // for that we return the `{}` import (called the
+                // `ListStem`).
+
+                let prefix = Path {
+                    segments,
+                    span: prefix.span.to(path.span),
+                };
+
+                // Add all the nested `PathListItem`s to the HIR.
+                for &(ref use_tree, id) in trees {
+                    let new_hir_id = self.lower_node_id(id);
+
+                    let mut prefix = prefix.clone();
+
+                    // Give the segments new node-ids since they are being cloned.
+                    for seg in &mut prefix.segments {
+                        seg.id = self.sess.next_node_id();
+                    }
+
+                    // Each `use` import is an item and thus are owners of the
+                    // names in the path. Up to this point the nested import is
+                    // the current owner, since we want each desugared import to
+                    // own its own names, we have to adjust the owner before
+                    // lowering the rest of the import.
+                    self.with_hir_id_owner(id, |this| {
+                        let mut vis = this.rebuild_vis(&vis);
+                        let mut ident = *ident;
+
+                        let item = this.lower_use_tree(use_tree,
+                                                       &prefix,
+                                                       id,
+                                                       &mut vis,
+                                                       &mut ident,
+                                                       attrs);
+
+                        this.insert_item(
+                            hir::Item {
+                                hir_id: new_hir_id,
+                                ident,
+                                attrs: attrs.into_iter().cloned().collect(),
+                                node: item,
+                                vis,
+                                span: use_tree.span,
+                            },
+                        );
+                    });
+                }
+
+                // Subtle and a bit hacky: we lower the privacy level
+                // of the list stem to "private" most of the time, but
+                // not for "restricted" paths. The key thing is that
+                // we don't want it to stay as `pub` (with no caveats)
+                // because that affects rustdoc and also the lints
+                // about `pub` items. But we can't *always* make it
+                // private -- particularly not for restricted paths --
+                // because it contains node-ids that would then be
+                // unused, failing the check that HirIds are "densely
+                // assigned".
+                match vis.node {
+                    hir::VisibilityKind::Public |
+                    hir::VisibilityKind::Crate(_) |
+                    hir::VisibilityKind::Inherited => {
+                        *vis = respan(prefix.span.shrink_to_lo(), hir::VisibilityKind::Inherited);
+                    }
+                    hir::VisibilityKind::Restricted { .. } => {
+                        // Do nothing here, as described in the comment on the match.
+                    }
+                }
+
+                let res = self.expect_full_res_from_use(id).next().unwrap_or(Res::Err);
+                let res = self.lower_res(res);
+                let path = P(self.lower_path_extra(res, &prefix, ParamMode::Explicit, None));
+                hir::ItemKind::Use(path, hir::UseKind::ListStem)
+            }
+        }
+    }
+
+    /// Paths like the visibility path in `pub(super) use foo::{bar, baz}` are repeated
+    /// many times in the HIR tree; for each occurrence, we need to assign distinct
+    /// `NodeId`s. (See, e.g., #56128.)
+    fn rebuild_use_path(&mut self, path: &hir::Path) -> hir::Path {
+        debug!("rebuild_use_path(path = {:?})", path);
+        let segments = path.segments.iter().map(|seg| hir::PathSegment {
+            ident: seg.ident,
+            hir_id: seg.hir_id.map(|_| self.next_id()),
+            res: seg.res,
+            args: None,
+            infer_args: seg.infer_args,
+        }).collect();
+        hir::Path {
+            span: path.span,
+            res: path.res,
+            segments,
+        }
+    }
+
+    fn rebuild_vis(&mut self, vis: &hir::Visibility) -> hir::Visibility {
+        let vis_kind = match vis.node {
+            hir::VisibilityKind::Public => hir::VisibilityKind::Public,
+            hir::VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
+            hir::VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
+            hir::VisibilityKind::Restricted { ref path, hir_id: _ } => {
+                hir::VisibilityKind::Restricted {
+                    path: P(self.rebuild_use_path(path)),
+                    hir_id: self.next_id(),
+                }
+            }
+        };
+        respan(vis.span, vis_kind)
+    }
+
+    fn lower_foreign_item(&mut self, i: &ForeignItem) -> hir::ForeignItem {
+        let def_id = self.resolver.definitions().local_def_id(i.id);
+        hir::ForeignItem {
+            hir_id: self.lower_node_id(i.id),
+            ident: i.ident,
+            attrs: self.lower_attrs(&i.attrs),
+            node: match i.node {
+                ForeignItemKind::Fn(ref fdec, ref generics) => {
+                    let (generics, (fn_dec, fn_args)) = self.add_in_band_defs(
+                        generics,
+                        def_id,
+                        AnonymousLifetimeMode::PassThrough,
+                        |this, _| {
+                            (
+                                // Disallow impl Trait in foreign items
+                                this.lower_fn_decl(fdec, None, false, None),
+                                this.lower_fn_args_to_names(fdec),
+                            )
+                        },
+                    );
+
+                    hir::ForeignItemKind::Fn(fn_dec, fn_args, generics)
+                }
+                ForeignItemKind::Static(ref t, m) => {
+                    hir::ForeignItemKind::Static(
+                        self.lower_ty(t, ImplTraitContext::disallowed()), self.lower_mutability(m))
+                }
+                ForeignItemKind::Ty => hir::ForeignItemKind::Type,
+                ForeignItemKind::Macro(_) => panic!("shouldn't exist here"),
+            },
+            vis: self.lower_visibility(&i.vis, None),
+            span: i.span,
+        }
+    }
+
+    fn lower_foreign_mod(&mut self, fm: &ForeignMod) -> hir::ForeignMod {
+        hir::ForeignMod {
+            abi: fm.abi,
+            items: fm.items
+                .iter()
+                .map(|x| self.lower_foreign_item(x))
+                .collect(),
+        }
+    }
+
+    fn lower_global_asm(&mut self, ga: &GlobalAsm) -> P<hir::GlobalAsm> {
+        P(hir::GlobalAsm {
+            asm: ga.asm,
+            ctxt: ga.ctxt,
+        })
+    }
+
+    fn lower_variant(&mut self, v: &Variant) -> hir::Variant {
+        Spanned {
+            node: hir::VariantKind {
+                ident: v.node.ident,
+                id: self.lower_node_id(v.node.id),
+                attrs: self.lower_attrs(&v.node.attrs),
+                data: self.lower_variant_data(&v.node.data),
+                disr_expr: v.node.disr_expr.as_ref().map(|e| self.lower_anon_const(e)),
+            },
+            span: v.span,
+        }
+    }
+
+    fn lower_variant_data(&mut self, vdata: &VariantData) -> hir::VariantData {
+        match *vdata {
+            VariantData::Struct(ref fields, recovered) => hir::VariantData::Struct(
+                fields.iter().enumerate().map(|f| self.lower_struct_field(f)).collect(),
+                recovered,
+            ),
+            VariantData::Tuple(ref fields, id) => {
+                hir::VariantData::Tuple(
+                    fields
+                        .iter()
+                        .enumerate()
+                        .map(|f| self.lower_struct_field(f))
+                        .collect(),
+                    self.lower_node_id(id),
+                )
+            },
+            VariantData::Unit(id) => {
+                hir::VariantData::Unit(self.lower_node_id(id))
+            },
+        }
+    }
+
+    fn lower_struct_field(&mut self, (index, f): (usize, &StructField)) -> hir::StructField {
+        let ty = if let TyKind::Path(ref qself, ref path) = f.ty.node {
+            let t = self.lower_path_ty(
+                &f.ty,
+                qself,
+                path,
+                ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
+                ImplTraitContext::disallowed()
+            );
+            P(t)
+        } else {
+            self.lower_ty(&f.ty, ImplTraitContext::disallowed())
+        };
+        hir::StructField {
+            span: f.span,
+            hir_id: self.lower_node_id(f.id),
+            ident: match f.ident {
+                Some(ident) => ident,
+                // FIXME(jseyfried): positional field hygiene.
+                None => Ident::new(sym::integer(index), f.span),
+            },
+            vis: self.lower_visibility(&f.vis, None),
+            ty,
+            attrs: self.lower_attrs(&f.attrs),
+        }
+    }
+
+    fn lower_trait_item(&mut self, i: &TraitItem) -> hir::TraitItem {
+        let trait_item_def_id = self.resolver.definitions().local_def_id(i.id);
+
+        let (generics, node) = match i.node {
+            TraitItemKind::Const(ref ty, ref default) => (
+                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
+                hir::TraitItemKind::Const(
+                    self.lower_ty(ty, ImplTraitContext::disallowed()),
+                    default
+                        .as_ref()
+                        .map(|x| self.lower_const_body(x)),
+                ),
+            ),
+            TraitItemKind::Method(ref sig, None) => {
+                let names = self.lower_fn_args_to_names(&sig.decl);
+                let (generics, sig) = self.lower_method_sig(
+                    &i.generics,
+                    sig,
+                    trait_item_def_id,
+                    false,
+                    None,
+                );
+                (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Required(names)))
+            }
+            TraitItemKind::Method(ref sig, Some(ref body)) => {
+                let body_id = self.lower_fn_body_block(&sig.decl, body);
+                let (generics, sig) = self.lower_method_sig(
+                    &i.generics,
+                    sig,
+                    trait_item_def_id,
+                    false,
+                    None,
+                );
+                (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Provided(body_id)))
+            }
+            TraitItemKind::Type(ref bounds, ref default) => {
+                let generics = self.lower_generics(&i.generics, ImplTraitContext::disallowed());
+                let node = hir::TraitItemKind::Type(
+                    self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
+                    default
+                        .as_ref()
+                        .map(|x| self.lower_ty(x, ImplTraitContext::disallowed())),
+                );
+
+                (generics, node)
+            },
+            TraitItemKind::Macro(..) => bug!("macro item shouldn't exist at this point"),
+        };
+
+        hir::TraitItem {
+            hir_id: self.lower_node_id(i.id),
+            ident: i.ident,
+            attrs: self.lower_attrs(&i.attrs),
+            generics,
+            node,
+            span: i.span,
+        }
+    }
+
+    fn lower_trait_item_ref(&mut self, i: &TraitItem) -> hir::TraitItemRef {
+        let (kind, has_default) = match i.node {
+            TraitItemKind::Const(_, ref default) => {
+                (hir::AssocItemKind::Const, default.is_some())
+            }
+            TraitItemKind::Type(_, ref default) => {
+                (hir::AssocItemKind::Type, default.is_some())
+            }
+            TraitItemKind::Method(ref sig, ref default) => (
+                hir::AssocItemKind::Method {
+                    has_self: sig.decl.has_self(),
+                },
+                default.is_some(),
+            ),
+            TraitItemKind::Macro(..) => unimplemented!(),
+        };
+        hir::TraitItemRef {
+            id: hir::TraitItemId { hir_id: self.lower_node_id(i.id) },
+            ident: i.ident,
+            span: i.span,
+            defaultness: self.lower_defaultness(Defaultness::Default, has_default),
+            kind,
+        }
+    }
+
+    fn lower_impl_item(&mut self, i: &ImplItem) -> hir::ImplItem {
+        let impl_item_def_id = self.resolver.definitions().local_def_id(i.id);
+
+        let (generics, node) = match i.node {
+            ImplItemKind::Const(ref ty, ref expr) => (
+                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
+                hir::ImplItemKind::Const(
+                    self.lower_ty(ty, ImplTraitContext::disallowed()),
+                    self.lower_const_body(expr),
+                ),
+            ),
+            ImplItemKind::Method(ref sig, ref body) => {
+                self.current_item = Some(i.span);
+                let body_id = self.lower_maybe_async_body(
+                    &sig.decl, sig.header.asyncness.node, body
+                );
+                let impl_trait_return_allow = !self.is_in_trait_impl;
+                let (generics, sig) = self.lower_method_sig(
+                    &i.generics,
+                    sig,
+                    impl_item_def_id,
+                    impl_trait_return_allow,
+                    sig.header.asyncness.node.opt_return_id(),
+                );
+
+                (generics, hir::ImplItemKind::Method(sig, body_id))
+            }
+            ImplItemKind::TyAlias(ref ty) => (
+                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
+                hir::ImplItemKind::TyAlias(self.lower_ty(ty, ImplTraitContext::disallowed())),
+            ),
+            ImplItemKind::OpaqueTy(ref bounds) => (
+                self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
+                hir::ImplItemKind::OpaqueTy(
+                    self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
+                ),
+            ),
+            ImplItemKind::Macro(..) => bug!("`TyMac` should have been expanded by now"),
+        };
+
+        hir::ImplItem {
+            hir_id: self.lower_node_id(i.id),
+            ident: i.ident,
+            attrs: self.lower_attrs(&i.attrs),
+            generics,
+            vis: self.lower_visibility(&i.vis, None),
+            defaultness: self.lower_defaultness(i.defaultness, true /* [1] */),
+            node,
+            span: i.span,
+        }
+
+        // [1] since `default impl` is not yet implemented, this is always true in impls
+    }
+
+    fn lower_impl_item_ref(&mut self, i: &ImplItem) -> hir::ImplItemRef {
+        hir::ImplItemRef {
+            id: hir::ImplItemId { hir_id: self.lower_node_id(i.id) },
+            ident: i.ident,
+            span: i.span,
+            vis: self.lower_visibility(&i.vis, Some(i.id)),
+            defaultness: self.lower_defaultness(i.defaultness, true /* [1] */),
+            kind: match i.node {
+                ImplItemKind::Const(..) => hir::AssocItemKind::Const,
+                ImplItemKind::TyAlias(..) => hir::AssocItemKind::Type,
+                ImplItemKind::OpaqueTy(..) => hir::AssocItemKind::OpaqueTy,
+                ImplItemKind::Method(ref sig, _) => hir::AssocItemKind::Method {
+                    has_self: sig.decl.has_self(),
+                },
+                ImplItemKind::Macro(..) => unimplemented!(),
+            },
+        }
+
+        // [1] since `default impl` is not yet implemented, this is always true in impls
+    }
+
+    /// If an `explicit_owner` is given, this method allocates the `HirId` in
+    /// the address space of that item instead of the item currently being
+    /// lowered. This can happen during `lower_impl_item_ref()` where we need to
+    /// lower a `Visibility` value although we haven't lowered the owning
+    /// `ImplItem` in question yet.
+    fn lower_visibility(
+        &mut self,
+        v: &Visibility,
+        explicit_owner: Option<NodeId>,
+    ) -> hir::Visibility {
+        let node = match v.node {
+            VisibilityKind::Public => hir::VisibilityKind::Public,
+            VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
+            VisibilityKind::Restricted { ref path, id } => {
+                debug!("lower_visibility: restricted path id = {:?}", id);
+                let lowered_id = if let Some(owner) = explicit_owner {
+                    self.lower_node_id_with_owner(id, owner)
+                } else {
+                    self.lower_node_id(id)
+                };
+                let res = self.expect_full_res(id);
+                let res = self.lower_res(res);
+                hir::VisibilityKind::Restricted {
+                    path: P(self.lower_path_extra(
+                        res,
+                        path,
+                        ParamMode::Explicit,
+                        explicit_owner,
+                    )),
+                    hir_id: lowered_id,
+                }
+            },
+            VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
+        };
+        respan(v.span, node)
+    }
+
+    fn lower_defaultness(&self, d: Defaultness, has_value: bool) -> hir::Defaultness {
+        match d {
+            Defaultness::Default => hir::Defaultness::Default {
+                has_value: has_value,
+            },
+            Defaultness::Final => {
+                assert!(has_value);
+                hir::Defaultness::Final
+            }
+        }
+    }
+
+    fn lower_impl_polarity(&mut self, i: ImplPolarity) -> hir::ImplPolarity {
+        match i {
+            ImplPolarity::Positive => hir::ImplPolarity::Positive,
+            ImplPolarity::Negative => hir::ImplPolarity::Negative,
+        }
+    }
+
+    fn record_body(&mut self, arguments: HirVec<hir::Arg>, value: hir::Expr) -> hir::BodyId {
+        let body = hir::Body {
+            generator_kind: self.generator_kind,
+            arguments,
+            value,
+        };
+        let id = body.id();
+        self.bodies.insert(id, body);
+        id
+    }
+
+    fn lower_body(
+        &mut self,
+        f: impl FnOnce(&mut LoweringContext<'_>) -> (HirVec<hir::Arg>, hir::Expr),
+    ) -> hir::BodyId {
+        let prev_gen_kind = self.generator_kind.take();
+        let (arguments, result) = f(self);
+        let body_id = self.record_body(arguments, result);
+        self.generator_kind = prev_gen_kind;
+        body_id
+    }
+
+    fn lower_arg(&mut self, arg: &Arg) -> hir::Arg {
+        hir::Arg {
+            attrs: self.lower_attrs(&arg.attrs),
+            hir_id: self.lower_node_id(arg.id),
+            pat: self.lower_pat(&arg.pat),
+            span: arg.span,
+        }
+    }
+
+    pub(super) fn lower_fn_body(
+        &mut self,
+        decl: &FnDecl,
+        body: impl FnOnce(&mut LoweringContext<'_>) -> hir::Expr,
+    ) -> hir::BodyId {
+        self.lower_body(|this| (
+            decl.inputs.iter().map(|x| this.lower_arg(x)).collect(),
+            body(this),
+        ))
+    }
+
+    fn lower_fn_body_block(&mut self, decl: &FnDecl, body: &Block) -> hir::BodyId {
+        self.lower_fn_body(decl, |this| {
+            let body = this.lower_block(body, false);
+            this.expr_block(body, ThinVec::new())
+        })
+    }
+
+    pub(super) fn lower_const_body(&mut self, expr: &Expr) -> hir::BodyId {
+        self.lower_body(|this| (hir_vec![], this.lower_expr(expr)))
+    }
+
+    fn lower_maybe_async_body(
+        &mut self,
+        decl: &FnDecl,
+        asyncness: IsAsync,
+        body: &Block,
+    ) -> hir::BodyId {
+        let closure_id = match asyncness {
+            IsAsync::Async { closure_id, .. } => closure_id,
+            IsAsync::NotAsync => return self.lower_fn_body_block(decl, body),
+        };
+
+        self.lower_body(|this| {
+            let mut arguments: Vec<hir::Arg> = Vec::new();
+            let mut statements: Vec<hir::Stmt> = Vec::new();
+
+            // Async function arguments are lowered into the closure body so that they are
+            // captured and so that the drop order matches the equivalent non-async functions.
+            //
+            // from:
+            //
+            //     async fn foo(<pattern>: <ty>, <pattern>: <ty>, <pattern>: <ty>) {
+            //       async move {
+            //       }
+            //     }
+            //
+            // into:
+            //
+            //     fn foo(__arg0: <ty>, __arg1: <ty>, __arg2: <ty>) {
+            //       async move {
+            //         let __arg2 = __arg2;
+            //         let <pattern> = __arg2;
+            //         let __arg1 = __arg1;
+            //         let <pattern> = __arg1;
+            //         let __arg0 = __arg0;
+            //         let <pattern> = __arg0;
+            //       }
+            //     }
+            //
+            // If `<pattern>` is a simple ident, then it is lowered to a single
+            // `let <pattern> = <pattern>;` statement as an optimization.
+            for (index, argument) in decl.inputs.iter().enumerate() {
+                let argument = this.lower_arg(argument);
+                let span = argument.pat.span;
+
+                // Check if this is a binding pattern, if so, we can optimize and avoid adding a
+                // `let <pat> = __argN;` statement. In this case, we do not rename the argument.
+                let (ident, is_simple_argument) = match argument.pat.node {
+                    hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ident, _) =>
+                        (ident, true),
+                    _ => {
+                        // Replace the ident for bindings that aren't simple.
+                        let name = format!("__arg{}", index);
+                        let ident = Ident::from_str(&name);
+
+                        (ident, false)
+                    },
+                };
+
+                let desugared_span =
+                    this.mark_span_with_reason(DesugaringKind::Async, span, None);
+
+                // Construct an argument representing `__argN: <ty>` to replace the argument of the
+                // async function.
+                //
+                // If this is the simple case, this argument will end up being the same as the
+                // original argument, but with a different pattern id.
+                let mut stmt_attrs = ThinVec::new();
+                stmt_attrs.extend(argument.attrs.iter().cloned());
+                let (new_argument_pat, new_argument_id) = this.pat_ident(desugared_span, ident);
+                let new_argument = hir::Arg {
+                    attrs: argument.attrs,
+                    hir_id: argument.hir_id,
+                    pat: new_argument_pat,
+                    span: argument.span,
+                };
+
+
+                if is_simple_argument {
+                    // If this is the simple case, then we only insert one statement that is
+                    // `let <pat> = <pat>;`. We re-use the original argument's pattern so that
+                    // `HirId`s are densely assigned.
+                    let expr = this.expr_ident(desugared_span, ident, new_argument_id);
+                    let stmt = this.stmt_let_pat(
+                        stmt_attrs,
+                        desugared_span,
+                        Some(P(expr)),
+                        argument.pat,
+                        hir::LocalSource::AsyncFn
+                    );
+                    statements.push(stmt);
+                } else {
+                    // If this is not the simple case, then we construct two statements:
+                    //
+                    // ```
+                    // let __argN = __argN;
+                    // let <pat> = __argN;
+                    // ```
+                    //
+                    // The first statement moves the argument into the closure and thus ensures
+                    // that the drop order is correct.
+                    //
+                    // The second statement creates the bindings that the user wrote.
+
+                    // Construct the `let mut __argN = __argN;` statement. It must be a mut binding
+                    // because the user may have specified a `ref mut` binding in the next
+                    // statement.
+                    let (move_pat, move_id) = this.pat_ident_binding_mode(
+                        desugared_span, ident, hir::BindingAnnotation::Mutable);
+                    let move_expr = this.expr_ident(desugared_span, ident, new_argument_id);
+                    let move_stmt = this.stmt_let_pat(
+                        ThinVec::new(),
+                        desugared_span,
+                        Some(P(move_expr)),
+                        move_pat,
+                        hir::LocalSource::AsyncFn
+                    );
+
+                    // Construct the `let <pat> = __argN;` statement. We re-use the original
+                    // argument's pattern so that `HirId`s are densely assigned.
+                    let pattern_expr = this.expr_ident(desugared_span, ident, move_id);
+                    let pattern_stmt = this.stmt_let_pat(
+                        stmt_attrs,
+                        desugared_span,
+                        Some(P(pattern_expr)),
+                        argument.pat,
+                        hir::LocalSource::AsyncFn
+                    );
+
+                    statements.push(move_stmt);
+                    statements.push(pattern_stmt);
+                };
+
+                arguments.push(new_argument);
+            }
+
+            let async_expr = this.make_async_expr(
+                CaptureBy::Value, closure_id, None, body.span,
+                |this| {
+                    let body = this.lower_block_with_stmts(body, false, statements);
+                    this.expr_block(body, ThinVec::new())
+                });
+            (HirVec::from(arguments), this.expr(body.span, async_expr, ThinVec::new()))
+        })
+    }
+
+    fn lower_method_sig(
+        &mut self,
+        generics: &Generics,
+        sig: &MethodSig,
+        fn_def_id: DefId,
+        impl_trait_return_allow: bool,
+        is_async: Option<NodeId>,
+    ) -> (hir::Generics, hir::MethodSig) {
+        let header = self.lower_fn_header(sig.header);
+        let (generics, decl) = self.add_in_band_defs(
+            generics,
+            fn_def_id,
+            AnonymousLifetimeMode::PassThrough,
+            |this, idty| this.lower_fn_decl(
+                &sig.decl,
+                Some((fn_def_id, idty)),
+                impl_trait_return_allow,
+                is_async,
+            ),
+        );
+        (generics, hir::MethodSig { header, decl })
+    }
+
+    fn lower_is_auto(&mut self, a: IsAuto) -> hir::IsAuto {
+        match a {
+            IsAuto::Yes => hir::IsAuto::Yes,
+            IsAuto::No => hir::IsAuto::No,
+        }
+    }
+
+    fn lower_fn_header(&mut self, h: FnHeader) -> hir::FnHeader {
+        hir::FnHeader {
+            unsafety: self.lower_unsafety(h.unsafety),
+            asyncness: self.lower_asyncness(h.asyncness.node),
+            constness: self.lower_constness(h.constness),
+            abi: h.abi,
+        }
+    }
+
+    pub(super) fn lower_unsafety(&mut self, u: Unsafety) -> hir::Unsafety {
+        match u {
+            Unsafety::Unsafe => hir::Unsafety::Unsafe,
+            Unsafety::Normal => hir::Unsafety::Normal,
+        }
+    }
+
+    fn lower_constness(&mut self, c: Spanned<Constness>) -> hir::Constness {
+        match c.node {
+            Constness::Const => hir::Constness::Const,
+            Constness::NotConst => hir::Constness::NotConst,
+        }
+    }
+
+    fn lower_asyncness(&mut self, a: IsAsync) -> hir::IsAsync {
+        match a {
+            IsAsync::Async { .. } => hir::IsAsync::Async,
+            IsAsync::NotAsync => hir::IsAsync::NotAsync,
+        }
+    }
+
+    pub(super) fn lower_generics(
+        &mut self,
+        generics: &Generics,
+        itctx: ImplTraitContext<'_>)
+        -> hir::Generics
+    {
+        // Collect `?Trait` bounds in where clause and move them to parameter definitions.
+        // FIXME: this could probably be done with less rightward drift. It also looks like two
+        // control paths where `report_error` is called are the only paths that advance to after the
+        // match statement, so the error reporting could probably just be moved there.
+        let mut add_bounds: NodeMap<Vec<_>> = Default::default();
+        for pred in &generics.where_clause.predicates {
+            if let WherePredicate::BoundPredicate(ref bound_pred) = *pred {
+                'next_bound: for bound in &bound_pred.bounds {
+                    if let GenericBound::Trait(_, TraitBoundModifier::Maybe) = *bound {
+                        let report_error = |this: &mut Self| {
+                            this.diagnostic().span_err(
+                                bound_pred.bounded_ty.span,
+                                "`?Trait` bounds are only permitted at the \
+                                 point where a type parameter is declared",
+                            );
+                        };
+                        // Check if the where clause type is a plain type parameter.
+                        match bound_pred.bounded_ty.node {
+                            TyKind::Path(None, ref path)
+                                if path.segments.len() == 1
+                                    && bound_pred.bound_generic_params.is_empty() =>
+                            {
+                                if let Some(Res::Def(DefKind::TyParam, def_id)) = self.resolver
+                                    .get_partial_res(bound_pred.bounded_ty.id)
+                                    .map(|d| d.base_res())
+                                {
+                                    if let Some(node_id) =
+                                        self.resolver.definitions().as_local_node_id(def_id)
+                                    {
+                                        for param in &generics.params {
+                                            match param.kind {
+                                                GenericParamKind::Type { .. } => {
+                                                    if node_id == param.id {
+                                                        add_bounds.entry(param.id)
+                                                            .or_default()
+                                                            .push(bound.clone());
+                                                        continue 'next_bound;
+                                                    }
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                }
+                                report_error(self)
+                            }
+                            _ => report_error(self),
+                        }
+                    }
+                }
+            }
+        }
+
+        hir::Generics {
+            params: self.lower_generic_params(&generics.params, &add_bounds, itctx),
+            where_clause: self.lower_where_clause(&generics.where_clause),
+            span: generics.span,
+        }
+    }
+
+    fn lower_where_clause(&mut self, wc: &WhereClause) -> hir::WhereClause {
+        self.with_anonymous_lifetime_mode(
+            AnonymousLifetimeMode::ReportError,
+            |this| {
+                hir::WhereClause {
+                    predicates: wc.predicates
+                        .iter()
+                        .map(|predicate| this.lower_where_predicate(predicate))
+                        .collect(),
+                    span: wc.span,
+                }
+            },
+        )
+    }
+
+    fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicate {
+        match *pred {
+            WherePredicate::BoundPredicate(WhereBoundPredicate {
+                ref bound_generic_params,
+                ref bounded_ty,
+                ref bounds,
+                span,
+            }) => {
+                self.with_in_scope_lifetime_defs(
+                    &bound_generic_params,
+                    |this| {
+                        hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
+                            bound_generic_params: this.lower_generic_params(
+                                bound_generic_params,
+                                &NodeMap::default(),
+                                ImplTraitContext::disallowed(),
+                            ),
+                            bounded_ty: this.lower_ty(bounded_ty, ImplTraitContext::disallowed()),
+                            bounds: bounds
+                                .iter()
+                                .filter_map(|bound| match *bound {
+                                    // Ignore `?Trait` bounds.
+                                    // They were copied into type parameters already.
+                                    GenericBound::Trait(_, TraitBoundModifier::Maybe) => None,
+                                    _ => Some(this.lower_param_bound(
+                                        bound,
+                                        ImplTraitContext::disallowed(),
+                                    )),
+                                })
+                                .collect(),
+                            span,
+                        })
+                    },
+                )
+            }
+            WherePredicate::RegionPredicate(WhereRegionPredicate {
+                ref lifetime,
+                ref bounds,
+                span,
+            }) => hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
+                span,
+                lifetime: self.lower_lifetime(lifetime),
+                bounds: self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
+            }),
+            WherePredicate::EqPredicate(WhereEqPredicate {
+                id,
+                ref lhs_ty,
+                ref rhs_ty,
+                span,
+            }) => {
+                hir::WherePredicate::EqPredicate(hir::WhereEqPredicate {
+                    hir_id: self.lower_node_id(id),
+                    lhs_ty: self.lower_ty(lhs_ty, ImplTraitContext::disallowed()),
+                    rhs_ty: self.lower_ty(rhs_ty, ImplTraitContext::disallowed()),
+                    span,
+                })
+            },
+        }
+    }
+}