reset the "anonymous lifetime mode" for parenthesized where clauses

Background:

The anonymous lifetime mode is used to prohibit elided lifetimes where
they didn't used to be permitted, and instead require that `'_` be
used. For example:

```rust
impl Trait for Ref<T> { .. }
//             ^^^^^^ ERROR: should be `Ref<'_, T>`
```

When we are parsing the parts of the impl header, we enter into an
alternate mode called `CreateParameter`. In this mode, we give an
error for things like `Ref<T>`, but for elided lifetimes in a
reference type like `&T` we make the elided lifetime into an in-band
lifetime:

https://github.com/rust-lang/rust/blob/4f99f37b7e213d69a489884f651adfc6d217cef5/src/librustc/hir/lowering.rs#L4017-L4035

This was not intended to change behavior because we only enter into
that mode in contexts where elision was not historically
permitted. However, the problem is that we fail to reset the mode when
we enter into bounds like `Fn(&u32)`, where elision *was* allowed --
the same occurs for fn types like `fn(&u32`). This PR restores the
original mode in those contexts.

Author: nikomatsakis

src/librustc/hir/lowering.rs

@@ -594,6 +594,18 @@ impl<'a> LoweringContext<'a> {
         span.with_ctxt(SyntaxContext::empty().apply_mark(mark))
     }
 
+    fn with_anonymous_lifetime_mode<R>(
+        &mut self,
+        anonymous_lifetime_mode: AnonymousLifetimeMode,
+        op: impl FnOnce(&mut Self) -> R,
+    ) -> R {
+        let old_anonymous_lifetime_mode = self.anonymous_lifetime_mode;
+        self.anonymous_lifetime_mode = anonymous_lifetime_mode;
+        let result = op(self);
+        self.anonymous_lifetime_mode = old_anonymous_lifetime_mode;
+        result
+    }
+
     /// Creates a new hir::GenericParam for every new lifetime and
     /// type parameter encountered while evaluating `f`. Definitions
     /// are created with the parent provided. If no `parent_id` is
@@ -1620,44 +1632,54 @@ impl<'a> LoweringContext<'a> {
         &mut self,
         data: &ParenthesizedParameterData,
     ) -> (hir::PathParameters, bool) {
-        const DISALLOWED: ImplTraitContext = ImplTraitContext::Disallowed;
-        let &ParenthesizedParameterData {
-            ref inputs,
-            ref output,
-            span,
-        } = data;
-        let inputs = inputs
-            .iter()
-            .map(|ty| self.lower_ty(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,
-            })
-        };
+        // Switch to `PassThrough` mode for anonymous lifetimes: this
+        // means that we permit things like `&Ref<T>`, where `Ref` has
+        // a hidden lifetime parameter. This is needed for backwards
+        // compatibility, even in contexts like an impl header where
+        // we generally don't permit such things (see #51008).
+        self.with_anonymous_lifetime_mode(
+            AnonymousLifetimeMode::PassThrough,
+            |this| {
+                const DISALLOWED: ImplTraitContext = ImplTraitContext::Disallowed;
+                let &ParenthesizedParameterData {
+                    ref inputs,
+                    ref output,
+                    span,
+                } = data;
+                let inputs = inputs
+                    .iter()
+                    .map(|ty| this.lower_ty(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::PathParameters {
-                lifetimes: hir::HirVec::new(),
-                types: hir_vec![mk_tup(self, inputs, span)],
-                bindings: hir_vec![
-                    hir::TypeBinding {
-                        id: self.next_id().node_id,
-                        name: Symbol::intern(FN_OUTPUT_NAME),
-                        ty: output
-                            .as_ref()
-                            .map(|ty| self.lower_ty(&ty, DISALLOWED))
-                            .unwrap_or_else(|| mk_tup(self, hir::HirVec::new(), span)),
-                        span: output.as_ref().map_or(span, |ty| ty.span),
-                    }
-                ],
-                parenthesized: true,
-            },
-            false,
+                (
+                    hir::PathParameters {
+                        lifetimes: hir::HirVec::new(),
+                        types: hir_vec![mk_tup(this, inputs, span)],
+                        bindings: hir_vec![
+                            hir::TypeBinding {
+                                id: this.next_id().node_id,
+                                name: Symbol::intern(FN_OUTPUT_NAME),
+                                ty: output
+                                    .as_ref()
+                                    .map(|ty| this.lower_ty(&ty, DISALLOWED))
+                                    .unwrap_or_else(|| mk_tup(this, hir::HirVec::new(), span)),
+                                span: output.as_ref().map_or(span, |ty| ty.span),
+                            }
+                        ],
+                        parenthesized: true,
+                    },
+                    false,
+                )
+            }
         )
     }
 

src/librustc/middle/resolve_lifetime.rs

@@ -101,6 +101,13 @@ impl Region {
         let depth = ty::DebruijnIndex::INNERMOST;
         let def_id = hir_map.local_def_id(def.lifetime.id);
         let origin = LifetimeDefOrigin::from_is_in_band(def.in_band);
+        debug!(
+            "Region::late: def={:?} depth={:?} def_id={:?} origin={:?}",
+            def,
+            depth,
+            def_id,
+            origin,
+        );
         (def.lifetime.name, Region::LateBound(depth, def_id, origin))
     }
 

src/test/ui/rust-2018/issue-51008.rs

@@ -0,0 +1,25 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Regression test for #51008 -- the anonymous lifetime in `&i32` was
+// being incorrectly considered part of the "elided lifetimes" from
+// the impl.
+//
+// run-pass
+
+#![feature(rust_2018_preview)]
+
+trait A {
+
+}
+
+impl<F> A for F where F: FnOnce(&i32) {}
+
+fn main() {}