Auto merge of rust-lang#113732 - matthiaskrgr:rollup-nm5qy4i, r=matth…

…iaskrgr

Rollup of 6 pull requests

Successful merges:

 - rust-lang#113625 (Structurally normalize in selection)
 - rust-lang#113644 (misc bootstrap cleanups)
 - rust-lang#113663 (Implement "items do not inherit unsafety" note for THIR unsafeck)
 - rust-lang#113683 (remove outdated `FIXME`s in bootstrap internals)
 - rust-lang#113709 (rustdoc: use src consistently over source in CSS/JS)
 - rust-lang#113724 (Migrate GUI colors test to original CSS color format)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_mir_build/messages.ftl

@@ -312,6 +312,8 @@ mir_build_unreachable_pattern = unreachable pattern
  .label = unreachable pattern
  .catchall_label = matches any value
 
+mir_build_unsafe_not_inherited = items do not inherit unsafety from separate enclosing items
+
 mir_build_unsafe_op_in_unsafe_fn_borrow_of_layout_constrained_field_requires_unsafe =
  borrow of layout constrained field with interior mutability is unsafe and requires unsafe block (error E0133)
  .note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -91,7 +91,12 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
  kind.emit_unsafe_op_in_unsafe_fn_lint(self.tcx, self.hir_context, span);
  }
  SafetyContext::Safe => {
- kind.emit_requires_unsafe_err(self.tcx, span, unsafe_op_in_unsafe_fn_allowed);
+ kind.emit_requires_unsafe_err(
+ self.tcx,
+ span,
+ self.hir_context,
+ unsafe_op_in_unsafe_fn_allowed,
+ );
  }
  }
  }
@@ -602,98 +607,164 @@ impl UnsafeOpKind {
  &self,
  tcx: TyCtxt<'_>,
  span: Span,
+ hir_context: hir::HirId,
  unsafe_op_in_unsafe_fn_allowed: bool,
  ) {
+ let note_non_inherited = tcx.hir().parent_iter(hir_context).find(|(id, node)| {
+ if let hir::Node::Expr(block) = node
+ && let hir::ExprKind::Block(block, _) = block.kind
+ && let hir::BlockCheckMode::UnsafeBlock(_) = block.rules
+ {
+ true
+ }
+ else if let Some(sig) = tcx.hir().fn_sig_by_hir_id(*id)
+ && sig.header.is_unsafe()
+ {
+ true
+ } else {
+ false
+ }
+ });
+ let unsafe_not_inherited_note = if let Some((id, _)) = note_non_inherited {
+ let span = tcx.hir().span(id);
+ let span = tcx.sess.source_map().guess_head_span(span);
+ Some(UnsafeNotInheritedNote { span })
+ } else {
+ None
+ };
+
  match self {
  CallToUnsafeFunction(Some(did)) if unsafe_op_in_unsafe_fn_allowed => {
  tcx.sess.emit_err(CallToUnsafeFunctionRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
  span,
+ unsafe_not_inherited_note,
  function: &tcx.def_path_str(*did),
  });
  }
  CallToUnsafeFunction(Some(did)) => {
  tcx.sess.emit_err(CallToUnsafeFunctionRequiresUnsafe {
  span,
+ unsafe_not_inherited_note,
  function: &tcx.def_path_str(*did),
  });
  }
  CallToUnsafeFunction(None) if unsafe_op_in_unsafe_fn_allowed => {
  tcx.sess.emit_err(
- CallToUnsafeFunctionRequiresUnsafeNamelessUnsafeOpInUnsafeFnAllowed { span },
+ CallToUnsafeFunctionRequiresUnsafeNamelessUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ },
  );
  }
  CallToUnsafeFunction(None) => {
- tcx.sess.emit_err(CallToUnsafeFunctionRequiresUnsafeNameless { span });
+ tcx.sess.emit_err(CallToUnsafeFunctionRequiresUnsafeNameless {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  UseOfInlineAssembly if unsafe_op_in_unsafe_fn_allowed => {
- tcx.sess
- .emit_err(UseOfInlineAssemblyRequiresUnsafeUnsafeOpInUnsafeFnAllowed { span });
+ tcx.sess.emit_err(UseOfInlineAssemblyRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  UseOfInlineAssembly => {
- tcx.sess.emit_err(UseOfInlineAssemblyRequiresUnsafe { span });
+ tcx.sess.emit_err(UseOfInlineAssemblyRequiresUnsafe {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  InitializingTypeWith if unsafe_op_in_unsafe_fn_allowed => {
- tcx.sess
- .emit_err(InitializingTypeWithRequiresUnsafeUnsafeOpInUnsafeFnAllowed { span });
+ tcx.sess.emit_err(InitializingTypeWithRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  InitializingTypeWith => {
- tcx.sess.emit_err(InitializingTypeWithRequiresUnsafe { span });
+ tcx.sess.emit_err(InitializingTypeWithRequiresUnsafe {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  UseOfMutableStatic if unsafe_op_in_unsafe_fn_allowed => {
- tcx.sess
- .emit_err(UseOfMutableStaticRequiresUnsafeUnsafeOpInUnsafeFnAllowed { span });
+ tcx.sess.emit_err(UseOfMutableStaticRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  UseOfMutableStatic => {
- tcx.sess.emit_err(UseOfMutableStaticRequiresUnsafe { span });
+ tcx.sess
+ .emit_err(UseOfMutableStaticRequiresUnsafe { span, unsafe_not_inherited_note });
  }
  UseOfExternStatic if unsafe_op_in_unsafe_fn_allowed => {
- tcx.sess
- .emit_err(UseOfExternStaticRequiresUnsafeUnsafeOpInUnsafeFnAllowed { span });
+ tcx.sess.emit_err(UseOfExternStaticRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  UseOfExternStatic => {
- tcx.sess.emit_err(UseOfExternStaticRequiresUnsafe { span });
+ tcx.sess
+ .emit_err(UseOfExternStaticRequiresUnsafe { span, unsafe_not_inherited_note });
  }
  DerefOfRawPointer if unsafe_op_in_unsafe_fn_allowed => {
- tcx.sess
- .emit_err(DerefOfRawPointerRequiresUnsafeUnsafeOpInUnsafeFnAllowed { span });
+ tcx.sess.emit_err(DerefOfRawPointerRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  DerefOfRawPointer => {
- tcx.sess.emit_err(DerefOfRawPointerRequiresUnsafe { span });
+ tcx.sess
+ .emit_err(DerefOfRawPointerRequiresUnsafe { span, unsafe_not_inherited_note });
  }
  AccessToUnionField if unsafe_op_in_unsafe_fn_allowed => {
- tcx.sess
- .emit_err(AccessToUnionFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed { span });
+ tcx.sess.emit_err(AccessToUnionFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  AccessToUnionField => {
- tcx.sess.emit_err(AccessToUnionFieldRequiresUnsafe { span });
+ tcx.sess
+ .emit_err(AccessToUnionFieldRequiresUnsafe { span, unsafe_not_inherited_note });
  }
  MutationOfLayoutConstrainedField if unsafe_op_in_unsafe_fn_allowed => {
  tcx.sess.emit_err(
  MutationOfLayoutConstrainedFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
  span,
+ unsafe_not_inherited_note,
  },
  );
  }
  MutationOfLayoutConstrainedField => {
- tcx.sess.emit_err(MutationOfLayoutConstrainedFieldRequiresUnsafe { span });
+ tcx.sess.emit_err(MutationOfLayoutConstrainedFieldRequiresUnsafe {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  BorrowOfLayoutConstrainedField if unsafe_op_in_unsafe_fn_allowed => {
  tcx.sess.emit_err(
- BorrowOfLayoutConstrainedFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed { span },
+ BorrowOfLayoutConstrainedFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+ span,
+ unsafe_not_inherited_note,
+ },
  );
  }
  BorrowOfLayoutConstrainedField => {
- tcx.sess.emit_err(BorrowOfLayoutConstrainedFieldRequiresUnsafe { span });
+ tcx.sess.emit_err(BorrowOfLayoutConstrainedFieldRequiresUnsafe {
+ span,
+ unsafe_not_inherited_note,
+ });
  }
  CallToFunctionWith(did) if unsafe_op_in_unsafe_fn_allowed => {
  tcx.sess.emit_err(CallToFunctionWithRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
  span,
+ unsafe_not_inherited_note,
  function: &tcx.def_path_str(*did),
  });
  }
  CallToFunctionWith(did) => {
  tcx.sess.emit_err(CallToFunctionWithRequiresUnsafe {
  span,
+ unsafe_not_inherited_note,
  function: &tcx.def_path_str(*did),
  });
  }