Auto merge of #90235 - matthiaskrgr:rollup-7pqtevk, r=matthiaskrgr
Rollup of 6 pull requests Successful merges: - #89558 (Add rustc lint, warning when iterating over hashmaps) - #90100 (Skip documentation for tier 2 targets on dist-x86_64-apple-darwin) - #90155 (Fix alignment of method headings for scannability) - #90162 (Mark `{array, slice}::{from_ref, from_mut}` as const fn) - #90221 (Fix ICE when forgetting to `Box` a parameter to a `Self::func` call) - #90234 (Temporarily turn overflow checks off for rustc-rayon-core) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
00d5e42e77
58 changed files with 409 additions and 98 deletions
15
.github/workflows/ci.yml
vendored
15
.github/workflows/ci.yml
vendored
|
|
@ -287,7 +287,7 @@ jobs:
|
|||
os: ubuntu-latest-xl
|
||||
- name: dist-x86_64-apple
|
||||
env:
|
||||
SCRIPT: "./x.py dist"
|
||||
SCRIPT: "./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended"
|
||||
RUST_CONFIGURE_ARGS: "--host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false"
|
||||
RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
|
||||
MACOSX_DEPLOYMENT_TARGET: 10.7
|
||||
|
|
@ -532,9 +532,16 @@ jobs:
|
|||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- name: dist-x86_64-linux
|
||||
os: ubuntu-latest-xl
|
||||
env: {}
|
||||
- name: dist-x86_64-apple
|
||||
env:
|
||||
SCRIPT: "./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended"
|
||||
RUST_CONFIGURE_ARGS: "--host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false"
|
||||
RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
|
||||
MACOSX_DEPLOYMENT_TARGET: 10.7
|
||||
NO_LLVM_ASSERTIONS: 1
|
||||
NO_DEBUG_ASSERTIONS: 1
|
||||
DIST_REQUIRE_ALL_TOOLS: 1
|
||||
os: macos-latest
|
||||
timeout-minutes: 600
|
||||
runs-on: "${{ matrix.os }}"
|
||||
steps:
|
||||
|
|
|
|||
|
|
@ -77,6 +77,13 @@ overflow-checks = false
|
|||
# per-crate configuration isn't specifiable in the environment.
|
||||
codegen-units = 10000
|
||||
|
||||
[profile.release.package.rustc-rayon-core]
|
||||
# The rustc fork of Rayon has deadlock detection code which intermittently
|
||||
# causes overflows in the CI (see https://github.com/rust-lang/rust/issues/90227)
|
||||
# so we turn overflow checks off for now.
|
||||
# FIXME: This workaround should be removed once #90227 is fixed.
|
||||
overflow-checks = false
|
||||
|
||||
# These dependencies of the standard library implement symbolication for
|
||||
# backtraces on most platforms. Their debuginfo causes both linking to be slower
|
||||
# (more data to chew through) and binaries to be larger without really all that
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@
|
|||
#![feature(iter_zip)]
|
||||
#![feature(never_type)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
use rustc_ast::token::{self, Token};
|
||||
use rustc_ast::tokenstream::{CanSynthesizeMissingTokens, TokenStream, TokenTree};
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
#![feature(iter_is_partitioned)]
|
||||
#![feature(box_patterns)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
pub mod ast_validation;
|
||||
pub mod feature_gate;
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@
|
|||
#![feature(trusted_step)]
|
||||
#![feature(try_blocks)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_middle;
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@
|
|||
#![feature(proc_macro_internals)]
|
||||
#![feature(proc_macro_quote)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
extern crate proc_macro;
|
||||
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@
|
|||
#![feature(iter_zip)]
|
||||
#![feature(nll)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
use back::write::{create_informational_target_machine, create_target_machine};
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#![feature(nll)]
|
||||
#![feature(associated_type_bounds)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
//! This crate contains codegen code that is used by all codegen backends (LLVM and others).
|
||||
//! The backend-agnostic functions of this crate use functions defined in various traits that
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ Rust MIR: a lowered representation of Rust.
|
|||
#![feature(trusted_step)]
|
||||
#![feature(try_blocks)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
#![feature(thread_id_value)]
|
||||
#![allow(rustc::default_hash_types)]
|
||||
#![deny(unaligned_references)]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#![feature(nll)]
|
||||
#![feature(once_cell)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
@ -846,7 +847,7 @@ Available lint options:
|
|||
let builtin = sort_lints(sess, builtin);
|
||||
|
||||
let (plugin_groups, builtin_groups): (Vec<_>, _) =
|
||||
lint_store.get_lint_groups().iter().cloned().partition(|&(.., p)| p);
|
||||
lint_store.get_lint_groups().partition(|&(.., p)| p);
|
||||
let plugin_groups = sort_lint_groups(plugin_groups);
|
||||
let builtin_groups = sort_lint_groups(builtin_groups);
|
||||
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@
|
|||
#![feature(iter_zip)]
|
||||
#![feature(let_else)]
|
||||
#![feature(nll)]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@
|
|||
#![feature(proc_macro_span)]
|
||||
#![feature(try_blocks)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
|
|
|||
|
|
@ -460,6 +460,9 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
|
|||
// Prevents field reads in the marked trait or method to be considered
|
||||
// during dead code analysis.
|
||||
rustc_attr!(rustc_trivial_field_reads, Normal, template!(Word), INTERNAL_UNSTABLE),
|
||||
// Used by the `rustc::potential_query_instability` lint to warn methods which
|
||||
// might not be stable during incremental compilation.
|
||||
rustc_attr!(rustc_lint_query_instability, Normal, template!(Word), INTERNAL_UNSTABLE),
|
||||
|
||||
// ==========================================================================
|
||||
// Internal attributes, Const related:
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
#![feature(let_else)]
|
||||
#![feature(nll)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_middle;
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@
|
|||
#![feature(min_specialization)]
|
||||
#![feature(label_break_value)]
|
||||
#![recursion_limit = "512"] // For rustdoc
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
#![feature(nll)]
|
||||
#![feature(once_cell)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
mod callbacks;
|
||||
pub mod interface;
|
||||
|
|
|
|||
|
|
@ -144,7 +144,11 @@ impl LintStore {
|
|||
&self.lints
|
||||
}
|
||||
|
||||
pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec<LintId>, bool)> {
|
||||
pub fn get_lint_groups<'t>(
|
||||
&'t self,
|
||||
) -> impl Iterator<Item = (&'static str, Vec<LintId>, bool)> + 't {
|
||||
// This function is not used in a way which observes the order of lints.
|
||||
#[cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
self.lint_groups
|
||||
.iter()
|
||||
.filter(|(_, LintGroup { depr, .. })| {
|
||||
|
|
@ -154,7 +158,6 @@ impl LintStore {
|
|||
.map(|(k, LintGroup { lint_ids, from_plugin, .. })| {
|
||||
(*k, lint_ids.clone(), *from_plugin)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn register_early_pass(
|
||||
|
|
|
|||
|
|
@ -5,10 +5,7 @@ use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext}
|
|||
use rustc_ast as ast;
|
||||
use rustc_errors::Applicability;
|
||||
use rustc_hir::def::Res;
|
||||
use rustc_hir::{
|
||||
GenericArg, HirId, Item, ItemKind, MutTy, Mutability, Node, Path, PathSegment, QPath, Ty,
|
||||
TyKind,
|
||||
};
|
||||
use rustc_hir::*;
|
||||
use rustc_middle::ty;
|
||||
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
||||
use rustc_span::hygiene::{ExpnKind, MacroKind};
|
||||
|
|
@ -51,6 +48,60 @@ impl LateLintPass<'_> for DefaultHashTypes {
|
|||
}
|
||||
}
|
||||
|
||||
declare_tool_lint! {
|
||||
pub rustc::POTENTIAL_QUERY_INSTABILITY,
|
||||
Allow,
|
||||
"require explicit opt-in when using potentially unstable methods or functions",
|
||||
report_in_external_macro: true
|
||||
}
|
||||
|
||||
declare_lint_pass!(QueryStability => [POTENTIAL_QUERY_INSTABILITY]);
|
||||
|
||||
impl LateLintPass<'_> for QueryStability {
|
||||
fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
|
||||
// FIXME(rustdoc): This lint uses typecheck results, causing rustdoc to
|
||||
// error if there are resolution failures.
|
||||
//
|
||||
// As internal lints are currently always run if there are `unstable_options`,
|
||||
// they are added to the lint store of rustdoc. Internal lints are also
|
||||
// not used via the `lint_mod` query. Crate lints run outside of a query
|
||||
// so rustdoc currently doesn't disable them.
|
||||
//
|
||||
// Instead of relying on this, either change crate lints to a query disabled by
|
||||
// rustdoc, only run internal lints if the user is explicitly opting in
|
||||
// or figure out a different way to avoid running lints for rustdoc.
|
||||
if cx.tcx.sess.opts.actually_rustdoc {
|
||||
return;
|
||||
}
|
||||
|
||||
let (def_id, span) = match expr.kind {
|
||||
ExprKind::Path(ref path) if let Some(def_id) = cx.qpath_res(path, expr.hir_id).opt_def_id() => {
|
||||
(def_id, expr.span)
|
||||
}
|
||||
ExprKind::MethodCall(_, span, _, _) if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) => {
|
||||
(def_id, span)
|
||||
},
|
||||
_ => return,
|
||||
};
|
||||
|
||||
let substs = cx.typeck_results().node_substs(expr.hir_id);
|
||||
if let Ok(Some(instance)) = ty::Instance::resolve(cx.tcx, cx.param_env, def_id, substs) {
|
||||
let def_id = instance.def_id();
|
||||
if cx.tcx.has_attr(def_id, sym::rustc_lint_query_instability) {
|
||||
cx.struct_span_lint(POTENTIAL_QUERY_INSTABILITY, span, |lint| {
|
||||
let msg = format!(
|
||||
"using `{}` can result in unstable query results",
|
||||
cx.tcx.item_name(def_id)
|
||||
);
|
||||
lint.build(&msg)
|
||||
.note("if you believe this case to be fine, allow this lint and add a comment explaining your rationale")
|
||||
.emit();
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
declare_tool_lint! {
|
||||
pub rustc::USAGE_OF_TY_TYKIND,
|
||||
Allow,
|
||||
|
|
|
|||
|
|
@ -31,12 +31,14 @@
|
|||
#![feature(box_patterns)]
|
||||
#![feature(crate_visibility_modifier)]
|
||||
#![feature(format_args_capture)]
|
||||
#![feature(if_let_guard)]
|
||||
#![feature(iter_order_by)]
|
||||
#![feature(iter_zip)]
|
||||
#![feature(never_type)]
|
||||
#![feature(nll)]
|
||||
#![feature(control_flow_enum)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_middle;
|
||||
|
|
@ -484,6 +486,8 @@ fn register_internals(store: &mut LintStore) {
|
|||
store.register_early_pass(|| Box::new(LintPassImpl));
|
||||
store.register_lints(&DefaultHashTypes::get_lints());
|
||||
store.register_late_pass(|| Box::new(DefaultHashTypes));
|
||||
store.register_lints(&QueryStability::get_lints());
|
||||
store.register_late_pass(|| Box::new(QueryStability));
|
||||
store.register_lints(&ExistingDocKeyword::get_lints());
|
||||
store.register_late_pass(|| Box::new(ExistingDocKeyword));
|
||||
store.register_lints(&TyTyKind::get_lints());
|
||||
|
|
@ -494,6 +498,7 @@ fn register_internals(store: &mut LintStore) {
|
|||
None,
|
||||
vec![
|
||||
LintId::of(DEFAULT_HASH_TYPES),
|
||||
LintId::of(POTENTIAL_QUERY_INSTABILITY),
|
||||
LintId::of(USAGE_OF_TY_TYKIND),
|
||||
LintId::of(LINT_PASS_IMPL_WITHOUT_MACRO),
|
||||
LintId::of(TY_PASS_BY_REFERENCE),
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@
|
|||
#![feature(try_blocks)]
|
||||
#![feature(never_type)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
extern crate proc_macro;
|
||||
|
||||
|
|
|
|||
|
|
@ -56,6 +56,7 @@
|
|||
#![feature(try_reserve_kind)]
|
||||
#![feature(nonzero_ops)]
|
||||
#![recursion_limit = "512"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate bitflags;
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@
|
|||
#![feature(once_cell)]
|
||||
#![feature(min_specialization)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@
|
|||
#![feature(trusted_step)]
|
||||
#![feature(try_blocks)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
#![feature(let_else)]
|
||||
#![feature(in_band_lifetimes)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
fn check_attributes(
|
||||
&self,
|
||||
hir_id: HirId,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
item: Option<ItemLike<'_>>,
|
||||
) {
|
||||
|
|
@ -78,7 +78,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
sym::marker => self.check_marker(hir_id, attr, span, target),
|
||||
sym::target_feature => self.check_target_feature(hir_id, attr, span, target),
|
||||
sym::track_caller => {
|
||||
self.check_track_caller(hir_id, &attr.span, attrs, span, target)
|
||||
self.check_track_caller(hir_id, attr.span, attrs, span, target)
|
||||
}
|
||||
sym::doc => self.check_doc_attrs(
|
||||
attr,
|
||||
|
|
@ -103,6 +103,9 @@ impl CheckAttrVisitor<'tcx> {
|
|||
sym::rustc_legacy_const_generics => {
|
||||
self.check_rustc_legacy_const_generics(&attr, span, target, item)
|
||||
}
|
||||
sym::rustc_lint_query_instability => {
|
||||
self.check_rustc_lint_query_instability(&attr, span, target)
|
||||
}
|
||||
sym::rustc_clean
|
||||
| sym::rustc_dirty
|
||||
| sym::rustc_if_this_changed
|
||||
|
|
@ -230,7 +233,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if an `#[inline]` is applied to a function or a closure. Returns `true` if valid.
|
||||
fn check_inline(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
|
||||
fn check_inline(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
|
||||
match target {
|
||||
Target::Fn
|
||||
| Target::Closure
|
||||
|
|
@ -273,7 +276,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
E0518,
|
||||
"attribute should be applied to function or closure",
|
||||
)
|
||||
.span_label(*span, "not a function or closure")
|
||||
.span_label(span, "not a function or closure")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -312,7 +315,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[naked]` is applied to a function definition.
|
||||
fn check_naked(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
|
||||
fn check_naked(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
|
||||
match target {
|
||||
Target::Fn
|
||||
| Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
|
||||
|
|
@ -331,7 +334,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
attr.span,
|
||||
"attribute should be applied to a function definition",
|
||||
)
|
||||
.span_label(*span, "not a function definition")
|
||||
.span_label(span, "not a function definition")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -339,7 +342,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[cmse_nonsecure_entry]` is applied to a function definition.
|
||||
fn check_cmse_nonsecure_entry(&self, attr: &Attribute, span: &Span, target: Target) -> bool {
|
||||
fn check_cmse_nonsecure_entry(&self, attr: &Attribute, span: Span, target: Target) -> bool {
|
||||
match target {
|
||||
Target::Fn
|
||||
| Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
|
||||
|
|
@ -350,7 +353,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
attr.span,
|
||||
"attribute should be applied to a function definition",
|
||||
)
|
||||
.span_label(*span, "not a function definition")
|
||||
.span_label(span, "not a function definition")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -361,16 +364,16 @@ impl CheckAttrVisitor<'tcx> {
|
|||
fn check_track_caller(
|
||||
&self,
|
||||
hir_id: HirId,
|
||||
attr_span: &Span,
|
||||
attr_span: Span,
|
||||
attrs: &'hir [Attribute],
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
match target {
|
||||
_ if attrs.iter().any(|attr| attr.has_name(sym::naked)) => {
|
||||
struct_span_err!(
|
||||
self.tcx.sess,
|
||||
*attr_span,
|
||||
attr_span,
|
||||
E0736,
|
||||
"cannot use `#[track_caller]` with `#[naked]`",
|
||||
)
|
||||
|
|
@ -391,11 +394,11 @@ impl CheckAttrVisitor<'tcx> {
|
|||
_ => {
|
||||
struct_span_err!(
|
||||
self.tcx.sess,
|
||||
*attr_span,
|
||||
attr_span,
|
||||
E0739,
|
||||
"attribute should be applied to function"
|
||||
)
|
||||
.span_label(*span, "not a function")
|
||||
.span_label(span, "not a function")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -407,7 +410,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
&self,
|
||||
hir_id: HirId,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
match target {
|
||||
|
|
@ -427,7 +430,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
E0701,
|
||||
"attribute can only be applied to a struct or enum"
|
||||
)
|
||||
.span_label(*span, "not a struct or enum")
|
||||
.span_label(span, "not a struct or enum")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -435,7 +438,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if the `#[marker]` attribute on an `item` is valid. Returns `true` if valid.
|
||||
fn check_marker(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
|
||||
fn check_marker(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
|
||||
match target {
|
||||
Target::Trait => true,
|
||||
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
|
||||
|
|
@ -450,7 +453,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "attribute can only be applied to a trait")
|
||||
.span_label(*span, "not a trait")
|
||||
.span_label(span, "not a trait")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -462,7 +465,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
&self,
|
||||
hir_id: HirId,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
match target {
|
||||
|
|
@ -478,7 +481,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
being phased out; it will become a hard error in \
|
||||
a future release!",
|
||||
)
|
||||
.span_label(*span, "not a function")
|
||||
.span_label(span, "not a function")
|
||||
.emit();
|
||||
});
|
||||
true
|
||||
|
|
@ -495,7 +498,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "attribute should be applied to a function")
|
||||
.span_label(*span, "not a function")
|
||||
.span_label(span, "not a function")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -1047,14 +1050,14 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[must_not_suspend]` is applied to a function. Returns `true` if valid.
|
||||
fn check_must_not_suspend(&self, attr: &Attribute, span: &Span, target: Target) -> bool {
|
||||
fn check_must_not_suspend(&self, attr: &Attribute, span: Span, target: Target) -> bool {
|
||||
match target {
|
||||
Target::Struct | Target::Enum | Target::Union | Target::Trait => true,
|
||||
_ => {
|
||||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "`must_not_suspend` attribute should be applied to a struct, enum, or trait")
|
||||
.span_label(*span, "is not a struct, enum, or trait")
|
||||
.span_label(span, "is not a struct, enum, or trait")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -1062,7 +1065,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[cold]` is applied to a non-function. Returns `true` if valid.
|
||||
fn check_cold(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
|
||||
fn check_cold(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
|
||||
match target {
|
||||
Target::Fn | Target::Method(..) | Target::ForeignFn | Target::Closure => {}
|
||||
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
|
||||
|
|
@ -1082,7 +1085,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
being phased out; it will become a hard error in \
|
||||
a future release!",
|
||||
)
|
||||
.span_label(*span, "not a function")
|
||||
.span_label(span, "not a function")
|
||||
.emit();
|
||||
});
|
||||
}
|
||||
|
|
@ -1090,7 +1093,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[link_name]` is applied to an item other than a foreign function or static.
|
||||
fn check_link_name(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
|
||||
fn check_link_name(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
|
||||
match target {
|
||||
Target::ForeignFn | Target::ForeignStatic => {}
|
||||
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
|
||||
|
|
@ -1124,7 +1127,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
diag.span_label(*span, "not a foreign function or static");
|
||||
diag.span_label(span, "not a foreign function or static");
|
||||
diag.emit();
|
||||
});
|
||||
}
|
||||
|
|
@ -1132,7 +1135,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[no_link]` is applied to an `extern crate`. Returns `true` if valid.
|
||||
fn check_no_link(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
|
||||
fn check_no_link(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
|
||||
match target {
|
||||
Target::ExternCrate => true,
|
||||
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
|
||||
|
|
@ -1150,7 +1153,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
attr.span,
|
||||
"attribute should be applied to an `extern crate` item",
|
||||
)
|
||||
.span_label(*span, "not an `extern crate` item")
|
||||
.span_label(span, "not an `extern crate` item")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -1166,7 +1169,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
&self,
|
||||
hir_id: HirId,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
match target {
|
||||
|
|
@ -1187,7 +1190,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
attr.span,
|
||||
"attribute should be applied to a free function, impl method or static",
|
||||
)
|
||||
.span_label(*span, "not a free function, impl method or static")
|
||||
.span_label(span, "not a free function, impl method or static")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -1197,14 +1200,14 @@ impl CheckAttrVisitor<'tcx> {
|
|||
fn check_rustc_layout_scalar_valid_range(
|
||||
&self,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
if target != Target::Struct {
|
||||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "attribute should be applied to a struct")
|
||||
.span_label(*span, "not a struct")
|
||||
.span_label(span, "not a struct")
|
||||
.emit();
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1229,7 +1232,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
fn check_rustc_legacy_const_generics(
|
||||
&self,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
item: Option<ItemLike<'_>>,
|
||||
) -> bool {
|
||||
|
|
@ -1238,7 +1241,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "attribute should be applied to a function")
|
||||
.span_label(*span, "not a function")
|
||||
.span_label(span, "not a function")
|
||||
.emit();
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1324,6 +1327,25 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
fn check_rustc_lint_query_instability(
|
||||
&self,
|
||||
attr: &Attribute,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
let is_function = matches!(target, Target::Fn | Target::Method(..));
|
||||
if !is_function {
|
||||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "attribute should be applied to a function")
|
||||
.span_label(span, "not a function")
|
||||
.emit();
|
||||
false
|
||||
} else {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks that the dep-graph debugging attributes are only present when the query-dep-graph
|
||||
/// option is passed to the compiler.
|
||||
fn check_rustc_dirty_clean(&self, attr: &Attribute) -> bool {
|
||||
|
|
@ -1339,7 +1361,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[link_section]` is applied to a function or static.
|
||||
fn check_link_section(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
|
||||
fn check_link_section(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
|
||||
match target {
|
||||
Target::Static | Target::Fn | Target::Method(..) => {}
|
||||
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
|
||||
|
|
@ -1359,7 +1381,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
being phased out; it will become a hard error in \
|
||||
a future release!",
|
||||
)
|
||||
.span_label(*span, "not a function or static")
|
||||
.span_label(span, "not a function or static")
|
||||
.emit();
|
||||
});
|
||||
}
|
||||
|
|
@ -1367,7 +1389,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
/// Checks if `#[no_mangle]` is applied to a function or static.
|
||||
fn check_no_mangle(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
|
||||
fn check_no_mangle(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
|
||||
match target {
|
||||
Target::Static | Target::Fn => {}
|
||||
Target::Method(..) if self.is_impl_item(hir_id) => {}
|
||||
|
|
@ -1397,7 +1419,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
being phased out; it will become a hard error in \
|
||||
a future release!",
|
||||
)
|
||||
.span_label(*span, format!("foreign {}", foreign_item_kind))
|
||||
.span_label(span, format!("foreign {}", foreign_item_kind))
|
||||
.note("symbol names in extern blocks are not mangled")
|
||||
.span_suggestion(
|
||||
attr.span,
|
||||
|
|
@ -1420,7 +1442,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
being phased out; it will become a hard error in \
|
||||
a future release!",
|
||||
)
|
||||
.span_label(*span, "not a free function, impl method or static")
|
||||
.span_label(span, "not a free function, impl method or static")
|
||||
.emit();
|
||||
});
|
||||
}
|
||||
|
|
@ -1431,7 +1453,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
fn check_repr(
|
||||
&self,
|
||||
attrs: &'hir [Attribute],
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
item: Option<ItemLike<'_>>,
|
||||
hir_id: HirId,
|
||||
|
|
@ -1565,7 +1587,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
"{}",
|
||||
&format!("attribute should be applied to {} {}", article, allowed_targets)
|
||||
)
|
||||
.span_label(*span, &format!("not {} {}", article, allowed_targets))
|
||||
.span_label(span, &format!("not {} {}", article, allowed_targets))
|
||||
.emit();
|
||||
}
|
||||
|
||||
|
|
@ -1628,7 +1650,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
&self,
|
||||
hir_id: HirId,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
attrs: &[Attribute],
|
||||
) -> bool {
|
||||
|
|
@ -1661,7 +1683,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "attribute should be applied to a macro")
|
||||
.span_label(*span, "not a macro")
|
||||
.span_label(span, "not a macro")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -1674,7 +1696,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
&self,
|
||||
hir_id: HirId,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
match target {
|
||||
|
|
@ -1695,7 +1717,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
self.tcx
|
||||
.sess
|
||||
.struct_span_err(attr.span, "attribute should be applied to `const fn`")
|
||||
.span_label(*span, "not a `const fn`")
|
||||
.span_label(span, "not a `const fn`")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
|
|
@ -1706,7 +1728,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
fn check_default_method_body_is_const(
|
||||
&self,
|
||||
attr: &Attribute,
|
||||
span: &Span,
|
||||
span: Span,
|
||||
target: Target,
|
||||
) -> bool {
|
||||
match target {
|
||||
|
|
@ -1718,14 +1740,14 @@ impl CheckAttrVisitor<'tcx> {
|
|||
attr.span,
|
||||
"attribute should be applied to a trait method with body",
|
||||
)
|
||||
.span_label(*span, "not a trait method or missing a body")
|
||||
.span_label(span, "not a trait method or missing a body")
|
||||
.emit();
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_stability_promotable(&self, attr: &Attribute, _span: &Span, target: Target) -> bool {
|
||||
fn check_stability_promotable(&self, attr: &Attribute, _span: Span, target: Target) -> bool {
|
||||
match target {
|
||||
Target::Expression => {
|
||||
self.tcx
|
||||
|
|
@ -1738,7 +1760,7 @@ impl CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
fn check_deprecated(&self, hir_id: HirId, attr: &Attribute, _span: &Span, target: Target) {
|
||||
fn check_deprecated(&self, hir_id: HirId, attr: &Attribute, _span: Span, target: Target) {
|
||||
match target {
|
||||
Target::Closure | Target::Expression | Target::Statement | Target::Arm => {
|
||||
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
|
||||
|
|
@ -1810,29 +1832,29 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
|
|||
}
|
||||
|
||||
let target = Target::from_item(item);
|
||||
self.check_attributes(item.hir_id(), &item.span, target, Some(ItemLike::Item(item)));
|
||||
self.check_attributes(item.hir_id(), item.span, target, Some(ItemLike::Item(item)));
|
||||
intravisit::walk_item(self, item)
|
||||
}
|
||||
|
||||
fn visit_generic_param(&mut self, generic_param: &'tcx hir::GenericParam<'tcx>) {
|
||||
let target = Target::from_generic_param(generic_param);
|
||||
self.check_attributes(generic_param.hir_id, &generic_param.span, target, None);
|
||||
self.check_attributes(generic_param.hir_id, generic_param.span, target, None);
|
||||
intravisit::walk_generic_param(self, generic_param)
|
||||
}
|
||||
|
||||
fn visit_trait_item(&mut self, trait_item: &'tcx TraitItem<'tcx>) {
|
||||
let target = Target::from_trait_item(trait_item);
|
||||
self.check_attributes(trait_item.hir_id(), &trait_item.span, target, None);
|
||||
self.check_attributes(trait_item.hir_id(), trait_item.span, target, None);
|
||||
intravisit::walk_trait_item(self, trait_item)
|
||||
}
|
||||
|
||||
fn visit_field_def(&mut self, struct_field: &'tcx hir::FieldDef<'tcx>) {
|
||||
self.check_attributes(struct_field.hir_id, &struct_field.span, Target::Field, None);
|
||||
self.check_attributes(struct_field.hir_id, struct_field.span, Target::Field, None);
|
||||
intravisit::walk_field_def(self, struct_field);
|
||||
}
|
||||
|
||||
fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) {
|
||||
self.check_attributes(arm.hir_id, &arm.span, Target::Arm, None);
|
||||
self.check_attributes(arm.hir_id, arm.span, Target::Arm, None);
|
||||
intravisit::walk_arm(self, arm);
|
||||
}
|
||||
|
||||
|
|
@ -1840,7 +1862,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
|
|||
let target = Target::from_foreign_item(f_item);
|
||||
self.check_attributes(
|
||||
f_item.hir_id(),
|
||||
&f_item.span,
|
||||
f_item.span,
|
||||
target,
|
||||
Some(ItemLike::ForeignItem(f_item)),
|
||||
);
|
||||
|
|
@ -1849,14 +1871,14 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
|
|||
|
||||
fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
|
||||
let target = target_from_impl_item(self.tcx, impl_item);
|
||||
self.check_attributes(impl_item.hir_id(), &impl_item.span, target, None);
|
||||
self.check_attributes(impl_item.hir_id(), impl_item.span, target, None);
|
||||
intravisit::walk_impl_item(self, impl_item)
|
||||
}
|
||||
|
||||
fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
|
||||
// When checking statements ignore expressions, they will be checked later.
|
||||
if let hir::StmtKind::Local(ref l) = stmt.kind {
|
||||
self.check_attributes(l.hir_id, &stmt.span, Target::Statement, None);
|
||||
self.check_attributes(l.hir_id, stmt.span, Target::Statement, None);
|
||||
}
|
||||
intravisit::walk_stmt(self, stmt)
|
||||
}
|
||||
|
|
@ -1867,7 +1889,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
|
|||
_ => Target::Expression,
|
||||
};
|
||||
|
||||
self.check_attributes(expr.hir_id, &expr.span, target, None);
|
||||
self.check_attributes(expr.hir_id, expr.span, target, None);
|
||||
intravisit::walk_expr(self, expr)
|
||||
}
|
||||
|
||||
|
|
@ -1877,12 +1899,12 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
|
|||
generics: &'tcx hir::Generics<'tcx>,
|
||||
item_id: HirId,
|
||||
) {
|
||||
self.check_attributes(variant.id, &variant.span, Target::Variant, None);
|
||||
self.check_attributes(variant.id, variant.span, Target::Variant, None);
|
||||
intravisit::walk_variant(self, variant, generics, item_id)
|
||||
}
|
||||
|
||||
fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
|
||||
self.check_attributes(param.hir_id, ¶m.span, Target::Param, None);
|
||||
self.check_attributes(param.hir_id, param.span, Target::Param, None);
|
||||
|
||||
intravisit::walk_param(self, param);
|
||||
}
|
||||
|
|
@ -1950,7 +1972,7 @@ fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {
|
|||
let check_attr_visitor = &mut CheckAttrVisitor { tcx };
|
||||
tcx.hir().visit_item_likes_in_module(module_def_id, &mut check_attr_visitor.as_deep_visitor());
|
||||
if module_def_id.is_top_level_module() {
|
||||
check_attr_visitor.check_attributes(CRATE_HIR_ID, &DUMMY_SP, Target::Mod, None);
|
||||
check_attr_visitor.check_attributes(CRATE_HIR_ID, DUMMY_SP, Target::Mod, None);
|
||||
check_invalid_crate_level_attr(tcx, tcx.hir().krate_attrs());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
#![feature(nll)]
|
||||
#![feature(try_blocks)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_middle;
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
#![feature(try_blocks)]
|
||||
#![feature(associated_type_defaults)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
use rustc_ast::MacroDef;
|
||||
use rustc_attr as attr;
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#![feature(once_cell)]
|
||||
#![feature(rustc_attrs)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#![feature(let_else)]
|
||||
#![feature(min_specialization)]
|
||||
#![feature(thread_local_const_init)]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
#![feature(nll)]
|
||||
#![recursion_limit = "256"]
|
||||
#![allow(rustdoc::private_intra_doc_links)]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
#![feature(if_let_guard)]
|
||||
#![feature(nll)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
mod dump_visitor;
|
||||
mod dumper;
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
#![feature(min_specialization)]
|
||||
#![feature(once_cell)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@
|
|||
#![feature(nll)]
|
||||
#![feature(min_specialization)]
|
||||
#![feature(thread_local_const_init)]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
|
|
|||
|
|
@ -1114,6 +1114,7 @@ symbols! {
|
|||
rustc_layout_scalar_valid_range_end,
|
||||
rustc_layout_scalar_valid_range_start,
|
||||
rustc_legacy_const_generics,
|
||||
rustc_lint_query_instability,
|
||||
rustc_macro_transparency,
|
||||
rustc_main,
|
||||
rustc_mir,
|
||||
|
|
|
|||
|
|
@ -93,6 +93,7 @@
|
|||
#![feature(in_band_lifetimes)]
|
||||
#![feature(iter_zip)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_middle;
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#![feature(crate_visibility_modifier)]
|
||||
#![feature(control_flow_enum)]
|
||||
#![recursion_limit = "512"] // For rustdoc
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
|
|
|||
|
|
@ -830,6 +830,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
self.tcx.type_of(def_id)
|
||||
};
|
||||
let substs = self.infcx.fresh_substs_for_item(span, def_id);
|
||||
self.write_substs(hir_id, substs);
|
||||
let ty = item_ty.subst(self.tcx, substs);
|
||||
|
||||
self.write_resolution(hir_id, Ok((def_kind, def_id)));
|
||||
|
|
|
|||
|
|
@ -420,7 +420,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
..
|
||||
},
|
||||
method,
|
||||
)) if Some(recv_ty.def_id()) == pin_did && method.ident.name == sym::new => {
|
||||
)) if recv_ty.opt_def_id() == pin_did && method.ident.name == sym::new => {
|
||||
err.span_suggestion(
|
||||
fn_name.span,
|
||||
"use `Box::pin` to pin and box this expression",
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ This API is completely unstable and subject to change.
|
|||
#![feature(slice_partition_dedup)]
|
||||
#![feature(control_flow_enum)]
|
||||
#![recursion_limit = "256"]
|
||||
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
|
||||
|
||||
#[macro_use]
|
||||
extern crate tracing;
|
||||
|
|
|
|||
|
|
@ -85,14 +85,16 @@ where
|
|||
|
||||
/// Converts a reference to `T` into a reference to an array of length 1 (without copying).
|
||||
#[stable(feature = "array_from_ref", since = "1.53.0")]
|
||||
pub fn from_ref<T>(s: &T) -> &[T; 1] {
|
||||
#[rustc_const_unstable(feature = "const_array_from_ref", issue = "90206")]
|
||||
pub const fn from_ref<T>(s: &T) -> &[T; 1] {
|
||||
// SAFETY: Converting `&T` to `&[T; 1]` is sound.
|
||||
unsafe { &*(s as *const T).cast::<[T; 1]>() }
|
||||
}
|
||||
|
||||
/// Converts a mutable reference to `T` into a mutable reference to an array of length 1 (without copying).
|
||||
#[stable(feature = "array_from_ref", since = "1.53.0")]
|
||||
pub fn from_mut<T>(s: &mut T) -> &mut [T; 1] {
|
||||
#[rustc_const_unstable(feature = "const_array_from_ref", issue = "90206")]
|
||||
pub const fn from_mut<T>(s: &mut T) -> &mut [T; 1] {
|
||||
// SAFETY: Converting `&mut T` to `&mut [T; 1]` is sound.
|
||||
unsafe { &mut *(s as *mut T).cast::<[T; 1]>() }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -136,6 +136,8 @@
|
|||
#![feature(ptr_metadata)]
|
||||
#![feature(slice_ptr_get)]
|
||||
#![feature(variant_count)]
|
||||
#![feature(const_array_from_ref)]
|
||||
#![feature(const_slice_from_ref)]
|
||||
//
|
||||
// Language features:
|
||||
#![feature(abi_unadjusted)]
|
||||
|
|
|
|||
|
|
@ -138,12 +138,14 @@ pub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T]
|
|||
|
||||
/// Converts a reference to T into a slice of length 1 (without copying).
|
||||
#[stable(feature = "from_ref", since = "1.28.0")]
|
||||
pub fn from_ref<T>(s: &T) -> &[T] {
|
||||
#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "90206")]
|
||||
pub const fn from_ref<T>(s: &T) -> &[T] {
|
||||
array::from_ref(s)
|
||||
}
|
||||
|
||||
/// Converts a reference to T into a slice of length 1 (without copying).
|
||||
#[stable(feature = "from_ref", since = "1.28.0")]
|
||||
pub fn from_mut<T>(s: &mut T) -> &mut [T] {
|
||||
#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "90206")]
|
||||
pub const fn from_mut<T>(s: &mut T) -> &mut [T] {
|
||||
array::from_mut(s)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,11 @@ fn array_from_ref() {
|
|||
let value: String = "Hello World!".into();
|
||||
let arr: &[String; 1] = array::from_ref(&value);
|
||||
assert_eq!(&[value.clone()], arr);
|
||||
|
||||
const VALUE: &&str = &"Hello World!";
|
||||
const ARR: &[&str; 1] = array::from_ref(VALUE);
|
||||
assert_eq!(&[*VALUE], ARR);
|
||||
assert!(core::ptr::eq(VALUE, &ARR[0]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -74,6 +74,8 @@
|
|||
#![feature(trusted_random_access)]
|
||||
#![feature(unsize)]
|
||||
#![feature(unzip_option)]
|
||||
#![feature(const_array_from_ref)]
|
||||
#![feature(const_slice_from_ref)]
|
||||
#![deny(unsafe_op_in_unsafe_fn)]
|
||||
|
||||
extern crate test;
|
||||
|
|
|
|||
|
|
@ -2146,6 +2146,14 @@ fn test_slice_run_destructors() {
|
|||
assert_eq!(x.get(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_const_from_ref() {
|
||||
const VALUE: &i32 = &1;
|
||||
const SLICE: &[i32] = core::slice::from_ref(VALUE);
|
||||
|
||||
assert!(core::ptr::eq(VALUE, &SLICE[0]))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_slice_fill_with_uninit() {
|
||||
// This should not UB. See #87891
|
||||
|
|
|
|||
|
|
@ -414,6 +414,7 @@ impl<K, V, S> HashMap<K, V, S> {
|
|||
/// println!("key: {} val: {}", key, val);
|
||||
/// }
|
||||
/// ```
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn iter(&self) -> Iter<'_, K, V> {
|
||||
Iter { base: self.base.iter() }
|
||||
|
|
@ -442,6 +443,7 @@ impl<K, V, S> HashMap<K, V, S> {
|
|||
/// println!("key: {} val: {}", key, val);
|
||||
/// }
|
||||
/// ```
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
|
||||
IterMut { base: self.base.iter_mut() }
|
||||
|
|
@ -502,6 +504,7 @@ impl<K, V, S> HashMap<K, V, S> {
|
|||
/// assert!(a.is_empty());
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "drain", since = "1.6.0")]
|
||||
pub fn drain(&mut self) -> Drain<'_, K, V> {
|
||||
Drain { base: self.base.drain() }
|
||||
|
|
@ -543,6 +546,7 @@ impl<K, V, S> HashMap<K, V, S> {
|
|||
/// assert_eq!(odds, vec![1, 3, 5, 7]);
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[unstable(feature = "hash_drain_filter", issue = "59618")]
|
||||
pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, K, V, F>
|
||||
where
|
||||
|
|
@ -949,6 +953,7 @@ where
|
|||
/// assert_eq!(map.len(), 4);
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "retain_hash_collection", since = "1.18.0")]
|
||||
pub fn retain<F>(&mut self, f: F)
|
||||
where
|
||||
|
|
@ -978,6 +983,7 @@ where
|
|||
/// assert_eq!(vec, ["a", "b", "c"]);
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
|
||||
pub fn into_keys(self) -> IntoKeys<K, V> {
|
||||
IntoKeys { inner: self.into_iter() }
|
||||
|
|
@ -1004,6 +1010,7 @@ where
|
|||
/// assert_eq!(vec, [1, 2, 3]);
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
|
||||
pub fn into_values(self) -> IntoValues<K, V> {
|
||||
IntoValues { inner: self.into_iter() }
|
||||
|
|
@ -1969,6 +1976,7 @@ impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> {
|
|||
type IntoIter = Iter<'a, K, V>;
|
||||
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
fn into_iter(self) -> Iter<'a, K, V> {
|
||||
self.iter()
|
||||
}
|
||||
|
|
@ -1980,6 +1988,7 @@ impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S> {
|
|||
type IntoIter = IterMut<'a, K, V>;
|
||||
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
fn into_iter(self) -> IterMut<'a, K, V> {
|
||||
self.iter_mut()
|
||||
}
|
||||
|
|
@ -2008,6 +2017,7 @@ impl<K, V, S> IntoIterator for HashMap<K, V, S> {
|
|||
/// let vec: Vec<(&str, i32)> = map.into_iter().collect();
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
fn into_iter(self) -> IntoIter<K, V> {
|
||||
IntoIter { base: self.base.into_iter() }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -185,6 +185,7 @@ impl<T, S> HashSet<T, S> {
|
|||
/// }
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn iter(&self) -> Iter<'_, T> {
|
||||
Iter { base: self.base.iter() }
|
||||
|
|
@ -244,6 +245,7 @@ impl<T, S> HashSet<T, S> {
|
|||
/// assert!(set.is_empty());
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "drain", since = "1.6.0")]
|
||||
pub fn drain(&mut self) -> Drain<'_, T> {
|
||||
Drain { base: self.base.drain() }
|
||||
|
|
@ -282,6 +284,7 @@ impl<T, S> HashSet<T, S> {
|
|||
/// assert_eq!(odds, vec![1, 3, 5, 7]);
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[unstable(feature = "hash_drain_filter", issue = "59618")]
|
||||
pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, T, F>
|
||||
where
|
||||
|
|
@ -506,6 +509,7 @@ where
|
|||
/// assert_eq!(diff, [4].iter().collect());
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S> {
|
||||
Difference { iter: self.iter(), other }
|
||||
|
|
@ -533,6 +537,7 @@ where
|
|||
/// assert_eq!(diff1, [1, 4].iter().collect());
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn symmetric_difference<'a>(
|
||||
&'a self,
|
||||
|
|
@ -560,6 +565,7 @@ where
|
|||
/// assert_eq!(intersection, [2, 3].iter().collect());
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S> {
|
||||
if self.len() <= other.len() {
|
||||
|
|
@ -588,6 +594,7 @@ where
|
|||
/// assert_eq!(union, [1, 2, 3, 4].iter().collect());
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S> {
|
||||
if self.len() >= other.len() {
|
||||
|
|
@ -922,6 +929,7 @@ where
|
|||
/// set.retain(|&k| k % 2 == 0);
|
||||
/// assert_eq!(set.len(), 3);
|
||||
/// ```
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
#[stable(feature = "retain_hash_collection", since = "1.18.0")]
|
||||
pub fn retain<F>(&mut self, f: F)
|
||||
where
|
||||
|
|
@ -1403,6 +1411,7 @@ impl<'a, T, S> IntoIterator for &'a HashSet<T, S> {
|
|||
type IntoIter = Iter<'a, T>;
|
||||
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
fn into_iter(self) -> Iter<'a, T> {
|
||||
self.iter()
|
||||
}
|
||||
|
|
@ -1434,6 +1443,7 @@ impl<T, S> IntoIterator for HashSet<T, S> {
|
|||
/// }
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
|
||||
fn into_iter(self) -> IntoIter<T> {
|
||||
IntoIter { base: self.base.into_iter() }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -448,9 +448,11 @@ jobs:
|
|||
# macOS Builders #
|
||||
####################
|
||||
|
||||
# Only generate documentation for x86_64-apple-darwin, not other
|
||||
# tier 2 targets produced by this builder.
|
||||
- name: dist-x86_64-apple
|
||||
env:
|
||||
SCRIPT: ./x.py dist
|
||||
SCRIPT: ./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended
|
||||
RUST_CONFIGURE_ARGS: --host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false
|
||||
RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
|
||||
MACOSX_DEPLOYMENT_TARGET: 10.7
|
||||
|
|
@ -670,7 +672,17 @@ jobs:
|
|||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- *dist-x86_64-linux
|
||||
- name: dist-x86_64-apple
|
||||
env:
|
||||
SCRIPT: ./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended
|
||||
RUST_CONFIGURE_ARGS: --host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false
|
||||
RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
|
||||
MACOSX_DEPLOYMENT_TARGET: 10.7
|
||||
NO_LLVM_ASSERTIONS: 1
|
||||
NO_DEBUG_ASSERTIONS: 1
|
||||
DIST_REQUIRE_ALL_TOOLS: 1
|
||||
<<: *job-macos-xl
|
||||
|
||||
|
||||
master:
|
||||
name: master
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ else
|
|||
PYTHON="python2"
|
||||
fi
|
||||
|
||||
if ! isCI || isCiBranch auto || isCiBranch beta; then
|
||||
if ! isCI || isCiBranch auto || isCiBranch beta || isCiBranch try; then
|
||||
RUST_CONFIGURE_ARGS="$RUST_CONFIGURE_ARGS --set build.print-step-timings --enable-verbose-tests"
|
||||
fi
|
||||
|
||||
|
|
|
|||
|
|
@ -152,10 +152,15 @@ h1.fqn > .in-band > a:hover {
|
|||
h2, h3, h4 {
|
||||
border-bottom: 1px solid;
|
||||
}
|
||||
h3.code-header, h4.code-header {
|
||||
h3.code-header {
|
||||
font-size: 1.1em;
|
||||
}
|
||||
h4.code-header {
|
||||
font-size: 1em;
|
||||
}
|
||||
h3.code-header, h4.code-header {
|
||||
font-weight: 600;
|
||||
border: none;
|
||||
border-bottom-style: none;
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
}
|
||||
|
|
@ -174,12 +179,6 @@ h3.code-header, h4.code-header {
|
|||
margin-bottom: 10px;
|
||||
position: relative;
|
||||
}
|
||||
.impl, .method.trait-impl,
|
||||
.type.trait-impl,
|
||||
.associatedconstant.trait-impl,
|
||||
.associatedtype.trait-impl {
|
||||
padding-left: 15px;
|
||||
}
|
||||
|
||||
div.impl-items > div {
|
||||
padding-left: 0;
|
||||
|
|
@ -674,13 +673,6 @@ nav.sub {
|
|||
left: -19px;
|
||||
}
|
||||
|
||||
.content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant,
|
||||
.impl-items > .associatedtype, .content .impl-items details > summary > .type,
|
||||
.impl-items details > summary > .associatedconstant,
|
||||
.impl-items details > summary > .associatedtype {
|
||||
margin-left: 20px;
|
||||
}
|
||||
|
||||
.content .impl-items .docblock, .content .impl-items .item-info {
|
||||
margin-bottom: .6em;
|
||||
}
|
||||
|
|
@ -751,7 +743,7 @@ a {
|
|||
.anchor {
|
||||
display: none;
|
||||
position: absolute;
|
||||
left: 0;
|
||||
left: -0.5em;
|
||||
background: none !important;
|
||||
}
|
||||
.anchor.field {
|
||||
|
|
@ -1584,14 +1576,14 @@ details.rustdoc-toggle > summary.hideme::before {
|
|||
|
||||
details.rustdoc-toggle > summary:not(.hideme)::before {
|
||||
position: absolute;
|
||||
left: -23px;
|
||||
left: -24px;
|
||||
top: 3px;
|
||||
}
|
||||
|
||||
.impl-items > details.rustdoc-toggle > summary:not(.hideme)::before,
|
||||
.undocumented > details.rustdoc-toggle > summary:not(.hideme)::before {
|
||||
position: absolute;
|
||||
left: -2px;
|
||||
left: -24px;
|
||||
}
|
||||
|
||||
/* When a "hideme" summary is open and the "Expand description" or "Show
|
||||
|
|
|
|||
11
src/test/rustdoc-gui/anchor-navigable.goml
Normal file
11
src/test/rustdoc-gui/anchor-navigable.goml
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
// The `impl Foo` heading underneath `Implementations` has a §
|
||||
// anchor to its left (used for linking to that heading). The anchor only shows
|
||||
// up when hovering the `impl Foo`. This test ensures there's no gap between the
|
||||
// anchor and the `impl Foo`. If there were a gap, this would cause an annoying
|
||||
// problem: you hover `impl Foo` to see the anchor, then when you move your
|
||||
// mouse to the left, the anchor disappears before you reach it.
|
||||
goto: file://|DOC_PATH|/test_docs/struct.Foo.html
|
||||
// We check that ".item-info" is bigger than its content.
|
||||
move-cursor-to: ".impl"
|
||||
assert-property: (".impl > a.anchor", {"offsetWidth": "9"})
|
||||
assert-css: (".impl > a.anchor", {"left": "-8px"})
|
||||
24
src/test/ui-fulldeps/internal-lints/query_stability.rs
Normal file
24
src/test/ui-fulldeps/internal-lints/query_stability.rs
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
// compile-flags: -Z unstable-options
|
||||
|
||||
#![feature(rustc_private)]
|
||||
#![deny(rustc::potential_query_instability)]
|
||||
|
||||
extern crate rustc_data_structures;
|
||||
|
||||
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
|
||||
|
||||
fn main() {
|
||||
let mut x = FxHashMap::<u32, i32>::default();
|
||||
|
||||
for _ in x.drain() {}
|
||||
//~^ ERROR using `drain` can result in unstable
|
||||
|
||||
for _ in x.iter() {}
|
||||
//~^ ERROR using `iter`
|
||||
|
||||
for _ in Some(&mut x).unwrap().iter_mut() {}
|
||||
//~^ ERROR using `iter_mut`
|
||||
|
||||
for _ in x {}
|
||||
//~^ ERROR using `into_iter`
|
||||
}
|
||||
39
src/test/ui-fulldeps/internal-lints/query_stability.stderr
Normal file
39
src/test/ui-fulldeps/internal-lints/query_stability.stderr
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
error: using `drain` can result in unstable query results
|
||||
--> $DIR/query_stability.rs:13:16
|
||||
|
|
||||
LL | for _ in x.drain() {}
|
||||
| ^^^^^
|
||||
|
|
||||
note: the lint level is defined here
|
||||
--> $DIR/query_stability.rs:4:9
|
||||
|
|
||||
LL | #![deny(rustc::potential_query_instability)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
|
||||
|
||||
error: using `iter` can result in unstable query results
|
||||
--> $DIR/query_stability.rs:16:16
|
||||
|
|
||||
LL | for _ in x.iter() {}
|
||||
| ^^^^
|
||||
|
|
||||
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
|
||||
|
||||
error: using `iter_mut` can result in unstable query results
|
||||
--> $DIR/query_stability.rs:19:36
|
||||
|
|
||||
LL | for _ in Some(&mut x).unwrap().iter_mut() {}
|
||||
| ^^^^^^^^
|
||||
|
|
||||
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
|
||||
|
||||
error: using `into_iter` can result in unstable query results
|
||||
--> $DIR/query_stability.rs:22:14
|
||||
|
|
||||
LL | for _ in x {}
|
||||
| ^
|
||||
|
|
||||
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
|
||||
|
||||
error: aborting due to 4 previous errors
|
||||
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
// compile-flags: -Z unstable-options
|
||||
|
||||
#![feature(rustc_attrs)]
|
||||
|
||||
#[rustc_lint_query_instability]
|
||||
//~^ ERROR attribute should be applied to a function
|
||||
struct Foo;
|
||||
|
||||
impl Foo {
|
||||
#[rustc_lint_query_instability(a)]
|
||||
//~^ ERROR malformed `rustc_lint_query_instability`
|
||||
fn bar() {}
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
error: malformed `rustc_lint_query_instability` attribute input
|
||||
--> $DIR/query_stability_incorrect.rs:10:5
|
||||
|
|
||||
LL | #[rustc_lint_query_instability(a)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[rustc_lint_query_instability]`
|
||||
|
||||
error: attribute should be applied to a function
|
||||
--> $DIR/query_stability_incorrect.rs:5:1
|
||||
|
|
||||
LL | #[rustc_lint_query_instability]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
LL |
|
||||
LL | struct Foo;
|
||||
| ----------- not a function
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
// Checks that we do not ICE when comparing `Self` to `Pin`
|
||||
// edition:2021
|
||||
|
||||
struct S;
|
||||
|
||||
impl S {
|
||||
fn foo(_: Box<Option<S>>) {}
|
||||
fn bar() {
|
||||
Self::foo(None) //~ ERROR mismatched types
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
error[E0308]: mismatched types
|
||||
--> $DIR/issue-90213-expected-boxfuture-self-ice.rs:9:19
|
||||
|
|
||||
LL | Self::foo(None)
|
||||
| ^^^^ expected struct `Box`, found enum `Option`
|
||||
|
|
||||
= note: expected struct `Box<Option<S>>`
|
||||
found enum `Option<_>`
|
||||
= note: for more on the distinction between the stack and the heap, read https://doc.rust-lang.org/book/ch15-01-box.html, https://doc.rust-lang.org/rust-by-example/std/box.html, and https://doc.rust-lang.org/std/boxed/index.html
|
||||
help: store this in the heap by calling `Box::new`
|
||||
|
|
||||
LL | Self::foo(Box::new(None))
|
||||
| +++++++++ +
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
For more information about this error, try `rustc --explain E0308`.
|
||||
Loading…
Add table
Reference in a new issue