Lower AST and resolve lifetimes for unsafe binder type

Author: compiler-errors

compiler/rustc_ast_lowering/src/index.rs

@@ -285,6 +285,12 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         self.insert(ty.span, ty.hir_id, Node::Ty(ty));
 
         self.with_parent(ty.hir_id, |this| {
+            // FIXME(unsafe_binders): Should we split this out into a separate
+            // visit function?
+            if let TyKind::UnsafeBinder(binder) = ty.kind {
+                this.insert(ty.span, binder.hir_id, Node::UnsafeBinder(binder));
+            };
+
             intravisit::walk_ty(this, ty);
         });
     }

compiler/rustc_ast_lowering/src/lib.rs

@@ -1310,6 +1310,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     param_names: self.lower_fn_params_to_names(&f.decl),
                 }))
             }
+            TyKind::UnsafeBinder(f) => {
+                let generic_params = self.lower_lifetime_binder(t.id, &f.generic_params);
+                hir::TyKind::UnsafeBinder(self.arena.alloc(hir::UnsafeBinderTy {
+                    span: self.lower_span(t.span),
+                    hir_id: self.next_id(),
+                    generic_params,
+                    inner_ty: self.lower_ty(&f.inner_ty, itctx),
+                }))
+            }
             TyKind::Never => hir::TyKind::Never,
             TyKind::Tup(tys) => hir::TyKind::Tup(
                 self.arena.alloc_from_iter(tys.iter().map(|ty| self.lower_ty_direct(ty, itctx))),

compiler/rustc_ast_lowering/src/lifetime_collector.rs

@@ -95,6 +95,11 @@ impl<'ast> Visitor<'ast> for LifetimeCollectVisitor<'ast> {
                 visit::walk_ty(self, t);
                 self.current_binders.pop();
             }
+            TyKind::UnsafeBinder(_) => {
+                self.current_binders.push(t.id);
+                visit::walk_ty(self, t);
+                self.current_binders.pop();
+            }
             TyKind::Ref(None, _) => {
                 self.record_elided_anchor(t.id, t.span);
                 visit::walk_ty(self, t);

compiler/rustc_hir/src/hir.rs

@@ -2739,6 +2739,14 @@ pub struct BareFnTy<'hir> {
     pub param_names: &'hir [Ident],
 }
 
+#[derive(Debug, Clone, Copy, HashStable_Generic)]
+pub struct UnsafeBinderTy<'hir> {
+    pub hir_id: HirId,
+    pub span: Span,
+    pub generic_params: &'hir [GenericParam<'hir>],
+    pub inner_ty: &'hir Ty<'hir>,
+}
+
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct OpaqueTy<'hir> {
     pub generics: &'hir Generics<'hir>,
@@ -2831,6 +2839,8 @@ pub enum TyKind<'hir> {
     Ref(&'hir Lifetime, MutTy<'hir>),
     /// A bare function (e.g., `fn(usize) -> bool`).
     BareFn(&'hir BareFnTy<'hir>),
+    /// Uwu
+    UnsafeBinder(&'hir UnsafeBinderTy<'hir>),
     /// The never type (`!`).
     Never,
     /// A tuple (`(A, B, C, D, ...)`).
@@ -3801,6 +3811,7 @@ pub enum Node<'hir> {
     // FIXME: Merge into `Node::Infer`.
     ArrayLenInfer(&'hir InferArg),
     PreciseCapturingNonLifetimeArg(&'hir PreciseCapturingNonLifetimeArg),
+    UnsafeBinder(&'hir UnsafeBinderTy<'hir>),
     // Created by query feeding
     Synthetic,
     Err(Span),
@@ -3853,6 +3864,7 @@ impl<'hir> Node<'hir> {
             | Node::Infer(..)
             | Node::WhereBoundPredicate(..)
             | Node::ArrayLenInfer(..)
+            | Node::UnsafeBinder(..)
             | Node::Synthetic
             | Node::Err(..) => None,
         }

compiler/rustc_hir/src/intravisit.rs

@@ -891,6 +891,11 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) -> V::Resul
             walk_list!(visitor, visit_generic_param, function_declaration.generic_params);
             try_visit!(visitor.visit_fn_decl(function_declaration.decl));
         }
+        TyKind::UnsafeBinder(ref unsafe_binder) => {
+            try_visit!(visitor.visit_id(unsafe_binder.hir_id));
+            walk_list!(visitor, visit_generic_param, unsafe_binder.generic_params);
+            try_visit!(visitor.visit_ty(unsafe_binder.inner_ty));
+        }
         TyKind::Path(ref qpath) => {
             try_visit!(visitor.visit_qpath(qpath, typ.hir_id, typ.span));
         }

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -480,6 +480,12 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<S
                     self.outer_index.shift_out(1);
                     res
                 }
+                hir::TyKind::UnsafeBinder(_) => {
+                    self.outer_index.shift_in(1);
+                    let res = intravisit::walk_ty(self, ty);
+                    self.outer_index.shift_out(1);
+                    res
+                }
                 _ => intravisit::walk_ty(self, ty),
             }
         }

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -648,6 +648,35 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                     intravisit::walk_ty(this, ty);
                 });
             }
+            hir::TyKind::UnsafeBinder(binder) => {
+                let (mut bound_vars, binders): (FxIndexMap<LocalDefId, ResolvedArg>, Vec<_>) =
+                    binder
+                        .generic_params
+                        .iter()
+                        .enumerate()
+                        .map(|(late_bound_idx, param)| {
+                            let pair = ResolvedArg::late(late_bound_idx as u32, param);
+                            let r = late_arg_as_bound_arg(self.tcx, &pair.1, param);
+                            (pair, r)
+                        })
+                        .unzip();
+
+                deny_non_region_late_bound(self.tcx, &mut bound_vars, "function pointer types");
+
+                self.record_late_bound_vars(binder.hir_id, binders);
+                let scope = Scope::Binder {
+                    hir_id: ty.hir_id,
+                    bound_vars,
+                    s: self.scope,
+                    scope_type: BinderScopeType::Normal,
+                    where_bound_origin: None,
+                };
+                self.with(scope, |this| {
+                    // a bare fn has no bounds, so everything
+                    // contained within is scoped within its binder.
+                    intravisit::walk_ty(this, ty);
+                });
+            }
             hir::TyKind::TraitObject(bounds, lifetime, _) => {
                 debug!(?bounds, ?lifetime, "TraitObject");
                 let scope = Scope::TraitRefBoundary { s: self.scope };

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2052,6 +2052,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     self.lower_fn_ty(hir_ty.hir_id, bf.safety, bf.abi, bf.decl, None, Some(hir_ty)),
                 )
             }
+            hir::TyKind::UnsafeBinder(_binder) => todo!(),
             hir::TyKind::TraitObject(bounds, lifetime, repr) => {
                 self.prohibit_or_lint_bare_trait_object_ty(hir_ty);
 

compiler/rustc_hir_pretty/src/lib.rs

@@ -123,6 +123,7 @@ impl<'a> State<'a> {
                 self.print_bounds(":", pred.bounds);
             }
             Node::ArrayLenInfer(_) => self.word("_"),
+            Node::UnsafeBinder(binder) => self.print_unsafe_binder(binder),
             Node::Synthetic => unreachable!(),
             Node::Err(_) => self.word("/*ERROR*/"),
         }
@@ -293,6 +294,9 @@ impl<'a> State<'a> {
             hir::TyKind::BareFn(f) => {
                 self.print_ty_fn(f.abi, f.safety, f.decl, None, f.generic_params, f.param_names);
             }
+            hir::TyKind::UnsafeBinder(unsafe_binder) => {
+                self.print_unsafe_binder(unsafe_binder);
+            }
             hir::TyKind::OpaqueDef(..) => self.word("/*impl Trait*/"),
             hir::TyKind::Path(ref qpath) => self.print_qpath(qpath, false),
             hir::TyKind::TraitObject(bounds, lifetime, syntax) => {
@@ -348,6 +352,15 @@ impl<'a> State<'a> {
         self.end()
     }
 
+    fn print_unsafe_binder(&mut self, unsafe_binder: &hir::UnsafeBinderTy<'_>) {
+        self.ibox(INDENT_UNIT);
+        self.word("unsafe");
+        self.print_generic_params(unsafe_binder.generic_params);
+        self.nbsp();
+        self.print_type(unsafe_binder.inner_ty);
+        self.end();
+    }
+
     fn print_foreign_item(&mut self, item: &hir::ForeignItem<'_>) {
         self.hardbreak_if_not_bol();
         self.maybe_print_comment(item.span.lo());

compiler/rustc_lint/src/non_local_def.rs

@@ -440,6 +440,8 @@ fn ty_has_local_parent(
         | TyKind::Ptr(_)
         | TyKind::Ref(_, _)
         | TyKind::BareFn(_)
+        // FIXME(unsafe_binders): Do we want to consider this local?
+        | TyKind::UnsafeBinder(_)
         | TyKind::Never
         | TyKind::Tup(_)
         | TyKind::Path(_)

compiler/rustc_middle/src/hir/map/mod.rs

@@ -933,6 +933,7 @@ impl<'hir> Map<'hir> {
             Node::WhereBoundPredicate(pred) => pred.span,
             Node::ArrayLenInfer(inf) => inf.span,
             Node::PreciseCapturingNonLifetimeArg(param) => param.ident.span,
+            Node::UnsafeBinder(binder) => binder.span,
             Node::Synthetic => unreachable!(),
             Node::Err(span) => span,
         }
@@ -1215,6 +1216,7 @@ fn hir_id_to_string(map: Map<'_>, id: HirId) -> String {
         Node::Synthetic => unreachable!(),
         Node::Err(_) => node_str("error"),
         Node::PreciseCapturingNonLifetimeArg(_param) => node_str("parameter"),
+        Node::UnsafeBinder(_) => node_str("unsafe binder"),
     }
 }
 

compiler/rustc_passes/src/hir_stats.rs

@@ -342,6 +342,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
                 Ptr,
                 Ref,
                 BareFn,
+                UnsafeBinder,
                 Never,
                 Tup,
                 AnonAdt,
@@ -606,6 +607,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
                 Ptr,
                 Ref,
                 BareFn,
+                UnsafeBinder,
                 Never,
                 Tup,
                 AnonStruct,

compiler/rustc_resolve/src/late.rs

@@ -865,6 +865,28 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
                     },
                 )
             }
+            TyKind::UnsafeBinder(unsafe_binder) => {
+                // FIXME(unsafe_binder): Better span
+                let span = ty.span;
+                self.with_generic_param_rib(
+                    &unsafe_binder.generic_params,
+                    RibKind::Normal,
+                    LifetimeRibKind::Generics {
+                        binder: ty.id,
+                        kind: LifetimeBinderKind::BareFnType,
+                        span,
+                    },
+                    |this| {
+                        this.visit_generic_params(&unsafe_binder.generic_params, false);
+                        this.with_lifetime_rib(
+                            // We don't allow anonymous `unsafe &'_ ()` binders,
+                            // although I guess we could.
+                            LifetimeRibKind::AnonymousReportError,
+                            |this| this.visit_ty(&unsafe_binder.inner_ty),
+                        );
+                    },
+                )
+            }
             TyKind::Array(element_ty, length) => {
                 self.visit_ty(element_ty);
                 self.resolve_anon_const(length, AnonConstKind::ConstArg(IsRepeatExpr::No));