bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #51815 - oli-obk:lowering_cleanups2, r=nikomatsakis

Browse source 
Lowering cleanups [2/N]

Double indirections are unnecessary
This commit is contained in:
bors 2018-06-27 07:16:13 +00:00
commit 971f7d34d4
6 changed files with 32 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

38
src/librustc/hir/lowering.rs
View file

@ -1074,11 +1074,15 @@ impl<'a> LoweringContext<'a> {
-> hir::GenericArg {
match arg {
ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(&lt)),
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`

8
src/librustc/hir/mod.rs
View file

@ -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

2
src/librustc/middle/resolve_lifetime.rs
View file

@ -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");

2
src/librustc/traits/error_reporting.rs
View file

@ -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()

2
src/librustdoc/clean/auto_trait.rs
View file

@ -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())));
}
}
}

8
src/librustdoc/clean/mod.rs
View file

@ -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));