compiler/rustc_mir_build/src/check_unsafety.rs

   1 use crate::build::ExprCategory;
   2 use rustc_middle::thir::visit::{self, Visitor};
   3
   4 use rustc_errors::struct_span_err;
   5 use rustc_hir as hir;
   6 use rustc_middle::mir::BorrowKind;
   7 use rustc_middle::thir::*;
   8 use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt};
   9 use rustc_session::lint::builtin::{UNSAFE_OP_IN_UNSAFE_FN, UNUSED_UNSAFE};
  10 use rustc_session::lint::Level;
  11 use rustc_span::def_id::{DefId, LocalDefId};
  12 use rustc_span::symbol::Symbol;
  13 use rustc_span::Span;
  14
  15 use std::ops::Bound;
  16
  17 struct UnsafetyVisitor<'a, 'tcx> {
  18     tcx: TyCtxt<'tcx>,
  19     thir: &'a Thir<'tcx>,
  20     /// The `HirId` of the current scope, which would be the `HirId`
  21     /// of the current HIR node, modulo adjustments. Used for lint levels.
  22     hir_context: hir::HirId,
  23     /// The current "safety context". This notably tracks whether we are in an
  24     /// `unsafe` block, and whether it has been used.
  25     safety_context: SafetyContext,
  26     body_unsafety: BodyUnsafety,
  27     /// The `#[target_feature]` attributes of the body. Used for checking
  28     /// calls to functions with `#[target_feature]` (RFC 2396).
  29     body_target_features: &'tcx Vec<Symbol>,
  30     /// When inside the LHS of an assignment to a field, this is the type
  31     /// of the LHS and the span of the assignment expression.
  32     assignment_info: Option<(Ty<'tcx>, Span)>,
  33     in_union_destructure: bool,
  34     param_env: ParamEnv<'tcx>,
  35     inside_adt: bool,
  36 }
  37
  38 impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
  39     fn in_safety_context(&mut self, safety_context: SafetyContext, f: impl FnOnce(&mut Self)) {
  40         if let (
  41             SafetyContext::UnsafeBlock { span: enclosing_span, .. },
  42             SafetyContext::UnsafeBlock { span: block_span, hir_id, .. },
  43         ) = (self.safety_context, safety_context)
  44         {
  45             self.warn_unused_unsafe(
  46                 hir_id,
  47                 block_span,
  48                 Some((self.tcx.sess.source_map().guess_head_span(enclosing_span), "block")),
  49             );
  50             f(self);
  51         } else {
  52             let prev_context = self.safety_context;
  53             self.safety_context = safety_context;
  54
  55             f(self);
  56
  57             if let SafetyContext::UnsafeBlock { used: false, span, hir_id } = self.safety_context {
  58                 self.warn_unused_unsafe(
  59                     hir_id,
  60                     span,
  61                     if self.unsafe_op_in_unsafe_fn_allowed() {
  62                         self.body_unsafety.unsafe_fn_sig_span().map(|span| (span, "fn"))
  63                     } else {
  64                         None
  65                     },
  66                 );
  67             }
  68             self.safety_context = prev_context;
  69         }
  70     }
  71
  72     fn requires_unsafe(&mut self, span: Span, kind: UnsafeOpKind) {
  73         let (description, note) = kind.description_and_note();
  74         let unsafe_op_in_unsafe_fn_allowed = self.unsafe_op_in_unsafe_fn_allowed();
  75         match self.safety_context {
  76             SafetyContext::BuiltinUnsafeBlock => {}
  77             SafetyContext::UnsafeBlock { ref mut used, .. } => {
  78                 if !self.body_unsafety.is_unsafe() || !unsafe_op_in_unsafe_fn_allowed {
  79                     // Mark this block as useful
  80                     *used = true;
  81                 }
  82             }
  83             SafetyContext::UnsafeFn if unsafe_op_in_unsafe_fn_allowed => {}
  84             SafetyContext::UnsafeFn => {
  85                 // unsafe_op_in_unsafe_fn is disallowed
  86                 self.tcx.struct_span_lint_hir(
  87                     UNSAFE_OP_IN_UNSAFE_FN,
  88                     self.hir_context,
  89                     span,
  90                     |lint| {
  91                         lint.build(&format!(
  92                             "{} is unsafe and requires unsafe block (error E0133)",
  93                             description,
  94                         ))
  95                         .span_label(span, description)
  96                         .note(note)
  97                         .emit();
  98                     },
  99                 )
 100             }
 101             SafetyContext::Safe => {
 102                 let fn_sugg = if unsafe_op_in_unsafe_fn_allowed { " function or" } else { "" };
 103                 struct_span_err!(
 104                     self.tcx.sess,
 105                     span,
 106                     E0133,
 107                     "{} is unsafe and requires unsafe{} block",
 108                     description,
 109                     fn_sugg,
 110                 )
 111                 .span_label(span, description)
 112                 .note(note)
 113                 .emit();
 114             }
 115         }
 116     }
 117
 118     fn warn_unused_unsafe(
 119         &self,
 120         hir_id: hir::HirId,
 121         block_span: Span,
 122         enclosing_unsafe: Option<(Span, &'static str)>,
 123     ) {
 124         let block_span = self.tcx.sess.source_map().guess_head_span(block_span);
 125         self.tcx.struct_span_lint_hir(UNUSED_UNSAFE, hir_id, block_span, |lint| {
 126             let msg = "unnecessary `unsafe` block";
 127             let mut db = lint.build(msg);
 128             db.span_label(block_span, msg);
 129             if let Some((span, kind)) = enclosing_unsafe {
 130                 db.span_label(span, format!("because it's nested under this `unsafe` {}", kind));
 131             }
 132             db.emit();
 133         });
 134     }
 135
 136     /// Whether the `unsafe_op_in_unsafe_fn` lint is `allow`ed at the current HIR node.
 137     fn unsafe_op_in_unsafe_fn_allowed(&self) -> bool {
 138         self.tcx.lint_level_at_node(UNSAFE_OP_IN_UNSAFE_FN, self.hir_context).0 == Level::Allow
 139     }
 140 }
 141
 142 // Searches for accesses to layout constrained fields.
 143 struct LayoutConstrainedPlaceVisitor<'a, 'tcx> {
 144     found: bool,
 145     thir: &'a Thir<'tcx>,
 146     tcx: TyCtxt<'tcx>,
 147 }
 148
 149 impl<'a, 'tcx> LayoutConstrainedPlaceVisitor<'a, 'tcx> {
 150     fn new(thir: &'a Thir<'tcx>, tcx: TyCtxt<'tcx>) -> Self {
 151         Self { found: false, thir, tcx }
 152     }
 153 }
 154
 155 impl<'a, 'tcx> Visitor<'a, 'tcx> for LayoutConstrainedPlaceVisitor<'a, 'tcx> {
 156     fn thir(&self) -> &'a Thir<'tcx> {
 157         self.thir
 158     }
 159
 160     fn visit_expr(&mut self, expr: &Expr<'tcx>) {
 161         match expr.kind {
 162             ExprKind::Field { lhs, .. } => {
 163                 if let ty::Adt(adt_def, _) = self.thir[lhs].ty.kind() {
 164                     if (Bound::Unbounded, Bound::Unbounded)
 165                         != self.tcx.layout_scalar_valid_range(adt_def.did)
 166                     {
 167                         self.found = true;
 168                     }
 169                 }
 170                 visit::walk_expr(self, expr);
 171             }
 172
 173             // Keep walking through the expression as long as we stay in the same
 174             // place, i.e. the expression is a place expression and not a dereference
 175             // (since dereferencing something leads us to a different place).
 176             ExprKind::Deref { .. } => {}
 177             ref kind if ExprCategory::of(kind).map_or(true, |cat| cat == ExprCategory::Place) => {
 178                 visit::walk_expr(self, expr);
 179             }
 180
 181             _ => {}
 182         }
 183     }
 184 }
 185
 186 impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
 187     fn thir(&self) -> &'a Thir<'tcx> {
 188         &self.thir
 189     }
 190
 191     fn visit_block(&mut self, block: &Block) {
 192         match block.safety_mode {
 193             // compiler-generated unsafe code should not count towards the usefulness of
 194             // an outer unsafe block
 195             BlockSafety::BuiltinUnsafe => {
 196                 self.in_safety_context(SafetyContext::BuiltinUnsafeBlock, |this| {
 197                     visit::walk_block(this, block)
 198                 });
 199             }
 200             BlockSafety::ExplicitUnsafe(hir_id) => {
 201                 self.in_safety_context(
 202                     SafetyContext::UnsafeBlock { span: block.span, hir_id, used: false },
 203                     |this| visit::walk_block(this, block),
 204                 );
 205             }
 206             BlockSafety::Safe => {
 207                 visit::walk_block(self, block);
 208             }
 209         }
 210     }
 211
 212     fn visit_pat(&mut self, pat: &Pat<'tcx>) {
 213         if self.in_union_destructure {
 214             match *pat.kind {
 215                 // binding to a variable allows getting stuff out of variable
 216                 PatKind::Binding { .. }
 217                 // match is conditional on having this value
 218                 | PatKind::Constant { .. }
 219                 | PatKind::Variant { .. }
 220                 | PatKind::Leaf { .. }
 221                 | PatKind::Deref { .. }
 222                 | PatKind::Range { .. }
 223                 | PatKind::Slice { .. }
 224                 | PatKind::Array { .. } => {
 225                     self.requires_unsafe(pat.span, AccessToUnionField);
 226                     return; // we can return here since this already requires unsafe
 227                 }
 228                 // wildcard doesn't take anything
 229                 PatKind::Wild |
 230                 // these just wrap other patterns
 231                 PatKind::Or { .. } |
 232                 PatKind::AscribeUserType { .. } => {}
 233             }
 234         };
 235
 236         match &*pat.kind {
 237             PatKind::Leaf { .. } => {
 238                 if let ty::Adt(adt_def, ..) = pat.ty.kind() {
 239                     if adt_def.is_union() {
 240                         let old_in_union_destructure =
 241                             std::mem::replace(&mut self.in_union_destructure, true);
 242                         visit::walk_pat(self, pat);
 243                         self.in_union_destructure = old_in_union_destructure;
 244                     } else if (Bound::Unbounded, Bound::Unbounded)
 245                         != self.tcx.layout_scalar_valid_range(adt_def.did)
 246                     {
 247                         let old_inside_adt = std::mem::replace(&mut self.inside_adt, true);
 248                         visit::walk_pat(self, pat);
 249                         self.inside_adt = old_inside_adt;
 250                     } else {
 251                         visit::walk_pat(self, pat);
 252                     }
 253                 } else {
 254                     visit::walk_pat(self, pat);
 255                 }
 256             }
 257             PatKind::Binding { mode: BindingMode::ByRef(borrow_kind), ty, .. } => {
 258                 if self.inside_adt {
 259                     let ty::Ref(_, ty, _) = ty.kind() else {
 260                         span_bug!(
 261                             pat.span,
 262                             "BindingMode::ByRef in pattern, but found non-reference type {}",
 263                             ty
 264                         );
 265                     };
 266                     match borrow_kind {
 267                         BorrowKind::Shallow | BorrowKind::Shared | BorrowKind::Unique => {
 268                             if !ty.is_freeze(self.tcx.at(pat.span), self.param_env) {
 269                                 self.requires_unsafe(pat.span, BorrowOfLayoutConstrainedField);
 270                             }
 271                         }
 272                         BorrowKind::Mut { .. } => {
 273                             self.requires_unsafe(pat.span, MutationOfLayoutConstrainedField);
 274                         }
 275                     }
 276                 }
 277                 visit::walk_pat(self, pat);
 278             }
 279             PatKind::Deref { .. } => {
 280                 let old_inside_adt = std::mem::replace(&mut self.inside_adt, false);
 281                 visit::walk_pat(self, pat);
 282                 self.inside_adt = old_inside_adt;
 283             }
 284             _ => {
 285                 visit::walk_pat(self, pat);
 286             }
 287         }
 288     }
 289
 290     fn visit_expr(&mut self, expr: &Expr<'tcx>) {
 291         // could we be in the LHS of an assignment to a field?
 292         match expr.kind {
 293             ExprKind::Field { .. }
 294             | ExprKind::VarRef { .. }
 295             | ExprKind::UpvarRef { .. }
 296             | ExprKind::Scope { .. }
 297             | ExprKind::Cast { .. } => {}
 298
 299             ExprKind::AddressOf { .. }
 300             | ExprKind::Adt { .. }
 301             | ExprKind::Array { .. }
 302             | ExprKind::Binary { .. }
 303             | ExprKind::Block { .. }
 304             | ExprKind::Borrow { .. }
 305             | ExprKind::Literal { .. }
 306             | ExprKind::ConstBlock { .. }
 307             | ExprKind::Deref { .. }
 308             | ExprKind::Index { .. }
 309             | ExprKind::NeverToAny { .. }
 310             | ExprKind::PlaceTypeAscription { .. }
 311             | ExprKind::ValueTypeAscription { .. }
 312             | ExprKind::Pointer { .. }
 313             | ExprKind::Repeat { .. }
 314             | ExprKind::StaticRef { .. }
 315             | ExprKind::ThreadLocalRef { .. }
 316             | ExprKind::Tuple { .. }
 317             | ExprKind::Unary { .. }
 318             | ExprKind::Call { .. }
 319             | ExprKind::Assign { .. }
 320             | ExprKind::AssignOp { .. }
 321             | ExprKind::Break { .. }
 322             | ExprKind::Closure { .. }
 323             | ExprKind::Continue { .. }
 324             | ExprKind::Return { .. }
 325             | ExprKind::Yield { .. }
 326             | ExprKind::Loop { .. }
 327             | ExprKind::Let { .. }
 328             | ExprKind::Match { .. }
 329             | ExprKind::Box { .. }
 330             | ExprKind::If { .. }
 331             | ExprKind::InlineAsm { .. }
 332             | ExprKind::LogicalOp { .. }
 333             | ExprKind::Use { .. } => {
 334                 // We don't need to save the old value and restore it
 335                 // because all the place expressions can't have more
 336                 // than one child.
 337                 self.assignment_info = None;
 338             }
 339         };
 340         match expr.kind {
 341             ExprKind::Scope { value, lint_level: LintLevel::Explicit(hir_id), region_scope: _ } => {
 342                 let prev_id = self.hir_context;
 343                 self.hir_context = hir_id;
 344                 self.visit_expr(&self.thir[value]);
 345                 self.hir_context = prev_id;
 346                 return; // don't visit the whole expression
 347             }
 348             ExprKind::Call { fun, ty: _, args: _, from_hir_call: _, fn_span: _ } => {
 349                 if self.thir[fun].ty.fn_sig(self.tcx).unsafety() == hir::Unsafety::Unsafe {
 350                     self.requires_unsafe(expr.span, CallToUnsafeFunction);
 351                 } else if let &ty::FnDef(func_did, _) = self.thir[fun].ty.kind() {
 352                     // If the called function has target features the calling function hasn't,
 353                     // the call requires `unsafe`. Don't check this on wasm
 354                     // targets, though. For more information on wasm see the
 355                     // is_like_wasm check in typeck/src/collect.rs
 356                     if !self.tcx.sess.target.options.is_like_wasm
 357                         && !self
 358                             .tcx
 359                             .codegen_fn_attrs(func_did)
 360                             .target_features
 361                             .iter()
 362                             .all(|feature| self.body_target_features.contains(feature))
 363                     {
 364                         self.requires_unsafe(expr.span, CallToFunctionWith);
 365                     }
 366                 }
 367             }
 368             ExprKind::Deref { arg } => {
 369                 if let ExprKind::StaticRef { def_id, .. } = self.thir[arg].kind {
 370                     if self.tcx.is_mutable_static(def_id) {
 371                         self.requires_unsafe(expr.span, UseOfMutableStatic);
 372                     } else if self.tcx.is_foreign_item(def_id) {
 373                         self.requires_unsafe(expr.span, UseOfExternStatic);
 374                     }
 375                 } else if self.thir[arg].ty.is_unsafe_ptr() {
 376                     self.requires_unsafe(expr.span, DerefOfRawPointer);
 377                 }
 378             }
 379             ExprKind::InlineAsm { .. } => {
 380                 self.requires_unsafe(expr.span, UseOfInlineAssembly);
 381             }
 382             ExprKind::Adt(box Adt {
 383                 adt_def,
 384                 variant_index: _,
 385                 substs: _,
 386                 user_ty: _,
 387                 fields: _,
 388                 base: _,
 389             }) => match self.tcx.layout_scalar_valid_range(adt_def.did) {
 390                 (Bound::Unbounded, Bound::Unbounded) => {}
 391                 _ => self.requires_unsafe(expr.span, InitializingTypeWith),
 392             },
 393             ExprKind::Closure {
 394                 closure_id,
 395                 substs: _,
 396                 upvars: _,
 397                 movability: _,
 398                 fake_reads: _,
 399             } => {
 400                 let closure_id = closure_id.expect_local();
 401                 let closure_def = if let Some((did, const_param_id)) =
 402                     ty::WithOptConstParam::try_lookup(closure_id, self.tcx)
 403                 {
 404                     ty::WithOptConstParam { did, const_param_did: Some(const_param_id) }
 405                 } else {
 406                     ty::WithOptConstParam::unknown(closure_id)
 407                 };
 408                 let (closure_thir, expr) = self.tcx.thir_body(closure_def);
 409                 let closure_thir = &closure_thir.borrow();
 410                 let hir_context = self.tcx.hir().local_def_id_to_hir_id(closure_id);
 411                 let mut closure_visitor =
 412                     UnsafetyVisitor { thir: closure_thir, hir_context, ..*self };
 413                 closure_visitor.visit_expr(&closure_thir[expr]);
 414                 // Unsafe blocks can be used in closures, make sure to take it into account
 415                 self.safety_context = closure_visitor.safety_context;
 416             }
 417             ExprKind::Field { lhs, .. } => {
 418                 let lhs = &self.thir[lhs];
 419                 if let ty::Adt(adt_def, _) = lhs.ty.kind() {
 420                     if adt_def.is_union() {
 421                         if let Some((assigned_ty, assignment_span)) = self.assignment_info {
 422                             // To avoid semver hazard, we only consider `Copy` and `ManuallyDrop` non-dropping.
 423                             if !(assigned_ty
 424                                 .ty_adt_def()
 425                                 .map_or(false, |adt| adt.is_manually_drop())
 426                                 || assigned_ty
 427                                     .is_copy_modulo_regions(self.tcx.at(expr.span), self.param_env))
 428                             {
 429                                 self.requires_unsafe(assignment_span, AssignToDroppingUnionField);
 430                             } else {
 431                                 // write to non-drop union field, safe
 432                             }
 433                         } else {
 434                             self.requires_unsafe(expr.span, AccessToUnionField);
 435                         }
 436                     }
 437                 }
 438             }
 439             ExprKind::Assign { lhs, rhs } | ExprKind::AssignOp { lhs, rhs, .. } => {
 440                 let lhs = &self.thir[lhs];
 441                 // First, check whether we are mutating a layout constrained field
 442                 let mut visitor = LayoutConstrainedPlaceVisitor::new(self.thir, self.tcx);
 443                 visit::walk_expr(&mut visitor, lhs);
 444                 if visitor.found {
 445                     self.requires_unsafe(expr.span, MutationOfLayoutConstrainedField);
 446                 }
 447
 448                 // Second, check for accesses to union fields
 449                 // don't have any special handling for AssignOp since it causes a read *and* write to lhs
 450                 if matches!(expr.kind, ExprKind::Assign { .. }) {
 451                     self.assignment_info = Some((lhs.ty, expr.span));
 452                     visit::walk_expr(self, lhs);
 453                     self.assignment_info = None;
 454                     visit::walk_expr(self, &self.thir()[rhs]);
 455                     return; // we have already visited everything by now
 456                 }
 457             }
 458             ExprKind::Borrow { borrow_kind, arg } => {
 459                 let mut visitor = LayoutConstrainedPlaceVisitor::new(self.thir, self.tcx);
 460                 visit::walk_expr(&mut visitor, expr);
 461                 if visitor.found {
 462                     match borrow_kind {
 463                         BorrowKind::Shallow | BorrowKind::Shared | BorrowKind::Unique
 464                             if !self.thir[arg]
 465                                 .ty
 466                                 .is_freeze(self.tcx.at(self.thir[arg].span), self.param_env) =>
 467                         {
 468                             self.requires_unsafe(expr.span, BorrowOfLayoutConstrainedField)
 469                         }
 470                         BorrowKind::Mut { .. } => {
 471                             self.requires_unsafe(expr.span, MutationOfLayoutConstrainedField)
 472                         }
 473                         BorrowKind::Shallow | BorrowKind::Shared | BorrowKind::Unique => {}
 474                     }
 475                 }
 476             }
 477             ExprKind::Let { expr: expr_id, .. } => {
 478                 let let_expr = &self.thir[expr_id];
 479                 if let ty::Adt(adt_def, _) = let_expr.ty.kind() {
 480                     if adt_def.is_union() {
 481                         self.requires_unsafe(expr.span, AccessToUnionField);
 482                     }
 483                 }
 484             }
 485             _ => {}
 486         }
 487         visit::walk_expr(self, expr);
 488     }
 489 }
 490
 491 #[derive(Clone, Copy)]
 492 enum SafetyContext {
 493     Safe,
 494     BuiltinUnsafeBlock,
 495     UnsafeFn,
 496     UnsafeBlock { span: Span, hir_id: hir::HirId, used: bool },
 497 }
 498
 499 #[derive(Clone, Copy)]
 500 enum BodyUnsafety {
 501     /// The body is not unsafe.
 502     Safe,
 503     /// The body is an unsafe function. The span points to
 504     /// the signature of the function.
 505     Unsafe(Span),
 506 }
 507
 508 impl BodyUnsafety {
 509     /// Returns whether the body is unsafe.
 510     fn is_unsafe(&self) -> bool {
 511         matches!(self, BodyUnsafety::Unsafe(_))
 512     }
 513
 514     /// If the body is unsafe, returns the `Span` of its signature.
 515     fn unsafe_fn_sig_span(self) -> Option<Span> {
 516         match self {
 517             BodyUnsafety::Unsafe(span) => Some(span),
 518             BodyUnsafety::Safe => None,
 519         }
 520     }
 521 }
 522
 523 #[derive(Clone, Copy, PartialEq)]
 524 enum UnsafeOpKind {
 525     CallToUnsafeFunction,
 526     UseOfInlineAssembly,
 527     InitializingTypeWith,
 528     UseOfMutableStatic,
 529     UseOfExternStatic,
 530     DerefOfRawPointer,
 531     AssignToDroppingUnionField,
 532     AccessToUnionField,
 533     MutationOfLayoutConstrainedField,
 534     BorrowOfLayoutConstrainedField,
 535     CallToFunctionWith,
 536 }
 537
 538 use UnsafeOpKind::*;
 539
 540 impl UnsafeOpKind {
 541     pub fn description_and_note(&self) -> (&'static str, &'static str) {
 542         match self {
 543             CallToUnsafeFunction => (
 544                 "call to unsafe function",
 545                 "consult the function's documentation for information on how to avoid undefined \
 546                  behavior",
 547             ),
 548             UseOfInlineAssembly => (
 549                 "use of inline assembly",
 550                 "inline assembly is entirely unchecked and can cause undefined behavior",
 551             ),
 552             InitializingTypeWith => (
 553                 "initializing type with `rustc_layout_scalar_valid_range` attr",
 554                 "initializing a layout restricted type's field with a value outside the valid \
 555                  range is undefined behavior",
 556             ),
 557             UseOfMutableStatic => (
 558                 "use of mutable static",
 559                 "mutable statics can be mutated by multiple threads: aliasing violations or data \
 560                  races will cause undefined behavior",
 561             ),
 562             UseOfExternStatic => (
 563                 "use of extern static",
 564                 "extern statics are not controlled by the Rust type system: invalid data, \
 565                  aliasing violations or data races will cause undefined behavior",
 566             ),
 567             DerefOfRawPointer => (
 568                 "dereference of raw pointer",
 569                 "raw pointers may be null, dangling or unaligned; they can violate aliasing rules \
 570                  and cause data races: all of these are undefined behavior",
 571             ),
 572             AssignToDroppingUnionField => (
 573                 "assignment to union field that might need dropping",
 574                 "the previous content of the field will be dropped, which causes undefined \
 575                  behavior if the field was not properly initialized",
 576             ),
 577             AccessToUnionField => (
 578                 "access to union field",
 579                 "the field may not be properly initialized: using uninitialized data will cause \
 580                  undefined behavior",
 581             ),
 582             MutationOfLayoutConstrainedField => (
 583                 "mutation of layout constrained field",
 584                 "mutating layout constrained fields cannot statically be checked for valid values",
 585             ),
 586             BorrowOfLayoutConstrainedField => (
 587                 "borrow of layout constrained field with interior mutability",
 588                 "references to fields of layout constrained fields lose the constraints. Coupled \
 589                  with interior mutability, the field can be changed to invalid values",
 590             ),
 591             CallToFunctionWith => (
 592                 "call to function with `#[target_feature]`",
 593                 "can only be called if the required target features are available",
 594             ),
 595         }
 596     }
 597 }
 598
 599 pub fn check_unsafety<'tcx>(tcx: TyCtxt<'tcx>, def: ty::WithOptConstParam<LocalDefId>) {
 600     // THIR unsafeck is gated under `-Z thir-unsafeck`
 601     if !tcx.sess.opts.debugging_opts.thir_unsafeck {
 602         return;
 603     }
 604
 605     // Closures are handled by their owner, if it has a body
 606     if tcx.is_closure(def.did.to_def_id()) {
 607         let hir = tcx.hir();
 608         let owner = hir.enclosing_body_owner(hir.local_def_id_to_hir_id(def.did));
 609         tcx.ensure().thir_check_unsafety(hir.local_def_id(owner));
 610         return;
 611     }
 612
 613     let (thir, expr) = tcx.thir_body(def);
 614     let thir = &thir.borrow();
 615     // If `thir` is empty, a type error occured, skip this body.
 616     if thir.exprs.is_empty() {
 617         return;
 618     }
 619
 620     let hir_id = tcx.hir().local_def_id_to_hir_id(def.did);
 621     let body_unsafety = tcx.hir().fn_sig_by_hir_id(hir_id).map_or(BodyUnsafety::Safe, |fn_sig| {
 622         if fn_sig.header.unsafety == hir::Unsafety::Unsafe {
 623             BodyUnsafety::Unsafe(fn_sig.span)
 624         } else {
 625             BodyUnsafety::Safe
 626         }
 627     });
 628     let body_target_features = &tcx.codegen_fn_attrs(def.did).target_features;
 629     let safety_context =
 630         if body_unsafety.is_unsafe() { SafetyContext::UnsafeFn } else { SafetyContext::Safe };
 631     let mut visitor = UnsafetyVisitor {
 632         tcx,
 633         thir,
 634         safety_context,
 635         hir_context: hir_id,
 636         body_unsafety,
 637         body_target_features,
 638         assignment_info: None,
 639         in_union_destructure: false,
 640         param_env: tcx.param_env(def.did),
 641         inside_adt: false,
 642     };
 643     visitor.visit_expr(&thir[expr]);
 644 }
 645
 646 crate fn thir_check_unsafety<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) {
 647     if let Some(def) = ty::WithOptConstParam::try_lookup(def_id, tcx) {
 648         tcx.thir_check_unsafety_for_const_arg(def)
 649     } else {
 650         check_unsafety(tcx, ty::WithOptConstParam::unknown(def_id))
 651     }
 652 }
 653
 654 crate fn thir_check_unsafety_for_const_arg<'tcx>(
 655     tcx: TyCtxt<'tcx>,
 656     (did, param_did): (LocalDefId, DefId),
 657 ) {
 658     check_unsafety(tcx, ty::WithOptConstParam { did, const_param_did: Some(param_did) })
 659 }