Auto merge of #51815 - oli-obk:lowering_cleanups2, r=nikomatsakis
Lowering cleanups [2/N] Double indirections are unnecessary
This commit is contained in:
commit
971f7d34d4
6 changed files with 32 additions and 28 deletions
|
@ -1074,11 +1074,15 @@ impl<'a> LoweringContext<'a> {
|
|||
-> hir::GenericArg {
|
||||
match arg {
|
||||
ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(<)),
|
||||
ast::GenericArg::Type(ty) => GenericArg::Type(self.lower_ty(&ty, itctx)),
|
||||
ast::GenericArg::Type(ty) => GenericArg::Type(self.lower_ty_direct(&ty, itctx)),
|
||||
}
|
||||
}
|
||||
|
||||
fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> P<hir::Ty> {
|
||||
P(self.lower_ty_direct(t, itctx))
|
||||
}
|
||||
|
||||
fn lower_ty_direct(&mut self, t: &Ty, itctx: ImplTraitContext) -> hir::Ty {
|
||||
let kind = match t.node {
|
||||
TyKind::Infer => hir::TyInfer,
|
||||
TyKind::Err => hir::TyErr,
|
||||
|
@ -1115,10 +1119,10 @@ impl<'a> LoweringContext<'a> {
|
|||
),
|
||||
TyKind::Never => hir::TyNever,
|
||||
TyKind::Tup(ref tys) => {
|
||||
hir::TyTup(tys.iter().map(|ty| self.lower_ty(ty, itctx)).collect())
|
||||
hir::TyTup(tys.iter().map(|ty| self.lower_ty_direct(ty, itctx)).collect())
|
||||
}
|
||||
TyKind::Paren(ref ty) => {
|
||||
return self.lower_ty(ty, itctx);
|
||||
return self.lower_ty_direct(ty, itctx);
|
||||
}
|
||||
TyKind::Path(ref qself, ref path) => {
|
||||
let id = self.lower_node_id(t.id);
|
||||
|
@ -1228,12 +1232,12 @@ impl<'a> LoweringContext<'a> {
|
|||
};
|
||||
|
||||
let LoweredNodeId { node_id, hir_id } = self.lower_node_id(t.id);
|
||||
P(hir::Ty {
|
||||
hir::Ty {
|
||||
id: node_id,
|
||||
node: kind,
|
||||
span: t.span,
|
||||
hir_id,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn lower_existential_impl_trait(
|
||||
|
@ -1636,7 +1640,7 @@ impl<'a> LoweringContext<'a> {
|
|||
// e.g. `Vec` in `Vec::new` or `<I as Iterator>::Item` in
|
||||
// `<I as Iterator>::Item::default`.
|
||||
let new_id = self.next_id();
|
||||
self.ty_path(new_id, p.span, hir::QPath::Resolved(qself, path))
|
||||
P(self.ty_path(new_id, p.span, hir::QPath::Resolved(qself, path)))
|
||||
};
|
||||
|
||||
// Anything after the base path are associated "extensions",
|
||||
|
@ -1667,7 +1671,7 @@ impl<'a> LoweringContext<'a> {
|
|||
|
||||
// Wrap the associated extension in another type node.
|
||||
let new_id = self.next_id();
|
||||
ty = self.ty_path(new_id, p.span, qpath);
|
||||
ty = P(self.ty_path(new_id, p.span, qpath));
|
||||
}
|
||||
|
||||
// Should've returned in the for loop above.
|
||||
|
@ -1802,10 +1806,10 @@ impl<'a> LoweringContext<'a> {
|
|||
|this| {
|
||||
const DISALLOWED: ImplTraitContext = ImplTraitContext::Disallowed;
|
||||
let &ParenthesisedArgs { ref inputs, ref output, span } = data;
|
||||
let inputs = inputs.iter().map(|ty| this.lower_ty(ty, DISALLOWED)).collect();
|
||||
let inputs = inputs.iter().map(|ty| this.lower_ty_direct(ty, DISALLOWED)).collect();
|
||||
let mk_tup = |this: &mut Self, tys, span| {
|
||||
let LoweredNodeId { node_id, hir_id } = this.next_id();
|
||||
P(hir::Ty { node: hir::TyTup(tys), id: node_id, hir_id, span })
|
||||
hir::Ty { node: hir::TyTup(tys), id: node_id, hir_id, span }
|
||||
};
|
||||
|
||||
(
|
||||
|
@ -1818,7 +1822,7 @@ impl<'a> LoweringContext<'a> {
|
|||
ty: output
|
||||
.as_ref()
|
||||
.map(|ty| this.lower_ty(&ty, DISALLOWED))
|
||||
.unwrap_or_else(|| mk_tup(this, hir::HirVec::new(), span)),
|
||||
.unwrap_or_else(|| P(mk_tup(this, hir::HirVec::new(), span))),
|
||||
span: output.as_ref().map_or(span, |ty| ty.span),
|
||||
}
|
||||
],
|
||||
|
@ -1894,9 +1898,9 @@ impl<'a> LoweringContext<'a> {
|
|||
.iter()
|
||||
.map(|arg| {
|
||||
if let Some(def_id) = fn_def_id {
|
||||
self.lower_ty(&arg.ty, ImplTraitContext::Universal(def_id))
|
||||
self.lower_ty_direct(&arg.ty, ImplTraitContext::Universal(def_id))
|
||||
} else {
|
||||
self.lower_ty(&arg.ty, ImplTraitContext::Disallowed)
|
||||
self.lower_ty_direct(&arg.ty, ImplTraitContext::Disallowed)
|
||||
}
|
||||
})
|
||||
.collect::<HirVec<_>>();
|
||||
|
@ -1936,7 +1940,7 @@ impl<'a> LoweringContext<'a> {
|
|||
// fn_def_id: DefId of the parent function. Used to create child impl trait definition.
|
||||
fn lower_async_fn_ret_ty(
|
||||
&mut self,
|
||||
inputs: &[P<hir::Ty>],
|
||||
inputs: &[hir::Ty],
|
||||
output: &FunctionRetTy,
|
||||
fn_def_id: DefId,
|
||||
) -> hir::FunctionRetTy {
|
||||
|
@ -3661,7 +3665,7 @@ impl<'a> LoweringContext<'a> {
|
|||
let e1 = self.lower_expr(e1);
|
||||
let e2 = self.lower_expr(e2);
|
||||
let ty_path = P(self.std_path(span, &["ops", "RangeInclusive"], None, false));
|
||||
let ty = self.ty_path(id, span, hir::QPath::Resolved(None, ty_path));
|
||||
let ty = P(self.ty_path(id, span, hir::QPath::Resolved(None, ty_path)));
|
||||
let new_seg = P(hir::PathSegment::from_name(Symbol::intern("new")));
|
||||
let new_path = hir::QPath::TypeRelative(ty, new_seg);
|
||||
let new = P(self.expr(span, hir::ExprPath(new_path), ThinVec::new()));
|
||||
|
@ -4549,7 +4553,7 @@ impl<'a> LoweringContext<'a> {
|
|||
.resolve_str_path(span, self.crate_root, components, params, is_value)
|
||||
}
|
||||
|
||||
fn ty_path(&mut self, id: LoweredNodeId, span: Span, qpath: hir::QPath) -> P<hir::Ty> {
|
||||
fn ty_path(&mut self, id: LoweredNodeId, span: Span, qpath: hir::QPath) -> hir::Ty {
|
||||
let mut id = id;
|
||||
let node = match qpath {
|
||||
hir::QPath::Resolved(None, path) => {
|
||||
|
@ -4574,12 +4578,12 @@ impl<'a> LoweringContext<'a> {
|
|||
}
|
||||
_ => hir::TyPath(qpath),
|
||||
};
|
||||
P(hir::Ty {
|
||||
hir::Ty {
|
||||
id: id.node_id,
|
||||
hir_id: id.hir_id,
|
||||
node,
|
||||
span,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Invoked to create the lifetime argument for a type `&T`
|
||||
|
|
|
@ -383,7 +383,7 @@ impl PathSegment {
|
|||
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
|
||||
pub enum GenericArg {
|
||||
Lifetime(Lifetime),
|
||||
Type(P<Ty>),
|
||||
Type(Ty),
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
|
||||
|
@ -412,7 +412,7 @@ impl GenericArgs {
|
|||
self.args.is_empty() && self.bindings.is_empty() && !self.parenthesized
|
||||
}
|
||||
|
||||
pub fn inputs(&self) -> &[P<Ty>] {
|
||||
pub fn inputs(&self) -> &[Ty] {
|
||||
if self.parenthesized {
|
||||
for arg in &self.args {
|
||||
match arg {
|
||||
|
@ -1658,7 +1658,7 @@ pub enum Ty_ {
|
|||
/// The never type (`!`)
|
||||
TyNever,
|
||||
/// A tuple (`(A, B, C, D,...)`)
|
||||
TyTup(HirVec<P<Ty>>),
|
||||
TyTup(HirVec<Ty>),
|
||||
/// A path to a type definition (`module::module::...::Type`), or an
|
||||
/// associated type, e.g. `<Vec<T> as Trait>::Type` or `<T>::Target`.
|
||||
///
|
||||
|
@ -1719,7 +1719,7 @@ pub struct Arg {
|
|||
/// Represents the header (not the body) of a function declaration
|
||||
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
|
||||
pub struct FnDecl {
|
||||
pub inputs: HirVec<P<Ty>>,
|
||||
pub inputs: HirVec<Ty>,
|
||||
pub output: FunctionRetTy,
|
||||
pub variadic: bool,
|
||||
/// True if this function has an `self`, `&self` or `&mut self` receiver
|
||||
|
|
|
@ -1792,7 +1792,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
|
|||
|
||||
fn visit_fn_like_elision(
|
||||
&mut self,
|
||||
inputs: &'tcx [P<hir::Ty>],
|
||||
inputs: &'tcx [hir::Ty],
|
||||
output: Option<&'tcx P<hir::Ty>>,
|
||||
) {
|
||||
debug!("visit_fn_like_elision: enter");
|
||||
|
|
|
@ -963,7 +963,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
|||
..
|
||||
}) => {
|
||||
(self.tcx.sess.codemap().def_span(span), decl.inputs.iter()
|
||||
.map(|arg| match arg.clone().into_inner().node {
|
||||
.map(|arg| match arg.clone().node {
|
||||
hir::TyTup(ref tys) => ArgKind::Tuple(
|
||||
Some(arg.span),
|
||||
tys.iter()
|
||||
|
|
|
@ -263,7 +263,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
|
|||
}));
|
||||
}
|
||||
ty::GenericParamDefKind::Type {..} => {
|
||||
args.push(hir::GenericArg::Type(P(self.ty_param_to_ty(param.clone()))));
|
||||
args.push(hir::GenericArg::Type(self.ty_param_to_ty(param.clone())));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -2150,7 +2150,7 @@ pub struct Arguments {
|
|||
pub values: Vec<Argument>,
|
||||
}
|
||||
|
||||
impl<'a> Clean<Arguments> for (&'a [P<hir::Ty>], &'a [Spanned<ast::Name>]) {
|
||||
impl<'a> Clean<Arguments> for (&'a [hir::Ty], &'a [Spanned<ast::Name>]) {
|
||||
fn clean(&self, cx: &DocContext) -> Arguments {
|
||||
Arguments {
|
||||
values: self.0.iter().enumerate().map(|(i, ty)| {
|
||||
|
@ -2168,7 +2168,7 @@ impl<'a> Clean<Arguments> for (&'a [P<hir::Ty>], &'a [Spanned<ast::Name>]) {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a> Clean<Arguments> for (&'a [P<hir::Ty>], hir::BodyId) {
|
||||
impl<'a> Clean<Arguments> for (&'a [hir::Ty], hir::BodyId) {
|
||||
fn clean(&self, cx: &DocContext) -> Arguments {
|
||||
let body = cx.tcx.hir.body(self.1);
|
||||
|
||||
|
@ -2184,7 +2184,7 @@ impl<'a> Clean<Arguments> for (&'a [P<hir::Ty>], hir::BodyId) {
|
|||
}
|
||||
|
||||
impl<'a, A: Copy> Clean<FnDecl> for (&'a hir::FnDecl, A)
|
||||
where (&'a [P<hir::Ty>], A): Clean<Arguments>
|
||||
where (&'a [hir::Ty], A): Clean<Arguments>
|
||||
{
|
||||
fn clean(&self, cx: &DocContext) -> FnDecl {
|
||||
FnDecl {
|
||||
|
@ -2926,7 +2926,7 @@ impl Clean<Type> for hir::Ty {
|
|||
}
|
||||
});
|
||||
if let Some(ty) = type_.cloned() {
|
||||
ty_substs.insert(ty_param_def, ty.into_inner().clean(cx));
|
||||
ty_substs.insert(ty_param_def, ty.clean(cx));
|
||||
} else if let Some(default) = default.clone() {
|
||||
ty_substs.insert(ty_param_def,
|
||||
default.into_inner().clean(cx));
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue