Lower impl Trait types in locals.

Author: Alexander Regueiro

src/librustc/diagnostics.rs

@@ -1739,7 +1739,7 @@ specified exit code, use `std::process::exit`.
 
 E0562: r##"
 Abstract return types (written `impl Trait` for some trait `Trait`) are only
-allowed as function return types.
+allowed as function and inherent impl return types or binding types.
 
 Erroneous code example:
 
@@ -1754,7 +1754,8 @@ fn main() {
 }
 ```
 
-Make sure `impl Trait` only appears in return-type position.
+Make sure `impl Trait` only appears in return-type position or as the type of a
+binding.
 
 ```
 fn count_to_n(n: usize) -> impl Iterator<Item=usize> {

src/librustc/hir/def_id.rs

@@ -131,7 +131,6 @@ pub struct DefIndex(u32);
 /// thanks to `NodeCollector::new`.
 pub const CRATE_DEF_INDEX: DefIndex = DefIndex(0);
 
-
 impl fmt::Debug for DefIndex {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f,

src/librustc/hir/lowering.rs

@@ -102,9 +102,9 @@ impl<'a> DefCollector<'a> {
             visit::walk_fn_decl(this, decl);
 
             let closure_def = this.create_def(closure_id,
-                                  DefPathData::ClosureExpr,
-                                  REGULAR_SPACE,
-                                  span);
+                                              DefPathData::ClosureExpr,
+                                              REGULAR_SPACE,
+                                              span);
             this.with_parent(closure_def, |this| {
                 visit::walk_block(this, body);
             })

src/librustc/hir/map/def_collector.rs

@@ -736,7 +736,7 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
 
                         debug!(
                             "instantiate_opaque_types_in_map: \
-                             encountered opaque outside it's definition scope \
+                             encountered opaque outside its definition scope \
                              def_id={:?}",
                             def_id,
                         );
@@ -808,8 +808,8 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
 
         for predicate in bounds.predicates {
             // Change the predicate to refer to the type variable,
-            // which will be the concrete type, instead of the Opaque.
-            // This also instantiates nested `impl Trait`.
+            // which will be the concrete type instead of the opaque type.
+            // This also instantiates nested instances of `impl Trait`.
             let predicate = self.instantiate_opaque_types_in_map(&predicate);
 
             let cause = traits::ObligationCause::new(span, self.body_id, traits::SizedReturnType);

src/librustc/infer/opaque_types/mod.rs

@@ -79,8 +79,8 @@ impl BoundRegion {
     }
 }
 
-/// NB: If you change this, you'll probably want to change the corresponding
-/// AST structure in libsyntax/ast.rs as well.
+/// N.B., If you change this, you'll probably want to change the corresponding
+/// AST structure in `libsyntax/ast.rs` as well.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
 pub enum TyKind<'tcx> {
     /// The primitive boolean type. Written as `bool`.
@@ -158,7 +158,7 @@ pub enum TyKind<'tcx> {
     Projection(ProjectionTy<'tcx>),
 
     /// Opaque (`impl Trait`) type found in a return type.
-    /// The DefId comes either from
+    /// The `DefId` comes either from
     /// * the `impl Trait` ast::Ty node,
     /// * or the `existential type` declaration
     /// The substitutions are for the generics of the function in question.
@@ -168,7 +168,7 @@ pub enum TyKind<'tcx> {
     /// A type parameter; for example, `T` in `fn f<T>(x: T) {}
     Param(ParamTy),
 
-    /// A type variable used during type-checking.
+    /// A type variable used during type checking.
     Infer(InferTy),
 
     /// A placeholder for a type which could not be computed; this is

src/librustc/ty/sty.rs

@@ -14,7 +14,7 @@
 //! are supplied to us before normalization and may contain existential
 //! `impl Trait` instances. In contrast, the input/output types found in
 //! the MIR (specifically, in the special local variables for the
-//! `RETURN_PLACE` the MIR arguments) are always fully normalize (and
+//! `RETURN_PLACE` the MIR arguments) are always fully normalized (and
 //! contain revealed `impl Trait` values).
 
 use borrow_check::nll::renumber;

src/librustc_mir/borrow_check/nll/type_check/input_output.rs

@@ -98,7 +98,7 @@ mod relate_tys;
 ///   to outlive; should represent the fn body
 /// - `input_tys` -- fully liberated, but **not** normalized, expected types of the arguments;
 ///   the types of the input parameters found in the MIR itself will be equated with these
-/// - `output_ty` -- fully liberaetd, but **not** normalized, expected return type;
+/// - `output_ty` -- fully liberated, but **not** normalized, expected return type;
 ///   the type for the RETURN_PLACE will be equated with this
 /// - `liveness` -- results of a liveness computation on the MIR; used to create liveness
 ///   constraints for the regions in the types of variables

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -235,7 +235,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     .pat_binding_modes_mut()
                     .insert(pat.hir_id, bm);
                 debug!("check_pat_walk: pat.hir_id={:?} bm={:?}", pat.hir_id, bm);
-                let typ = self.local_ty(pat.span, pat.id);
+                let local_ty = self.local_ty(pat.span, pat.id).decl_ty;
                 match bm {
                     ty::BindByReference(mutbl) => {
                         // if the binding is like
@@ -249,28 +249,28 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                         // `x` is assigned a value of type `&M T`, hence `&M T <: typeof(x)` is
                         // required. However, we use equality, which is stronger. See (*) for
                         // an explanation.
-                        self.demand_eqtype(pat.span, region_ty, typ);
+                        self.demand_eqtype(pat.span, region_ty, local_ty);
                     }
                     // otherwise the type of x is the expected type T
                     ty::BindByValue(_) => {
                         // As above, `T <: typeof(x)` is required but we
                         // use equality, see (*) below.
-                        self.demand_eqtype(pat.span, expected, typ);
+                        self.demand_eqtype(pat.span, expected, local_ty);
                     }
                 }
 
                 // if there are multiple arms, make sure they all agree on
                 // what the type of the binding `x` ought to be
                 if var_id != pat.id {
-                    let vt = self.local_ty(pat.span, var_id);
-                    self.demand_eqtype(pat.span, vt, typ);
+                    let vt = self.local_ty(pat.span, var_id).decl_ty;
+                    self.demand_eqtype(pat.span, vt, local_ty);
                 }
 
                 if let Some(ref p) = *sub {
                     self.check_pat_walk(&p, expected, def_bm, true);
                 }
 
-                typ
+                local_ty
             }
             PatKind::TupleStruct(ref qpath, ref subpats, ddpos) => {
                 self.check_pat_tuple_struct(pat, qpath, &subpats, ddpos, expected, def_bm)

src/librustc_typeck/check/_match.rs

@@ -1039,8 +1039,8 @@ impl<'gcx, 'tcx, 'exprs, E> CoerceMany<'gcx, 'tcx, 'exprs, E>
     }
 
     /// Indicates that the value generated by `expression`, which is
-    /// of type `expression_ty`, is one of the possibility that we
-    /// could coerce from. This will record `expression` and later
+    /// of type `expression_ty`, is one of the possibilities that we
+    /// could coerce from. This will record `expression`, and later
     /// calls to `coerce` may come back and add adjustments and things
     /// if necessary.
     pub fn coerce<'a>(&mut self,