Ban in-band in fn-syntax on AST.

Author: cjgillot

compiler/rustc_resolve/src/late.rs

@@ -248,6 +248,7 @@ enum LifetimeRibKind {
 #[derive(Copy, Clone, Debug)]
 enum LifetimeBinderKind {
     BareFnType,
+    FnTrait,
     PolyTrait,
     WhereBound,
     Item,
@@ -260,6 +261,7 @@ impl LifetimeBinderKind {
         use LifetimeBinderKind::*;
         match self {
             BareFnType => "type",
+            FnTrait => "bound",
             PolyTrait => "bound",
             WhereBound => "bound",
             Item => "item",
@@ -271,15 +273,15 @@ impl LifetimeBinderKind {
     fn allow_in_band(self) -> bool {
         use LifetimeBinderKind::*;
         match self {
-            BareFnType | PolyTrait | WhereBound | Item => false,
+            BareFnType | FnTrait | PolyTrait | WhereBound | Item => false,
             Function | ImplBlock => true,
         }
     }
 
     fn transparent_in_band(self) -> bool {
         use LifetimeBinderKind::*;
         match self {
-            BareFnType | Function | ImplBlock => false,
+            BareFnType | Function | FnTrait | ImplBlock => false,
             _ => true,
         }
     }
@@ -856,9 +858,18 @@ impl<'a: 'ast, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
         if let Some(ref args) = path_segment.args {
             match &**args {
                 GenericArgs::AngleBracketed(..) => visit::walk_generic_args(self, path_span, args),
-                GenericArgs::Parenthesized(..) => self.with_lifetime_rib(
+                GenericArgs::Parenthesized(data) => self.with_lifetime_rib(
                     LifetimeRibKind::AnonymousPassThrough(path_segment.id),
-                    |this| visit::walk_generic_args(this, path_span, args),
+                    |this| {
+                        this.with_lifetime_rib(
+                            LifetimeRibKind::Generics {
+                                parent: path_segment.id,
+                                kind: LifetimeBinderKind::FnTrait,
+                                span: data.span,
+                            },
+                            |this| visit::walk_generic_args(this, path_span, args),
+                        )
+                    },
                 ),
             }
         }
@@ -1214,6 +1225,28 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                     self.r.lifetimes_res_map.insert(lifetime.id, region);
                     return;
                 }
+                LifetimeRibKind::Generics {
+                    kind: LifetimeBinderKind::BareFnType | LifetimeBinderKind::FnTrait,
+                    ..
+                } => {
+                    rustc_errors::struct_span_err!(
+                        self.r.session,
+                        lifetime.ident.span,
+                        E0687,
+                        "lifetimes used in `fn` or `Fn` syntax must be \
+                             explicitly declared using `<...>` binders"
+                    )
+                    .span_label(lifetime.ident.span, "in-band lifetime definition")
+                    .emit();
+                    let res_ident =
+                        Ident::new(lifetime.ident.name, res_span.normalize_to_macros_2_0());
+
+                    self.lifetime_ribs[in_band_rib_index]
+                        .bindings
+                        .insert(res_ident, LifetimeRes::Error);
+                    self.r.lifetimes_res_map.insert(lifetime.id, LifetimeRes::Error);
+                    return;
+                }
                 _ => {}
             }
         }

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -1797,6 +1797,9 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
                 if !kind.transparent_in_band() {
                     suggests_in_band = kind.allow_in_band();
                 }
+                if let LifetimeBinderKind::FnTrait = kind {
+                    continue;
+                }
 
                 if span.from_expansion() && suggest_note {
                     suggest_note = false; // Avoid displaying the same help multiple times.

compiler/rustc_resolve/src/late/lifetimes.rs

@@ -168,9 +168,6 @@ crate struct LifetimeContext<'a, 'tcx> {
     map: &'a mut NamedRegionMap,
     scope: ScopeRef<'a>,
 
-    /// Used to disallow the use of in-band lifetimes in `fn` or `Fn` syntax.
-    is_in_fn_syntax: bool,
-
     /// Indicates that we only care about the definition of a trait. This should
     /// be false if the `Item` we are resolving lifetimes for is not a trait or
     /// we eventually need lifetimes resolve for trait items.
@@ -451,7 +448,6 @@ fn do_resolve(
         tcx,
         map: &mut named_region_map,
         scope: ROOT_SCOPE,
-        is_in_fn_syntax: false,
         trait_definition_only,
         xcrate_object_lifetime_defaults: Default::default(),
         lifetime_uses: &mut Default::default(),
@@ -869,8 +865,6 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
         match ty.kind {
             hir::TyKind::BareFn(ref c) => {
                 let next_early_index = self.next_early_index();
-                let was_in_fn_syntax = self.is_in_fn_syntax;
-                self.is_in_fn_syntax = true;
                 let lifetime_span: Option<Span> =
                     c.generic_params.iter().rev().find_map(|param| match param.kind {
                         GenericParamKind::Lifetime { .. } => Some(param.span),
@@ -911,7 +905,6 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                     intravisit::walk_ty(this, ty);
                 });
                 self.missing_named_lifetime_spots.pop();
-                self.is_in_fn_syntax = was_in_fn_syntax;
             }
             hir::TyKind::TraitObject(bounds, ref lifetime, _) => {
                 debug!(?bounds, ?lifetime, "TraitObject");
@@ -1685,7 +1678,6 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
             tcx: *tcx,
             map,
             scope: &wrap_scope,
-            is_in_fn_syntax: self.is_in_fn_syntax,
             trait_definition_only: self.trait_definition_only,
             xcrate_object_lifetime_defaults,
             lifetime_uses,
@@ -2209,39 +2201,6 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                 }
             }
 
-            // Check for fn-syntax conflicts with in-band lifetime definitions
-            if !self.trait_definition_only && self.is_in_fn_syntax {
-                match def {
-                    Region::EarlyBound(_, _, LifetimeDefOrigin::InBand)
-                    | Region::LateBound(_, _, _, LifetimeDefOrigin::InBand) => {
-                        struct_span_err!(
-                            self.tcx.sess,
-                            lifetime_ref.span,
-                            E0687,
-                            "lifetimes used in `fn` or `Fn` syntax must be \
-                             explicitly declared using `<...>` binders"
-                        )
-                        .span_label(lifetime_ref.span, "in-band lifetime definition")
-                        .emit();
-                    }
-
-                    Region::Static
-                    | Region::EarlyBound(
-                        _,
-                        _,
-                        LifetimeDefOrigin::ExplicitOrElided | LifetimeDefOrigin::Error,
-                    )
-                    | Region::LateBound(
-                        _,
-                        _,
-                        _,
-                        LifetimeDefOrigin::ExplicitOrElided | LifetimeDefOrigin::Error,
-                    )
-                    | Region::LateBoundAnon(..)
-                    | Region::Free(..) => {}
-                }
-            }
-
             self.insert_lifetime(lifetime_ref, def);
         } else {
             self.tcx.sess.delay_span_bug(
@@ -2263,10 +2222,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
         );
 
         if generic_args.parenthesized {
-            let was_in_fn_syntax = self.is_in_fn_syntax;
-            self.is_in_fn_syntax = true;
             self.visit_fn_like_elision(generic_args.inputs(), Some(generic_args.bindings[0].ty()));
-            self.is_in_fn_syntax = was_in_fn_syntax;
             return;
         }