Rollup of 8 pull requests

Cargo.lock

@@ -636,9 +636,9 @@ dependencies = [
 
 [[package]]
 name = "compiler_builtins"
-version = "0.1.35"
+version = "0.1.36"
 source = "registry+https:/rust-lang/crates.io-index"
-checksum = "e3fcd8aba10d17504c87ef12d4f62ef404c6a4703d16682a9eb5543e6cf24455"
+checksum = "7cd0782e0a7da7598164153173e5a5d4d9b1da094473c98dce0ff91406112369"
 dependencies = [
  "cc",
  "rustc-std-workspace-core",

compiler/rustc_ast/src/attr/mod.rs

@@ -629,7 +629,8 @@ impl HasAttrs for StmtKind {
  match *self {
  StmtKind::Local(ref local) => local.attrs(),
  StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => expr.attrs(),
- StmtKind::Empty | StmtKind::Item(..) => &[],
+ StmtKind::Item(ref item) => item.attrs(),
+ StmtKind::Empty => &[],
  StmtKind::MacCall(ref mac) => mac.attrs.attrs(),
  }
  }
@@ -638,7 +639,8 @@ impl HasAttrs for StmtKind {
  match self {
  StmtKind::Local(local) => local.visit_attrs(f),
  StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.visit_attrs(f),
- StmtKind::Empty | StmtKind::Item(..) => {}
+ StmtKind::Item(item) => item.visit_attrs(f),
+ StmtKind::Empty => {}
  StmtKind::MacCall(mac) => {
  mac.attrs.visit_attrs(f);
  }

compiler/rustc_attr/src/builtin.rs

@@ -1013,13 +1013,28 @@ pub fn allow_internal_unstable<'a>(
  sess: &'a Session,
  attrs: &'a [Attribute],
 ) -> Option<impl Iterator<Item = Symbol> + 'a> {
- let attrs = sess.filter_by_name(attrs, sym::allow_internal_unstable);
+ allow_unstable(sess, attrs, sym::allow_internal_unstable)
+}
+
+pub fn rustc_allow_const_fn_unstable<'a>(
+ sess: &'a Session,
+ attrs: &'a [Attribute],
+) -> Option<impl Iterator<Item = Symbol> + 'a> {
+ allow_unstable(sess, attrs, sym::rustc_allow_const_fn_unstable)
+}
+
+fn allow_unstable<'a>(
+ sess: &'a Session,
+ attrs: &'a [Attribute],
+ symbol: Symbol,
+) -> Option<impl Iterator<Item = Symbol> + 'a> {
+ let attrs = sess.filter_by_name(attrs, symbol);
  let list = attrs
  .filter_map(move |attr| {
  attr.meta_item_list().or_else(|| {
  sess.diagnostic().span_err(
  attr.span,
- "`allow_internal_unstable` expects a list of feature names",
+ &format!("`{}` expects a list of feature names", symbol.to_ident_string()),
  );
  None
  })
@@ -1029,8 +1044,10 @@ pub fn allow_internal_unstable<'a>(
  Some(list.into_iter().filter_map(move |it| {
  let name = it.ident().map(|ident| ident.name);
  if name.is_none() {
- sess.diagnostic()
- .span_err(it.span(), "`allow_internal_unstable` expects feature names");
+ sess.diagnostic().span_err(
+ it.span(),
+ &format!("`{}` expects feature names", symbol.to_ident_string()),
+ );
  }
  name
  }))

compiler/rustc_expand/src/expand.rs

@@ -1357,7 +1357,8 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
  // we'll expand attributes on expressions separately
  if !stmt.is_expr() {
  let (attr, derives, after_derive) = if stmt.is_item() {
- self.classify_item(&mut stmt)
+ // FIXME: Handle custom attributes on statements (#15701)
+ (None, vec![], false)
  } else {
  // ignore derives on non-item statements so it falls through
  // to the unused-attributes lint

compiler/rustc_feature/src/active.rs

@@ -210,6 +210,11 @@ declare_features! (
  /// it is not on path for eventual stabilization).
  (active, no_niche, "1.42.0", None, None),
 
+ /// Allows using `#[rustc_allow_const_fn_unstable]`.
+ /// This is an attribute on `const fn` for the same
+ /// purpose as `#[allow_internal_unstable]`.
+ (active, rustc_allow_const_fn_unstable, "1.49.0", Some(69399), None),
+
  // no-tracking-issue-end
 
  // -------------------------------------------------------------------------

compiler/rustc_feature/src/builtin_attrs.rs

@@ -379,6 +379,10 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
  allow_internal_unstable, AssumedUsed, template!(Word, List: "feat1, feat2, ..."),
  "allow_internal_unstable side-steps feature gating and stability checks",
  ),
+ gated!(
+ rustc_allow_const_fn_unstable, AssumedUsed, template!(Word, List: "feat1, feat2, ..."),
+ "rustc_allow_const_fn_unstable side-steps feature gating and stability checks"
+ ),
  gated!(
  allow_internal_unsafe, Normal, template!(Word),
  "allow_internal_unsafe side-steps the unsafe_code lint",

compiler/rustc_hir/src/hir.rs

@@ -1101,11 +1101,11 @@ pub enum StmtKind<'hir> {
  Semi(&'hir Expr<'hir>),
 }
 
-impl StmtKind<'hir> {
- pub fn attrs(&self) -> &'hir [Attribute] {
+impl<'hir> StmtKind<'hir> {
+ pub fn attrs(&self, get_item: impl FnOnce(ItemId) -> &'hir Item<'hir>) -> &'hir [Attribute] {
  match *self {
  StmtKind::Local(ref l) => &l.attrs,
- StmtKind::Item(_) => &[],
+ StmtKind::Item(ref item_id) => &get_item(*item_id).attrs,
  StmtKind::Expr(ref e) | StmtKind::Semi(ref e) => &e.attrs,
  }
  }

compiler/rustc_lint/src/builtin.rs

@@ -994,7 +994,8 @@ impl EarlyLintPass for UnusedDocComment {
  fn check_stmt(&mut self, cx: &EarlyContext<'_>, stmt: &ast::Stmt) {
  let kind = match stmt.kind {
  ast::StmtKind::Local(..) => "statements",
- ast::StmtKind::Item(..) => "inner items",
+ // Disabled pending discussion in #78306
+ ast::StmtKind::Item(..) => return,
  // expressions will be reported by `check_expr`.
  ast::StmtKind::Empty
  | ast::StmtKind::Semi(_)

compiler/rustc_lint/src/early.rs

@@ -18,6 +18,7 @@ use crate::context::{EarlyContext, LintContext, LintStore};
 use crate::passes::{EarlyLintPass, EarlyLintPassObject};
 use rustc_ast as ast;
 use rustc_ast::visit as ast_visit;
+use rustc_attr::HasAttrs;
 use rustc_session::lint::{BufferedEarlyLint, LintBuffer, LintPass};
 use rustc_session::Session;
 use rustc_span::symbol::Ident;
@@ -119,8 +120,22 @@ impl<'a, T: EarlyLintPass> ast_visit::Visitor<'a> for EarlyContextAndPass<'a, T>
  }
 
  fn visit_stmt(&mut self, s: &'a ast::Stmt) {
- run_early_pass!(self, check_stmt, s);
- self.check_id(s.id);
+ // Add the statement's lint attributes to our
+ // current state when checking the statement itself.
+ // This allows us to handle attributes like
+ // `#[allow(unused_doc_comments)]`, which apply to
+ // sibling attributes on the same target
+ //
+ // Note that statements get their attributes from
+ // the AST struct that they wrap (e.g. an item)
+ self.with_lint_attrs(s.id, s.attrs(), |cx| {
+ run_early_pass!(cx, check_stmt, s);
+ cx.check_id(s.id);
+ });
+ // The visitor for the AST struct wrapped
+ // by the statement (e.g. `Item`) will call
+ // `with_lint_attrs`, so do this walk
+ // outside of the above `with_lint_attrs` call
  ast_visit::walk_stmt(self, s);
  }
 

compiler/rustc_lint/src/late.rs

@@ -174,12 +174,13 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
  }
 
  fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) {
- // statement attributes are actually just attributes on one of
- // - item
- // - local
- // - expression
- // so we keep track of lint levels there
- lint_callback!(self, check_stmt, s);
+ let get_item = |id: hir::ItemId| self.context.tcx.hir().item(id.id);
+ let attrs = &s.kind.attrs(get_item);
+ // See `EarlyContextAndPass::visit_stmt` for an explanation
+ // of why we call `walk_stmt` outside of `with_lint_attrs`
+ self.with_lint_attrs(s.hir_id, attrs, |cx| {
+ lint_callback!(cx, check_stmt, s);
+ });
  hir_visit::walk_stmt(self, s);
  }
 

compiler/rustc_lint/src/levels.rs

@@ -562,6 +562,13 @@ impl<'tcx> intravisit::Visitor<'tcx> for LintLevelMapBuilder<'_, 'tcx> {
  })
  }
 
+ fn visit_stmt(&mut self, e: &'tcx hir::Stmt<'tcx>) {
+ // We will call `with_lint_attrs` when we walk
+ // the `StmtKind`. The outer statement itself doesn't
+ // define the lint levels.
+ intravisit::walk_stmt(self, e);
+ }
+
  fn visit_expr(&mut self, e: &'tcx hir::Expr<'tcx>) {
  self.with_lint_attrs(e.hir_id, &e.attrs, |builder| {
  intravisit::walk_expr(builder, e);

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -8,6 +8,7 @@ use rustc_ast as ast;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::svh::Svh;
 use rustc_hir as hir;
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, CRATE_DEF_INDEX, LOCAL_CRATE};
 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
 use rustc_middle::hir::exports::Export;
@@ -487,6 +488,10 @@ impl CrateStore for CStore {
  self.get_crate_data(def.krate).def_key(def.index)
  }
 
+ fn def_kind(&self, def: DefId) -> DefKind {
+ self.get_crate_data(def.krate).def_kind(def.index)
+ }
+
  fn def_path(&self, def: DefId) -> DefPath {
  self.get_crate_data(def.krate).def_path(def.index)
  }

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

@@ -816,7 +816,7 @@ impl<'hir> Map<'hir> {
  Some(Node::Variant(ref v)) => Some(&v.attrs[..]),
  Some(Node::Field(ref f)) => Some(&f.attrs[..]),
  Some(Node::Expr(ref e)) => Some(&*e.attrs),
- Some(Node::Stmt(ref s)) => Some(s.kind.attrs()),
+ Some(Node::Stmt(ref s)) => Some(s.kind.attrs(|id| self.item(id.id))),
  Some(Node::Arm(ref a)) => Some(&*a.attrs),
  Some(Node::GenericParam(param)) => Some(&param.attrs[..]),
  // Unit/tuple structs/variants take the attributes straight from

compiler/rustc_middle/src/middle/cstore.rs

@@ -8,6 +8,7 @@ use rustc_ast as ast;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::{self, MetadataRef};
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
 use rustc_macros::HashStable;
@@ -185,6 +186,7 @@ pub trait CrateStore {
 
  // resolve
  fn def_key(&self, def: DefId) -> DefKey;
+ fn def_kind(&self, def: DefId) -> DefKind;
  fn def_path(&self, def: DefId) -> DefPath;
  fn def_path_hash(&self, def: DefId) -> DefPathHash;
  fn all_def_path_hashes_and_def_ids(&self, cnum: CrateNum) -> Vec<(DefPathHash, DefId)>;

compiler/rustc_mir/src/transform/check_consts/mod.rs

@@ -79,9 +79,13 @@ pub fn is_lang_panic_fn(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
  || Some(def_id) == tcx.lang_items().begin_panic_fn()
 }
 
-pub fn allow_internal_unstable(tcx: TyCtxt<'tcx>, def_id: DefId, feature_gate: Symbol) -> bool {
+pub fn rustc_allow_const_fn_unstable(
+ tcx: TyCtxt<'tcx>,
+ def_id: DefId,
+ feature_gate: Symbol,
+) -> bool {
  let attrs = tcx.get_attrs(def_id);
- attr::allow_internal_unstable(&tcx.sess, attrs)
+ attr::rustc_allow_const_fn_unstable(&tcx.sess, attrs)
  .map_or(false, |mut features| features.any(|name| name == feature_gate))
 }
 

compiler/rustc_mir/src/transform/check_consts/validation.rs

@@ -292,7 +292,11 @@ impl Validator<'mir, 'tcx> {
 
  Status::Unstable(gate) if self.tcx.features().enabled(gate) => {
  let unstable_in_stable = self.ccx.is_const_stable_const_fn()
- && !super::allow_internal_unstable(self.tcx, self.def_id().to_def_id(), gate);
+ && !super::rustc_allow_const_fn_unstable(
+ self.tcx,
+ self.def_id().to_def_id(),
+ gate,
+ );
  if unstable_in_stable {
  emit_unstable_in_stable_error(self.ccx, span, gate);
  }
@@ -807,7 +811,7 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
  }
 
  // Calling an unstable function *always* requires that the corresponding gate
- // be enabled, even if the function has `#[allow_internal_unstable(the_gate)]`.
+ // be enabled, even if the function has `#[rustc_allow_const_fn_unstable(the_gate)]`.
  if !tcx.features().declared_lib_features.iter().any(|&(sym, _)| sym == gate) {
  self.check_op(ops::FnCallUnstable(callee, Some(gate)));
  return;
@@ -821,7 +825,7 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
 
  // Otherwise, we are something const-stable calling a const-unstable fn.
 
- if super::allow_internal_unstable(tcx, caller, gate) {
+ if super::rustc_allow_const_fn_unstable(tcx, caller, gate) {
  return;
  }
 
@@ -967,8 +971,8 @@ fn emit_unstable_in_stable_error(ccx: &ConstCx<'_, '_>, span: Span, gate: Symbol
  )
  .span_suggestion(
  attr_span,
- "otherwise `#[allow_internal_unstable]` can be used to bypass stability checks",
- format!("#[allow_internal_unstable({})]\n", gate),
+ "otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks",
+ format!("#[rustc_allow_const_fn_unstable({})]\n", gate),
  Applicability::MaybeIncorrect,
  )
  .emit();

compiler/rustc_mir/src/transform/validate.rs

@@ -5,13 +5,17 @@ use crate::dataflow::{Analysis, ResultsCursor};
 use crate::util::storage::AlwaysLiveLocals;
 
 use super::MirPass;
-use rustc_middle::mir::visit::{PlaceContext, Visitor};
+use rustc_middle::mir::{
+ interpret::Scalar,
+ visit::{PlaceContext, Visitor},
+};
 use rustc_middle::mir::{
  AggregateKind, BasicBlock, Body, BorrowKind, Local, Location, MirPhase, Operand, Rvalue,
  SourceScope, Statement, StatementKind, Terminator, TerminatorKind, VarDebugInfo,
 };
 use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt};
+use rustc_target::abi::Size;
 
 #[derive(Copy, Clone, Debug)]
 enum EdgeKind {
@@ -346,7 +350,25 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
  ),
  );
  }
- for (_, target) in targets.iter() {
+
+ let target_width = self.tcx.sess.target.pointer_width;
+
+ let size = Size::from_bits(match switch_ty.kind() {
+ ty::Uint(uint) => uint.normalize(target_width).bit_width().unwrap(),
+ ty::Int(int) => int.normalize(target_width).bit_width().unwrap(),
+ ty::Char => 32,
+ ty::Bool => 1,
+ other => bug!("unhandled type: {:?}", other),
+ });
+
+ for (value, target) in targets.iter() {
+ if Scalar::<()>::try_from_uint(value, size).is_none() {
+ self.fail(
+ location,
+ format!("the value {:#x} is not a proper {:?}", value, switch_ty),
+ )
+ }
+
  self.check_edge(location, target, EdgeKind::Normal);
  }
  self.check_edge(location, targets.otherwise(), EdgeKind::Normal);