From 9acb351f5756b58b053ca9b834664da971ac52f2 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 30 May 2018 10:27:53 -0400 Subject: [PATCH 1/2] 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 { .. } // ^^^^^^ 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`, 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. --- src/librustc/hir/lowering.rs | 96 +++++++++++++++---------- src/librustc/middle/resolve_lifetime.rs | 7 ++ src/test/ui/rust-2018/issue-51008.rs | 25 +++++++ 3 files changed, 91 insertions(+), 37 deletions(-) create mode 100644 src/test/ui/rust-2018/issue-51008.rs diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index f24a803bac317..7d88468c3dd78 100644 --- a/src/librustc/hir/lowering.rs +++ b/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( + &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`, 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, + ) + } ) } diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 53d51d9429fb5..2da99b35929a1 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/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)) } diff --git a/src/test/ui/rust-2018/issue-51008.rs b/src/test/ui/rust-2018/issue-51008.rs new file mode 100644 index 0000000000000..eb2673857e2f4 --- /dev/null +++ b/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 or the MIT license +// , 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 A for F where F: FnOnce(&i32) {} + +fn main() {} From da69bbce68b8c477701a07ed8fcf0c9d29e74c42 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 30 May 2018 10:40:42 -0400 Subject: [PATCH 2/2] also reset anon-param-mode for `fn()` types --- src/librustc/hir/lowering.rs | 27 +++++++++++++++----------- src/test/ui/rust-2018/issue-51008-1.rs | 25 ++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 11 deletions(-) create mode 100644 src/test/ui/rust-2018/issue-51008-1.rs diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 7d88468c3dd78..6dd339ccdcc6b 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -1033,17 +1033,22 @@ impl<'a> LoweringContext<'a> { _ => None, }), |this| { - hir::TyBareFn(P(hir::BareFnTy { - generic_params: this.lower_generic_params( - &f.generic_params, - &NodeMap(), - ImplTraitContext::Disallowed, - ), - unsafety: this.lower_unsafety(f.unsafety), - abi: f.abi, - decl: this.lower_fn_decl(&f.decl, None, false), - arg_names: this.lower_fn_args_to_names(&f.decl), - })) + this.with_anonymous_lifetime_mode( + AnonymousLifetimeMode::PassThrough, + |this| { + hir::TyBareFn(P(hir::BareFnTy { + generic_params: this.lower_generic_params( + &f.generic_params, + &NodeMap(), + ImplTraitContext::Disallowed, + ), + unsafety: this.lower_unsafety(f.unsafety), + abi: f.abi, + decl: this.lower_fn_decl(&f.decl, None, false), + arg_names: this.lower_fn_args_to_names(&f.decl), + })) + }, + ) }, ), TyKind::Never => hir::TyNever, diff --git a/src/test/ui/rust-2018/issue-51008-1.rs b/src/test/ui/rust-2018/issue-51008-1.rs new file mode 100644 index 0000000000000..4a76d683d6e50 --- /dev/null +++ b/src/test/ui/rust-2018/issue-51008-1.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 or the MIT license +// , 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 A for F where F: PartialEq { } + +fn main() {}