mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Auto merge of #85560 - GuillaumeGomez:rollup-8k90rc7, r=GuillaumeGomez

Browse source 
Rollup of 4 pull requests

Successful merges:

 - #85506 (Reset "focusedByTab" field when doing another search)
 - #85548 (Remove dead toggle JS code)
 - #85550 (facepalm: operator precedence fail on my part.)
 - #85555 (Check for more things in THIR unsafeck)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2021-05-21 19:17:22 +00:00
commit 5dc8789e30
70 changed files with 684 additions and 262 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

77
compiler/rustc_mir_build/src/check_unsafety.rs
View file

@ -7,8 +7,11 @@ use rustc_middle::ty::{self, TyCtxt};
use rustc_session::lint::builtin::{UNSAFE_OP_IN_UNSAFE_FN, UNUSED_UNSAFE};
use rustc_session::lint::Level;
use rustc_span::def_id::{DefId, LocalDefId};
use rustc_span::symbol::Symbol;
use rustc_span::Span;
use std::ops::Bound;
struct UnsafetyVisitor<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
thir: &'a Thir<'tcx>,
@ -19,6 +22,10 @@ struct UnsafetyVisitor<'a, 'tcx> {
/// `unsafe` block, and whether it has been used.
safety_context: SafetyContext,
body_unsafety: BodyUnsafety,
/// The `#[target_feature]` attributes of the body. Used for checking
/// calls to functions with `#[target_feature]` (RFC 2396).
body_target_features: &'tcx Vec<Symbol>,
is_const: bool,
}
impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
@ -148,11 +155,55 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
ExprKind::Call { fun, ty: _, args: _, from_hir_call: _, fn_span: _ } => {
if self.thir[fun].ty.fn_sig(self.tcx).unsafety() == hir::Unsafety::Unsafe {
self.requires_unsafe(expr.span, CallToUnsafeFunction);
} else if let &ty::FnDef(func_did, _) = self.thir[fun].ty.kind() {
// If the called function has target features the calling function hasn't,
// the call requires `unsafe`.
if !self
.tcx
.codegen_fn_attrs(func_did)
.target_features
.iter()
.all(|feature| self.body_target_features.contains(feature))
{
self.requires_unsafe(expr.span, CallToFunctionWith);
}
}
}
ExprKind::Deref { arg } => {
if let ExprKind::StaticRef { def_id, .. } = self.thir[arg].kind {
if self.tcx.is_mutable_static(def_id) {
self.requires_unsafe(expr.span, UseOfMutableStatic);
} else if self.tcx.is_foreign_item(def_id) {
self.requires_unsafe(expr.span, UseOfExternStatic);
}
} else if self.thir[arg].ty.is_unsafe_ptr() {
self.requires_unsafe(expr.span, DerefOfRawPointer);
}
}
ExprKind::InlineAsm { .. } | ExprKind::LlvmInlineAsm { .. } => {
self.requires_unsafe(expr.span, UseOfInlineAssembly);
}
ExprKind::Adt {
adt_def,
variant_index: _,
substs: _,
user_ty: _,
fields: _,
base: _,
} => match self.tcx.layout_scalar_valid_range(adt_def.did) {
(Bound::Unbounded, Bound::Unbounded) => {}
_ => self.requires_unsafe(expr.span, InitializingTypeWith),
},
ExprKind::Cast { source } => {
let source = &self.thir[source];
if self.tcx.features().const_raw_ptr_to_usize_cast
&& self.is_const
&& (source.ty.is_unsafe_ptr() || source.ty.is_fn_ptr())
&& expr.ty.is_integral()
{
self.requires_unsafe(expr.span, CastOfPointerToInt);
}
}
_ => {}
}
@ -195,15 +246,10 @@ impl BodyUnsafety {
enum UnsafeOpKind {
CallToUnsafeFunction,
UseOfInlineAssembly,
#[allow(dead_code)] // FIXME
InitializingTypeWith,
#[allow(dead_code)] // FIXME
CastOfPointerToInt,
#[allow(dead_code)] // FIXME
UseOfMutableStatic,
#[allow(dead_code)] // FIXME
UseOfExternStatic,
#[allow(dead_code)] // FIXME
DerefOfRawPointer,
#[allow(dead_code)] // FIXME
AssignToDroppingUnionField,
@ -213,7 +259,6 @@ enum UnsafeOpKind {
MutationOfLayoutConstrainedField,
#[allow(dead_code)] // FIXME
BorrowOfLayoutConstrainedField,
#[allow(dead_code)] // FIXME
CallToFunctionWith,
}
@ -287,6 +332,7 @@ pub fn check_unsafety<'tcx>(
tcx: TyCtxt<'tcx>,
thir: &Thir<'tcx>,
expr: ExprId,
def_id: LocalDefId,
hir_id: hir::HirId,
) {
let body_unsafety = tcx.hir().fn_sig_by_hir_id(hir_id).map_or(BodyUnsafety::Safe, |fn_sig| {
@ -296,10 +342,23 @@ pub fn check_unsafety<'tcx>(
BodyUnsafety::Safe
}
});
let body_target_features = &tcx.codegen_fn_attrs(def_id).target_features;
let safety_context =
if body_unsafety.is_unsafe() { SafetyContext::UnsafeFn } else { SafetyContext::Safe };
let mut visitor =
UnsafetyVisitor { tcx, thir, safety_context, hir_context: hir_id, body_unsafety };
let is_const = match tcx.hir().body_owner_kind(hir_id) {
hir::BodyOwnerKind::Closure => false,
hir::BodyOwnerKind::Fn => tcx.is_const_fn_raw(def_id.to_def_id()),
hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) => true,
};
let mut visitor = UnsafetyVisitor {
tcx,
thir,
safety_context,
hir_context: hir_id,
body_unsafety,
body_target_features,
is_const,
};
visitor.visit_expr(&thir[expr]);
}
@ -311,7 +370,7 @@ crate fn thir_check_unsafety_inner<'tcx>(
let body_id = tcx.hir().body_owned_by(hir_id);
let body = tcx.hir().body(body_id);
let (thir, expr) = cx::build_thir(tcx, def, &body.value);
check_unsafety(tcx, &thir, expr, hir_id);
check_unsafety(tcx, &thir, expr, def.did, hir_id);
}
crate fn thir_check_unsafety<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) {

2
src/bootstrap/bin/rustc.rs
View file

@ -305,7 +305,7 @@ fn format_rusage_data(_child: Child) -> Option<String> {
};
// Mac OS X reports the maxrss in bytes, not kb.
let divisor = if env::consts::OS == "macos" { 1024 } else { 1 };
let maxrss = rusage.ru_maxrss + (divisor - 1) / divisor;
let maxrss = (rusage.ru_maxrss + (divisor - 1)) / divisor;
let mut init_str = format!(
"user: {USER_SEC}.{USER_USEC:03} \

158
src/librustdoc/html/static/main.js
View file

@ -764,138 +764,6 @@ function hideThemeButtonState() {
innerToggle.children[0].innerText = labelForToggleButton(sectionIsCollapsed);
}
function collapseDocs(toggle, mode) {
if (!toggle || !toggle.parentNode) {
return;
}
function adjustToggle(arg) {
return function(e) {
if (hasClass(e, "toggle-label")) {
if (arg) {
e.style.display = "inline-block";
} else {
e.style.display = "none";
}
}
if (hasClass(e, "inner")) {
e.innerHTML = labelForToggleButton(arg);
}
};
}
function implHider(addOrRemove, fullHide) {
return function(n) {
var shouldHide =
fullHide ||
hasClass(n, "method") ||
hasClass(n, "associatedconstant");
if (shouldHide || hasClass(n, "type")) {
if (shouldHide) {
if (addOrRemove) {
addClass(n, "hidden-by-impl-hider");
} else {
removeClass(n, "hidden-by-impl-hider");
}
}
var ns = n.nextElementSibling;
while (ns && (hasClass(ns, "docblock") || hasClass(ns, "item-info"))) {
if (addOrRemove) {
addClass(ns, "hidden-by-impl-hider");
} else {
removeClass(ns, "hidden-by-impl-hider");
}
ns = ns.nextElementSibling;
}
}
};
}
var relatedDoc;
var action = mode;
if (!hasClass(toggle.parentNode, "impl")) {
relatedDoc = toggle.parentNode.nextElementSibling;
if (hasClass(relatedDoc, "item-info")) {
relatedDoc = relatedDoc.nextElementSibling;
}
if (hasClass(relatedDoc, "docblock")) {
if (mode === "toggle") {
if (hasClass(relatedDoc, "hidden-by-usual-hider")) {
action = "show";
} else {
action = "hide";
}
}
if (action === "hide") {
addClass(relatedDoc, "hidden-by-usual-hider");
onEachLazy(toggle.childNodes, adjustToggle(true));
addClass(toggle.parentNode, "collapsed");
} else if (action === "show") {
removeClass(relatedDoc, "hidden-by-usual-hider");
removeClass(toggle.parentNode, "collapsed");
onEachLazy(toggle.childNodes, adjustToggle(false));
}
}
} else {
// we are collapsing the impl block(s).
var parentElem = toggle.parentNode;
relatedDoc = parentElem;
var docblock = relatedDoc.nextElementSibling;
while (!hasClass(relatedDoc, "impl-items")) {
relatedDoc = relatedDoc.nextElementSibling;
}
if (!relatedDoc && !hasClass(docblock, "docblock")) {
return;
}
// Hide all functions, but not associated types/consts.
if (mode === "toggle") {
if (hasClass(relatedDoc, "fns-now-collapsed") ||
hasClass(docblock, "hidden-by-impl-hider")) {
action = "show";
} else {
action = "hide";
}
}
var dontApplyBlockRule = toggle.parentNode.parentNode.id !== "main";
if (action === "show") {
removeClass(relatedDoc, "fns-now-collapsed");
// Stability/deprecation/portability information is never hidden.
if (!hasClass(docblock, "item-info")) {
removeClass(docblock, "hidden-by-usual-hider");
}
onEachLazy(toggle.childNodes, adjustToggle(false, dontApplyBlockRule));
onEachLazy(relatedDoc.childNodes, implHider(false, dontApplyBlockRule));
} else if (action === "hide") {
addClass(relatedDoc, "fns-now-collapsed");
// Stability/deprecation/portability information should be shown even when detailed
// info is hidden.
if (!hasClass(docblock, "item-info")) {
addClass(docblock, "hidden-by-usual-hider");
}
onEachLazy(toggle.childNodes, adjustToggle(true, dontApplyBlockRule));
onEachLazy(relatedDoc.childNodes, implHider(true, dontApplyBlockRule));
}
}
}
function collapseNonInherent(e) {
// inherent impl ids are like "impl" or impl-<number>'.
// they will never be hidden by default.
var n = e.parentElement;
if (n.id.match(/^impl(?:-\d+)?$/) === null) {
// Automatically minimize all non-inherent impls
if (hasClass(n, "impl")) {
collapseDocs(e, "hide");
}
}
}
function insertAfter(newNode, referenceNode) {
referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
}
@ -910,20 +778,6 @@ function hideThemeButtonState() {
var hideImplementors = getSettingValue("auto-collapse-implementors") !== "false";
var hideLargeItemContents = getSettingValue("auto-hide-large-items") !== "false";
var impl_list = document.getElementById("trait-implementations-list");
if (impl_list !== null) {
onEachLazy(impl_list.getElementsByClassName("rustdoc-toggle"), function(e) {
collapseNonInherent(e);
});
}
var blanket_list = document.getElementById("blanket-implementations-list");
if (blanket_list !== null) {
onEachLazy(blanket_list.getElementsByClassName("rustdoc-toggle"), function(e) {
collapseNonInherent(e);
});
}
onEachLazy(document.getElementsByTagName("details"), function (e) {
var showLargeItem = !hideLargeItemContents && hasClass(e, "type-contents-toggle");
var showImplementor = !hideImplementors && hasClass(e, "implementors-toggle");
@ -936,18 +790,6 @@ function hideThemeButtonState() {
});
var currentType = document.getElementsByClassName("type-decl")[0];
if (currentType) {
currentType = currentType.getElementsByClassName("rust")[0];
if (currentType) {
onEachLazy(currentType.classList, function(item) {
if (item !== "main") {
return true;
}
});
}
}
var pageId = getPageId();
if (pageId !== null) {
expandSection(pageId);

9
src/librustdoc/html/static/search.js
View file

@ -885,12 +885,12 @@ window.initSearch = function(rawSearchIndex) {
focusSearchResult();
}
// focus the first search result on the active tab, or the result that
// Focus the first search result on the active tab, or the result that
// was focused last time this tab was active.
function focusSearchResult() {
var target = searchState.focusedByTab[searchState.currentTab] ||
document.querySelectorAll(".search-results.active a").item(0) ||
document.querySelectorAll("#titles > button").item(searchState.currentTab);
document.querySelectorAll(".search-results.active a").item(0) ||
document.querySelectorAll("#titles > button").item(searchState.currentTab);
if (target) {
target.focus();
}
@ -1076,6 +1076,8 @@ window.initSearch = function(rawSearchIndex) {
ret_others[0] + ret_in_args[0] + ret_returned[0] + "</div>";
search.innerHTML = output;
// Reset focused elements.
searchState.focusedByTab = [null, null, null];
searchState.showResults(search);
var elems = document.getElementById("titles").childNodes;
elems[0].onclick = function() { printTab(0); };
@ -1365,7 +1367,6 @@ window.initSearch = function(rawSearchIndex) {
if (e.which === 38) { // up
var previous = document.activeElement.previousElementSibling;
if (previous) {
console.log("previousElementSibling", previous);
previous.focus();
} else {
searchState.focus();

19
src/test/ui/cast/cast-ptr-to-int-const.mir.stderr Normal file
View file

@ -0,0 +1,19 @@
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:10:9
|
LL | &Y as *const u32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:17:5
|
LL | &0 as *const i32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0133`.

20
src/test/ui/cast/cast-ptr-to-int-const.rs
View file

@ -1,25 +1,19 @@
// gate-test-const_raw_ptr_to_usize_cast
// revisions: with_feature without_feature
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![cfg_attr(with_feature, feature(const_raw_ptr_to_usize_cast))]
#![feature(const_raw_ptr_to_usize_cast)]
fn main() {
const X: usize = unsafe {
main as usize //[without_feature]~ ERROR casting pointers to integers in constants is unstable
};
const Y: u32 = 0;
const Z: usize = unsafe {
&Y as *const u32 as usize //[without_feature]~ ERROR is unstable
};
// Cast in `const` without `unsafe` block
const SAFE: usize = {
&Y as *const u32 as usize //[without_feature]~ ERROR is unstable
//[with_feature]~^ ERROR cast of pointer to int is unsafe and requires unsafe
&Y as *const u32 as usize
//~^ ERROR cast of pointer to int is unsafe and requires unsafe
};
}
// Cast in `const fn` without `unsafe` block
const fn test() -> usize {
&0 as *const i32 as usize //[without_feature]~ ERROR is unstable
//[with_feature]~^ ERROR cast of pointer to int is unsafe and requires unsafe
&0 as *const i32 as usize
//~^ ERROR cast of pointer to int is unsafe and requires unsafe
}

19
src/test/ui/cast/cast-ptr-to-int-const.thir.stderr Normal file
View file

@ -0,0 +1,19 @@
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:10:9
|
LL | &Y as *const u32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error[E0133]: cast of pointer to int is unsafe and requires unsafe function or block
--> $DIR/cast-ptr-to-int-const.rs:17:5
|
LL | &0 as *const i32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cast of pointer to int
|
= note: casting pointers to integers in constants
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0133`.

13
src/test/ui/cast/feature-gate-const_raw_ptr_to_usize_cast.rs Normal file
View file

@ -0,0 +1,13 @@
fn main() {
const X: usize = unsafe {
main as usize //~ ERROR casting pointers to integers in constants is unstable
};
const Y: u32 = 0;
const Z: usize = unsafe {
&Y as *const u32 as usize //~ ERROR is unstable
};
}
const fn test() -> usize {
&0 as *const i32 as usize //~ ERROR is unstable
}

30
src/test/ui/cast/feature-gate-const_raw_ptr_to_usize_cast.stderr Normal file
View file

@ -0,0 +1,30 @@
error[E0658]: casting pointers to integers in constants is unstable
--> $DIR/feature-gate-const_raw_ptr_to_usize_cast.rs:3:9
|
LL | main as usize
| ^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
error[E0658]: casting pointers to integers in constants is unstable
--> $DIR/feature-gate-const_raw_ptr_to_usize_cast.rs:7:9
|
LL | &Y as *const u32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
error[E0658]: casting pointers to integers in constant functions is unstable
--> $DIR/feature-gate-const_raw_ptr_to_usize_cast.rs:12:5
|
LL | &0 as *const i32 as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: see issue #51910 <https://github.com/rust-lang/rust/issues/51910> for more information
= help: add `#![feature(const_raw_ptr_to_usize_cast)]` to the crate attributes to enable
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0658`.

2
src/test/ui/generator/issue-45729-unsafe-in-generator.stderr → src/test/ui/generator/issue-45729-unsafe-in-generator.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/issue-45729-unsafe-in-generator.rs:5:9
--> $DIR/issue-45729-unsafe-in-generator.rs:8:9
|
LL | *(1 as *mut u32) = 42;
| ^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer

3
src/test/ui/generator/issue-45729-unsafe-in-generator.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![feature(generators)]
fn main() {

11
src/test/ui/generator/issue-45729-unsafe-in-generator.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/issue-45729-unsafe-in-generator.rs:8:9
|
LL | *(1 as *mut u32) = 42;
| ^^^^^^^^^^^^^^^^ dereference of raw pointer
|
= note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/intrinsics/issue-28575.stderr → src/test/ui/intrinsics/issue-28575.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-28575.rs:8:5
--> $DIR/issue-28575.rs:11:5
|
LL | FOO()
| ^^^ use of extern static

3
src/test/ui/intrinsics/issue-28575.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![feature(intrinsics)]
extern "C" {

11
src/test/ui/intrinsics/issue-28575.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-28575.rs:11:5
|
LL | FOO()
| ^^^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/issues/issue-14227.stderr → src/test/ui/issues/issue-14227.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-14227.rs:4:21
--> $DIR/issue-14227.rs:7:21
|
LL | static CRASH: u32 = symbol;
| ^^^^^^ use of extern static

3
src/test/ui/issues/issue-14227.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
extern "C" {
pub static symbol: u32;
}

11
src/test/ui/issues/issue-14227.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-14227.rs:7:21
|
LL | static CRASH: u32 = symbol;
| ^^^^^^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

6
src/test/ui/issues/issue-16538.stderr → src/test/ui/issues/issue-16538.mir.stderr
View file

@ -1,11 +1,11 @@
error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants
--> $DIR/issue-16538.rs:11:27
--> $DIR/issue-16538.rs:14:27
|
LL | static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0277]: `*const usize` cannot be shared between threads safely
--> $DIR/issue-16538.rs:11:1
--> $DIR/issue-16538.rs:14:1
|
LL | static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const usize` cannot be shared between threads safely
@ -14,7 +14,7 @@ LL | static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
= note: shared static variables must have a type that implements `Sync`
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-16538.rs:11:34
--> $DIR/issue-16538.rs:14:34
|
LL | static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
| ^^^^ use of extern static

3
src/test/ui/issues/issue-16538.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
mod Y {
pub type X = usize;
extern "C" {

27
src/test/ui/issues/issue-16538.thir.stderr Normal file
View file

@ -0,0 +1,27 @@
error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants
--> $DIR/issue-16538.rs:14:27
|
LL | static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0277]: `*const usize` cannot be shared between threads safely
--> $DIR/issue-16538.rs:14:1
|
LL | static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const usize` cannot be shared between threads safely
|
= help: the trait `Sync` is not implemented for `*const usize`
= note: shared static variables must have a type that implements `Sync`
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-16538.rs:14:34
|
LL | static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
| ^^^^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0015, E0133, E0277.
For more information about an error, try `rustc --explain E0015`.

2
src/test/ui/issues/issue-28324.stderr → src/test/ui/issues/issue-28324.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-28324.rs:5:24
--> $DIR/issue-28324.rs:8:24
|
LL | pub static BAZ: u32 = *&error_message_count;
| ^^^^^^^^^^^^^^^^^^^^ use of extern static

3
src/test/ui/issues/issue-28324.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
extern "C" {
static error_message_count: u32;
}

11
src/test/ui/issues/issue-28324.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/issue-28324.rs:8:25
|
LL | pub static BAZ: u32 = *&error_message_count;
| ^^^^^^^^^^^^^^^^^^^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

4
src/test/ui/issues/issue-47412.stderr → src/test/ui/issues/issue-47412.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: access to union field is unsafe and requires unsafe function or block
--> $DIR/issue-47412.rs:11:11
--> $DIR/issue-47412.rs:14:11
|
LL | match u.void {}
| ^^^^^^ access to union field
@ -7,7 +7,7 @@ LL | match u.void {}
= note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/issue-47412.rs:17:11
--> $DIR/issue-47412.rs:21:11
|
LL | match *ptr {}
| ^^^^ dereference of raw pointer

6
src/test/ui/issues/issue-47412.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#[derive(Copy, Clone)]
enum Void {}
@ -9,7 +12,8 @@ fn union_field() {
union Union { unit: (), void: Void }
let u = Union { unit: () };
match u.void {}
//~^ ERROR access to union field is unsafe
//[mir]~^ ERROR access to union field is unsafe
// FIXME(thir-unsafeck): AccessToUnionField unimplemented
}
fn raw_ptr_deref() {

11
src/test/ui/issues/issue-47412.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/issue-47412.rs:21:11
|
LL | match *ptr {}
| ^^^^ dereference of raw pointer
|
= note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/rfcs/rfc-2396-target_feature-11/check-pass.rs
View file

@ -8,6 +8,8 @@
// check-pass
// only-x86_64
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![feature(target_feature_11)]

2
src/test/ui/rfcs/rfc-2396-target_feature-11/closures-inherit-target_feature.rs
View file

@ -1,6 +1,8 @@
// Tests #73631: closures inherit `#[target_feature]` annotations
// check-pass
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
// only-x86_64
#![feature(target_feature_11)]

2
src/test/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.stderr → src/test/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/fn-ptr.rs:9:21
--> $DIR/fn-ptr.rs:11:21
|
LL | #[target_feature(enable = "sse2")]
| ---------------------------------- `#[target_feature]` added here

2
src/test/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.rs
View file

@ -1,3 +1,5 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
// only-x86_64
#![feature(target_feature_11)]

18
src/test/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.thir.stderr Normal file
View file

@ -0,0 +1,18 @@
error[E0308]: mismatched types
--> $DIR/fn-ptr.rs:11:21
|
LL | #[target_feature(enable = "sse2")]
| ---------------------------------- `#[target_feature]` added here
...
LL | let foo: fn() = foo;
| ---- ^^^ cannot coerce functions with `#[target_feature]` to safe function pointers
| |
| expected due to this
|
= note: expected fn pointer `fn()`
found fn item `fn() {foo}`
= note: functions with `#[target_feature]` can only be coerced to `unsafe` function pointers
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.

86
src/test/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr → src/test/ui/rfcs/rfc-2396-target_feature-11/safe-calls.mir.stderr
View file

@ -1,69 +1,69 @@
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:21:5
|
LL | sse2();
| ^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:22:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:23:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:28:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:29:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:34:5
|
LL | sse2();
| ^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:35:5
--> $DIR/safe-calls.rs:24:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:25:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:30:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:31:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:36:5
|
LL | sse2();
| ^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:37:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:38:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:42:5
--> $DIR/safe-calls.rs:44:5
|
LL | sse2();
| ^^^^^^ call to function with `#[target_feature]`
@ -71,7 +71,7 @@ LL | sse2();
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:45:18
--> $DIR/safe-calls.rs:47:18
|
LL | const name: () = sse2();
| ^^^^^^ call to function with `#[target_feature]`

2
src/test/ui/rfcs/rfc-2396-target_feature-11/safe-calls.rs
View file

@ -1,3 +1,5 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
// only-x86_64
#![feature(target_feature_11)]

83
src/test/ui/rfcs/rfc-2396-target_feature-11/safe-calls.thir.stderr Normal file
View file

@ -0,0 +1,83 @@
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:23:5
|
LL | sse2();
| ^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:24:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:25:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:30:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:31:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:36:5
|
LL | sse2();
| ^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:37:5
|
LL | avx_bmi2();
| ^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:38:5
|
LL | Quux.avx_bmi2();
| ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:44:5
|
LL | sse2();
| ^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error[E0133]: call to function with `#[target_feature]` is unsafe and requires unsafe function or block
--> $DIR/safe-calls.rs:47:18
|
LL | const name: () = sse2();
| ^^^^^^ call to function with `#[target_feature]`
|
= note: can only be called if the required target features are available
error: aborting due to 10 previous errors
For more information about this error, try `rustc --explain E0133`.

8
src/test/ui/safe-extern-statics-mut.stderr → src/test/ui/safe-extern-statics-mut.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:11:13
--> $DIR/safe-extern-statics-mut.rs:13:13
|
LL | let b = B;
| ^ use of mutable static
@ -7,7 +7,7 @@ LL | let b = B;
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:12:14
--> $DIR/safe-extern-statics-mut.rs:14:14
|
LL | let rb = &B;
| ^^ use of mutable static
@ -15,7 +15,7 @@ LL | let rb = &B;
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:13:14
--> $DIR/safe-extern-statics-mut.rs:15:14
|
LL | let xb = XB;
| ^^ use of mutable static
@ -23,7 +23,7 @@ LL | let xb = XB;
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:14:15
--> $DIR/safe-extern-statics-mut.rs:16:15
|
LL | let xrb = &XB;
| ^^^ use of mutable static

2
src/test/ui/safe-extern-statics-mut.rs
View file

@ -1,4 +1,6 @@
// aux-build:extern-statics.rs
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
extern crate extern_statics;
use extern_statics::*;

35
src/test/ui/safe-extern-statics-mut.thir.stderr Normal file
View file

@ -0,0 +1,35 @@
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:13:13
|
LL | let b = B;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:14:15
|
LL | let rb = &B;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:15:14
|
LL | let xb = XB;
| ^^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics-mut.rs:16:16
|
LL | let xrb = &XB;
| ^^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0133`.

8
src/test/ui/safe-extern-statics.stderr → src/test/ui/safe-extern-statics.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:11:13
--> $DIR/safe-extern-statics.rs:13:13
|
LL | let a = A;
| ^ use of extern static
@ -7,7 +7,7 @@ LL | let a = A;
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:12:14
--> $DIR/safe-extern-statics.rs:14:14
|
LL | let ra = &A;
| ^^ use of extern static
@ -15,7 +15,7 @@ LL | let ra = &A;
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:13:14
--> $DIR/safe-extern-statics.rs:15:14
|
LL | let xa = XA;
| ^^ use of extern static
@ -23,7 +23,7 @@ LL | let xa = XA;
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:14:15
--> $DIR/safe-extern-statics.rs:16:15
|
LL | let xra = &XA;
| ^^^ use of extern static

2
src/test/ui/safe-extern-statics.rs
View file

@ -1,4 +1,6 @@
// aux-build:extern-statics.rs
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
extern crate extern_statics;
use extern_statics::*;

35
src/test/ui/safe-extern-statics.thir.stderr Normal file
View file

@ -0,0 +1,35 @@
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:13:13
|
LL | let a = A;
| ^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:14:15
|
LL | let ra = &A;
| ^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:15:14
|
LL | let xa = XA;
| ^^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error[E0133]: use of extern static is unsafe and requires unsafe function or block
--> $DIR/safe-extern-statics.rs:16:16
|
LL | let xra = &XA;
| ^^ use of extern static
|
= note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0133`.

6
src/test/ui/static/static-mut-foreign-requires-unsafe.stderr → src/test/ui/static/static-mut-foreign-requires-unsafe.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-foreign-requires-unsafe.rs:6:5
--> $DIR/static-mut-foreign-requires-unsafe.rs:9:5
|
LL | a += 3;
| ^^^^^^ use of mutable static
@ -7,7 +7,7 @@ LL | a += 3;
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-foreign-requires-unsafe.rs:7:5
--> $DIR/static-mut-foreign-requires-unsafe.rs:10:5
|
LL | a = 4;
| ^^^^^ use of mutable static
@ -15,7 +15,7 @@ LL | a = 4;
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-foreign-requires-unsafe.rs:8:14
--> $DIR/static-mut-foreign-requires-unsafe.rs:11:14
|
LL | let _b = a;
| ^ use of mutable static

3
src/test/ui/static/static-mut-foreign-requires-unsafe.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
extern "C" {
static mut a: i32;
}

27
src/test/ui/static/static-mut-foreign-requires-unsafe.thir.stderr Normal file
View file

@ -0,0 +1,27 @@
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-foreign-requires-unsafe.rs:9:5
|
LL | a += 3;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-foreign-requires-unsafe.rs:10:5
|
LL | a = 4;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-foreign-requires-unsafe.rs:11:14
|
LL | let _b = a;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0133`.

6
src/test/ui/static/static-mut-requires-unsafe.stderr → src/test/ui/static/static-mut-requires-unsafe.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-requires-unsafe.rs:4:5
--> $DIR/static-mut-requires-unsafe.rs:7:5
|
LL | a += 3;
| ^^^^^^ use of mutable static
@ -7,7 +7,7 @@ LL | a += 3;
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-requires-unsafe.rs:5:5
--> $DIR/static-mut-requires-unsafe.rs:8:5
|
LL | a = 4;
| ^^^^^ use of mutable static
@ -15,7 +15,7 @@ LL | a = 4;
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-requires-unsafe.rs:6:14
--> $DIR/static-mut-requires-unsafe.rs:9:14
|
LL | let _b = a;
| ^ use of mutable static

3
src/test/ui/static/static-mut-requires-unsafe.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
static mut a: isize = 3;
fn main() {

27
src/test/ui/static/static-mut-requires-unsafe.thir.stderr Normal file
View file

@ -0,0 +1,27 @@
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-requires-unsafe.rs:7:5
|
LL | a += 3;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-requires-unsafe.rs:8:5
|
LL | a = 4;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error[E0133]: use of mutable static is unsafe and requires unsafe function or block
--> $DIR/static-mut-requires-unsafe.rs:9:14
|
LL | let _b = a;
| ^ use of mutable static
|
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/traits/safety-fn-body.stderr → src/test/ui/traits/safety-fn-body.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/safety-fn-body.rs:11:9
--> $DIR/safety-fn-body.rs:14:9
|
LL | *self += 1;
| ^^^^^^^^^^ dereference of raw pointer

3
src/test/ui/traits/safety-fn-body.rs
View file

@ -1,6 +1,9 @@
// Check that an unsafe impl does not imply that unsafe actions are
// legal in the methods.
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
unsafe trait UnsafeTrait : Sized {
fn foo(self) { }
}

11
src/test/ui/traits/safety-fn-body.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/safety-fn-body.rs:14:9
|
LL | *self += 1;
| ^^^^^ dereference of raw pointer
|
= note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/unsafe/issue-45087-unreachable-unsafe.stderr → src/test/ui/unsafe/issue-45087-unreachable-unsafe.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/issue-45087-unreachable-unsafe.rs:3:5
--> $DIR/issue-45087-unreachable-unsafe.rs:6:5
|
LL | *(1 as *mut u32) = 42;
| ^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer

3
src/test/ui/unsafe/issue-45087-unreachable-unsafe.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
fn main() {
return;
*(1 as *mut u32) = 42;

11
src/test/ui/unsafe/issue-45087-unreachable-unsafe.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/issue-45087-unreachable-unsafe.rs:6:5
|
LL | *(1 as *mut u32) = 42;
| ^^^^^^^^^^^^^^^^ dereference of raw pointer
|
= note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/unsafe/ranged_ints.stderr → src/test/ui/unsafe/ranged_ints.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe function or block
--> $DIR/ranged_ints.rs:7:14
--> $DIR/ranged_ints.rs:10:14
|
LL | let _x = NonZero(0);
| ^^^^^^^^^^ initializing type with `rustc_layout_scalar_valid_range` attr

3
src/test/ui/unsafe/ranged_ints.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![feature(rustc_attrs)]
#[rustc_layout_scalar_valid_range_start(1)]

11
src/test/ui/unsafe/ranged_ints.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe function or block
--> $DIR/ranged_ints.rs:10:14
|
LL | let _x = NonZero(0);
| ^^^^^^^^^^ initializing type with `rustc_layout_scalar_valid_range` attr
|
= note: initializing a layout restricted type's field with a value outside the valid range is undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/unsafe/ranged_ints_const.stderr → src/test/ui/unsafe/ranged_ints_const.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe function or block
--> $DIR/ranged_ints_const.rs:8:34
--> $DIR/ranged_ints_const.rs:11:34
|
LL | const fn foo() -> NonZero<u32> { NonZero(0) }
| ^^^^^^^^^^ initializing type with `rustc_layout_scalar_valid_range` attr

3
src/test/ui/unsafe/ranged_ints_const.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![feature(rustc_attrs)]
#[rustc_layout_scalar_valid_range_start(1)]

11
src/test/ui/unsafe/ranged_ints_const.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe function or block
--> $DIR/ranged_ints_const.rs:11:34
|
LL | const fn foo() -> NonZero<u32> { NonZero(0) }
| ^^^^^^^^^^ initializing type with `rustc_layout_scalar_valid_range` attr
|
= note: initializing a layout restricted type's field with a value outside the valid range is undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

3
src/test/ui/unsafe/ranged_ints_macro.rs
View file

@ -1,4 +1,7 @@
// build-pass
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![feature(rustc_attrs)]
macro_rules! apply {

2
src/test/ui/unsafe/unsafe-fn-assign-deref-ptr.stderr → src/test/ui/unsafe/unsafe-fn-assign-deref-ptr.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/unsafe-fn-assign-deref-ptr.rs:2:5
--> $DIR/unsafe-fn-assign-deref-ptr.rs:5:5
|
LL | *p = 0;
| ^^^^^^ dereference of raw pointer

3
src/test/ui/unsafe/unsafe-fn-assign-deref-ptr.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
fn f(p: *mut u8) {
*p = 0; //~ ERROR dereference of raw pointer is unsafe
return;

11
src/test/ui/unsafe/unsafe-fn-assign-deref-ptr.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/unsafe-fn-assign-deref-ptr.rs:5:5
|
LL | *p = 0;
| ^^ dereference of raw pointer
|
= note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/unsafe/unsafe-fn-deref-ptr.stderr → src/test/ui/unsafe/unsafe-fn-deref-ptr.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/unsafe-fn-deref-ptr.rs:2:12
--> $DIR/unsafe-fn-deref-ptr.rs:5:12
|
LL | return *p;
| ^^ dereference of raw pointer

3
src/test/ui/unsafe/unsafe-fn-deref-ptr.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
fn f(p: *const u8) -> u8 {
return *p; //~ ERROR dereference of raw pointer is unsafe
}

11
src/test/ui/unsafe/unsafe-fn-deref-ptr.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/unsafe-fn-deref-ptr.rs:5:12
|
LL | return *p;
| ^^ dereference of raw pointer
|
= note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

2
src/test/ui/unsafe/unsafe-unstable-const-fn.stderr → src/test/ui/unsafe/unsafe-unstable-const-fn.mir.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/unsafe-unstable-const-fn.rs:8:5
--> $DIR/unsafe-unstable-const-fn.rs:11:5
|
LL | *a == b
| ^^ dereference of raw pointer

3
src/test/ui/unsafe/unsafe-unstable-const-fn.rs
View file

@ -1,3 +1,6 @@
// revisions: mir thir
// [thir]compile-flags: -Z thir-unsafeck
#![stable(feature = "foo", since = "1.33.0")]
#![feature(staged_api)]
#![feature(const_raw_ptr_deref)]

11
src/test/ui/unsafe/unsafe-unstable-const-fn.thir.stderr Normal file
View file

@ -0,0 +1,11 @@
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
--> $DIR/unsafe-unstable-const-fn.rs:11:5
|
LL | *a == b
| ^^ dereference of raw pointer
|
= note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
For more information about this error, try `rustc --explain E0133`.

4
src/tools/tidy/src/ui_tests.rs
View file

@ -7,8 +7,8 @@ use std::path::Path;
const ENTRY_LIMIT: usize = 1000;
// FIXME: The following limits should be reduced eventually.
const ROOT_ENTRY_LIMIT: usize = 1370;
const ISSUES_ENTRY_LIMIT: usize = 2555;
const ROOT_ENTRY_LIMIT: usize = 1371;
const ISSUES_ENTRY_LIMIT: usize = 2558;
fn check_entries(path: &Path, bad: &mut bool) {
let dirs = walkdir::WalkDir::new(&path.join("test/ui"))