nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-05 03:23:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #105880 - Nilstrieb:make-newtypes-less-not-rust, r=oli-obk

Browse Source 
Improve syntax of `newtype_index`

This makes it more like proper Rust and also makes the implementation a lot simpler.

Mostly just turns weird flags in the body into proper attributes.

It should probably also be converted to an attribute macro instead of function-like, but that can be done in a future PR.
This commit is contained in:
bors 2022-12-20 07:27:01 +00:00
commit eb9e5e711d
37 changed files with 182 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
compiler/rustc_ast/src/ast.rs
View File

@ -2554,10 +2554,9 @@ pub enum AttrStyle {
}
rustc_index::newtype_index! {
pub struct AttrId {
ENCODABLE = custom
DEBUG_FORMAT = "AttrId({})"
}
#[custom_encodable]
#[debug_format = "AttrId({})]"]
pub struct AttrId {}
}
impl<S: Encoder> Encodable<S> for AttrId {

5
compiler/rustc_ast/src/node_id.rs
View File

@ -8,9 +8,8 @@ rustc_index::newtype_index! {
/// This is later turned into [`DefId`] and `HirId` for the HIR.
///
/// [`DefId`]: rustc_span::def_id::DefId
pub struct NodeId {
DEBUG_FORMAT = "NodeId({})"
}
#[debug_format = "NodeId({})"]
pub struct NodeId {}
}
rustc_data_structures::define_id_collections!(NodeMap, NodeSet, NodeMapEntry, NodeId);

10
compiler/rustc_borrowck/src/constraints/mod.rs
View File

@ -115,13 +115,11 @@ impl<'tcx> fmt::Debug for OutlivesConstraint<'tcx> {
}
rustc_index::newtype_index! {
pub struct OutlivesConstraintIndex {
DEBUG_FORMAT = "OutlivesConstraintIndex({})"
}
#[debug_format = "OutlivesConstraintIndex({})"]
pub struct OutlivesConstraintIndex {}
}
rustc_index::newtype_index! {
pub struct ConstraintSccIndex {
DEBUG_FORMAT = "ConstraintSccIndex({})"
}
#[debug_format = "ConstraintSccIndex({})"]
pub struct ConstraintSccIndex {}
}

5
compiler/rustc_borrowck/src/dataflow.rs
View File

@ -108,9 +108,8 @@ impl_visitable! {
}
rustc_index::newtype_index! {
pub struct BorrowIndex {
DEBUG_FORMAT = "bw{}"
}
#[debug_format = "bw{}"]
pub struct BorrowIndex {}
}
/// `Borrows` stores the data used in the analyses that track the flow

5
compiler/rustc_borrowck/src/location.rs
View File

@ -20,9 +20,8 @@ pub struct LocationTable {
}
rustc_index::newtype_index! {
pub struct LocationIndex {
DEBUG_FORMAT = "LocationIndex({})"
}
#[debug_format = "LocationIndex({})"]
pub struct LocationIndex {}
}
#[derive(Copy, Clone, Debug)]

5
compiler/rustc_borrowck/src/member_constraints.rs
View File

@ -55,9 +55,8 @@ pub(crate) struct NllMemberConstraint<'tcx> {
}
rustc_index::newtype_index! {
pub(crate) struct NllMemberConstraintIndex {
DEBUG_FORMAT = "MemberConstraintIndex({})"
}
#[debug_format = "MemberConstraintIndex({})"]
pub(crate) struct NllMemberConstraintIndex {}
}
impl Default for MemberConstraintSet<'_, ty::RegionVid> {

6
compiler/rustc_borrowck/src/region_infer/values.rs
View File

@ -90,12 +90,14 @@ impl RegionValueElements {
rustc_index::newtype_index! {
/// A single integer representing a `Location` in the MIR control-flow
/// graph. Constructed efficiently from `RegionValueElements`.
pub struct PointIndex { DEBUG_FORMAT = "PointIndex({})" }
#[debug_format = "PointIndex({})"]
pub struct PointIndex {}
}
rustc_index::newtype_index! {
/// A single integer representing a `ty::Placeholder`.
pub struct PlaceholderIndex { DEBUG_FORMAT = "PlaceholderIndex({})" }
#[debug_format = "PlaceholderIndex({})"]
pub struct PlaceholderIndex {}
}
/// An individual element in a region value -- the value of a

2
compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
View File

@ -46,7 +46,7 @@ struct Appearance {
}
rustc_index::newtype_index! {
pub struct AppearanceIndex { .. }
pub struct AppearanceIndex {}
}
impl vll::LinkElem for Appearance {

2
compiler/rustc_data_structures/src/graph/dominators/mod.rs
View File

@ -22,7 +22,7 @@ struct PreOrderFrame<Iter> {
}
rustc_index::newtype_index! {
struct PreorderIndex { .. }
struct PreorderIndex {}
}
pub fn dominators<G: ControlFlowGraph>(graph: G) -> Dominators<G::Node> {

2
compiler/rustc_hir/src/hir_id.rs
View File

@ -138,7 +138,7 @@ rustc_index::newtype_index! {
/// an "item-like" to something else can be implemented by a `Vec` instead of a
/// tree or hash map.
#[derive(HashStable_Generic)]
pub struct ItemLocalId { .. }
pub struct ItemLocalId {}
}
impl ItemLocalId {

6
compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
View File

@ -198,10 +198,10 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
// entire graph when there are many connected regions.
rustc_index::newtype_index! {
pub struct RegionId {
ENCODABLE = custom
}
#[custom_encodable]
pub struct RegionId {}
}
struct ConnectedRegion {
idents: SmallVec<[Symbol; 8]>,
impl_blocks: FxHashSet<usize>,

10
compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
View File

@ -4,15 +4,13 @@ use rustc_index::vec::IndexVec;
use rustc_middle::ty::error::TypeError;
rustc_index::newtype_index! {
pub(crate) struct ExpectedIdx {
DEBUG_FORMAT = "ExpectedIdx({})",
}
#[debug_format = "ExpectedIdx({})"]
pub(crate) struct ExpectedIdx {}
}
rustc_index::newtype_index! {
pub(crate) struct ProvidedIdx {
DEBUG_FORMAT = "ProvidedIdx({})",
}
#[debug_format = "ProvidedIdx({})"]
pub(crate) struct ProvidedIdx {}
}
impl ExpectedIdx {

10
compiler/rustc_hir_typeck/src/generator_interior/drop_ranges/mod.rs
View File

@ -96,15 +96,13 @@ fn for_each_consumable<'tcx>(hir: Map<'tcx>, place: TrackedValue, mut f: impl Fn
}
rustc_index::newtype_index! {
pub struct PostOrderId {
DEBUG_FORMAT = "id({})",
}
#[debug_format = "id({})"]
pub struct PostOrderId {}
}
rustc_index::newtype_index! {
pub struct TrackedValueIndex {
DEBUG_FORMAT = "hidx({})",
}
#[debug_format = "hidx({})"]
pub struct TrackedValueIndex {}
}
/// Identifies a value whose drop state we need to track.

5
compiler/rustc_index/src/vec/tests.rs
View File

@ -3,7 +3,10 @@
// Allows the macro invocation below to work
use crate as rustc_index;
rustc_macros::newtype_index!(struct MyIdx { MAX = 0xFFFF_FFFA });
rustc_macros::newtype_index! {
#[max = 0xFFFF_FFFA]
struct MyIdx {}
}
#[test]
fn index_size_is_optimized() {

10
compiler/rustc_infer/src/infer/region_constraints/leak_check.rs
View File

@ -357,15 +357,13 @@ impl<'tcx> SccUniverse<'tcx> {
}
rustc_index::newtype_index! {
struct LeakCheckNode {
DEBUG_FORMAT = "LeakCheckNode({})"
}
#[debug_format = "LeakCheckNode({})"]
struct LeakCheckNode {}
}
rustc_index::newtype_index! {
struct LeakCheckScc {
DEBUG_FORMAT = "LeakCheckScc({})"
}
#[debug_format = "LeakCheckScc({})"]
struct LeakCheckScc {}
}
/// Represents the graph of constraints. For each `R1: R2` constraint we create

4
compiler/rustc_lint/src/levels.rs
View File

@ -39,9 +39,9 @@ struct LintLevelSets {
}
rustc_index::newtype_index! {
#[custom_encodable] // we don't need encoding
struct LintStackIndex {
ENCODABLE = custom, // we don't need encoding
const COMMAND_LINE = 0,
const COMMAND_LINE = 0;
}
}

155
compiler/rustc_macros/src/newtype.rs
View File

@ -1,35 +1,15 @@
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::parse::*;
use syn::punctuated::Punctuated;
use syn::*;
mod kw {
syn::custom_keyword!(derive);
syn::custom_keyword!(DEBUG_FORMAT);
syn::custom_keyword!(MAX);
syn::custom_keyword!(ENCODABLE);
syn::custom_keyword!(custom);
syn::custom_keyword!(ORD_IMPL);
}
#[derive(Debug)]
enum DebugFormat {
// The user will provide a custom `Debug` impl, so we shouldn't generate
// one
Custom,
// Use the specified format string in the generated `Debug` impl
// By default, this is "{}"
Format(String),
}
// We parse the input and emit the output in a single step.
// This field stores the final macro output
struct Newtype(TokenStream);
impl Parse for Newtype {
fn parse(input: ParseStream<'_>) -> Result<Self> {
let attrs = input.call(Attribute::parse_outer)?;
let mut attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
input.parse::<Token![struct]>()?;
let name: Ident = input.parse()?;
@ -39,93 +19,68 @@ impl Parse for Newtype {
// Any additional `#[derive]` macro paths to apply
let mut derive_paths: Vec<Path> = Vec::new();
let mut debug_format: Option<DebugFormat> = None;
let mut debug_format: Option<Lit> = None;
let mut max = None;
let mut consts = Vec::new();
let mut encodable = true;
let mut ord = true;
// Parse an optional trailing comma
let try_comma = || -> Result<()> {
if body.lookahead1().peek(Token![,]) {
body.parse::<Token![,]>()?;
}
Ok(())
};
if body.lookahead1().peek(Token![..]) {
body.parse::<Token![..]>()?;
} else {
loop {
if body.lookahead1().peek(kw::derive) {
body.parse::<kw::derive>()?;
let derives;
bracketed!(derives in body);
let derives: Punctuated<Path, Token![,]> =
derives.parse_terminated(Path::parse)?;
try_comma()?;
derive_paths.extend(derives);
continue;
attrs.retain(|attr| match attr.path.get_ident() {
Some(ident) => match &*ident.to_string() {
"custom_encodable" => {
encodable = false;
false
}
if body.lookahead1().peek(kw::DEBUG_FORMAT) {
body.parse::<kw::DEBUG_FORMAT>()?;
body.parse::<Token![=]>()?;
let new_debug_format = if body.lookahead1().peek(kw::custom) {
body.parse::<kw::custom>()?;
DebugFormat::Custom
} else {
let format_str: LitStr = body.parse()?;
DebugFormat::Format(format_str.value())
"no_ord_impl" => {
ord = false;
false
}
"max" => {
let Ok(Meta::NameValue(literal) )= attr.parse_meta() else {
panic!("#[max = NUMBER] attribute requires max value");
};
try_comma()?;
if let Some(old) = debug_format.replace(new_debug_format) {
if let Some(old) = max.replace(literal.lit) {
panic!("Specified multiple max: {:?}", old);
}
false
}
"debug_format" => {
let Ok(Meta::NameValue(literal) )= attr.parse_meta() else {
panic!("#[debug_format = FMT] attribute requires a format");
};
if let Some(old) = debug_format.replace(literal.lit) {
panic!("Specified multiple debug format options: {:?}", old);
}
continue;
}
if body.lookahead1().peek(kw::MAX) {
body.parse::<kw::MAX>()?;
body.parse::<Token![=]>()?;
let val: Lit = body.parse()?;
try_comma()?;
if let Some(old) = max.replace(val) {
panic!("Specified multiple MAX: {:?}", old);
}
continue;
}
if body.lookahead1().peek(kw::ENCODABLE) {
body.parse::<kw::ENCODABLE>()?;
body.parse::<Token![=]>()?;
body.parse::<kw::custom>()?;
try_comma()?;
encodable = false;
continue;
}
if body.lookahead1().peek(kw::ORD_IMPL) {
body.parse::<kw::ORD_IMPL>()?;
body.parse::<Token![=]>()?;
body.parse::<kw::custom>()?;
ord = false;
continue;
}
// We've parsed everything that the user provided, so we're done
if body.is_empty() {
break;
false
}
_ => true,
},
_ => true,
});
// Otherwise, we are parsing a user-defined constant
let const_attrs = body.call(Attribute::parse_outer)?;
body.parse::<Token![const]>()?;
let const_name: Ident = body.parse()?;
body.parse::<Token![=]>()?;
let const_val: Expr = body.parse()?;
try_comma()?;
consts.push(quote! { #(#const_attrs)* #vis const #const_name: #name = #name::from_u32(#const_val); });
loop {
// We've parsed everything that the user provided, so we're done
if body.is_empty() {
break;
}
// Otherwise, we are parsing a user-defined constant
let const_attrs = body.call(Attribute::parse_outer)?;
body.parse::<Token![const]>()?;
let const_name: Ident = body.parse()?;
body.parse::<Token![=]>()?;
let const_val: Expr = body.parse()?;
body.parse::<Token![;]>()?;
consts.push(quote! { #(#const_attrs)* #vis const #const_name: #name = #name::from_u32(#const_val); });
}
let debug_format = debug_format.unwrap_or(DebugFormat::Format("{}".to_string()));
let debug_format =
debug_format.unwrap_or_else(|| Lit::Str(LitStr::new("{}", Span::call_site())));
// shave off 256 indices at the end to allow space for packing these indices into enums
let max = max.unwrap_or_else(|| Lit::Int(LitInt::new("0xFFFF_FF00", Span::call_site())));
@ -180,18 +135,14 @@ impl Parse for Newtype {
quote! {}
};
let debug_impl = match debug_format {
DebugFormat::Custom => quote! {},
DebugFormat::Format(format) => {
quote! {
impl ::std::fmt::Debug for #name {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(fmt, #format, self.as_u32())
}
}
let debug_impl = quote! {
impl ::std::fmt::Debug for #name {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(fmt, #debug_format, self.as_u32())
}
}
};
let spec_partial_eq_impl = if let Lit::Int(max) = &max {
if let Ok(max_val) = max.base10_parse::<u32>() {
quote! {

5
compiler/rustc_middle/src/middle/region.rs
View File

@ -147,9 +147,8 @@ rustc_index::newtype_index! {
///
/// * The subscope with `first_statement_index == 1` is scope of `c`,
/// and thus does not include EXPR_2, but covers the `...`.
pub struct FirstStatementIndex {
derive [HashStable]
}
#[derive(HashStable)]
pub struct FirstStatementIndex {}
}
// compilation error if size of `ScopeData` is not the same as a `u32`

42
compiler/rustc_middle/src/mir/coverage.rs
View File

@ -10,10 +10,10 @@ rustc_index::newtype_index! {
/// CounterValueReference.as_u32() (which ascend from 1) or an ExpressionOperandId.as_u32()
/// (which _*descend*_ from u32::MAX). Id value `0` (zero) represents a virtual counter with a
/// constant value of `0`.
#[derive(HashStable)]
#[max = 0xFFFF_FFFF]
#[debug_format = "ExpressionOperandId({})"]
pub struct ExpressionOperandId {
derive [HashStable]
DEBUG_FORMAT = "ExpressionOperandId({})",
MAX = 0xFFFF_FFFF,
}
}
@ -32,11 +32,10 @@ impl ExpressionOperandId {
}
rustc_index::newtype_index! {
pub struct CounterValueReference {
derive [HashStable]
DEBUG_FORMAT = "CounterValueReference({})",
MAX = 0xFFFF_FFFF,
}
#[derive(HashStable)]
#[max = 0xFFFF_FFFF]
#[debug_format = "CounterValueReference({})"]
pub struct CounterValueReference {}
}
impl CounterValueReference {
@ -56,33 +55,30 @@ rustc_index::newtype_index! {
/// InjectedExpressionId.as_u32() converts to ExpressionOperandId.as_u32()
///
/// Values descend from u32::MAX.
pub struct InjectedExpressionId {
derive [HashStable]
DEBUG_FORMAT = "InjectedExpressionId({})",
MAX = 0xFFFF_FFFF,
}
#[derive(HashStable)]
#[max = 0xFFFF_FFFF]
#[debug_format = "InjectedExpressionId({})"]
pub struct InjectedExpressionId {}
}
rustc_index::newtype_index! {
/// InjectedExpressionIndex.as_u32() translates to u32::MAX - ExpressionOperandId.as_u32()
///
/// Values ascend from 0.
pub struct InjectedExpressionIndex {
derive [HashStable]
DEBUG_FORMAT = "InjectedExpressionIndex({})",
MAX = 0xFFFF_FFFF,
}
#[derive(HashStable)]
#[max = 0xFFFF_FFFF]
#[debug_format = "InjectedExpressionIndex({})"]
pub struct InjectedExpressionIndex {}
}
rustc_index::newtype_index! {
/// MappedExpressionIndex values ascend from zero, and are recalculated indexes based on their
/// array position in the LLVM coverage map "Expressions" array, which is assembled during the
/// "mapgen" process. They cannot be computed algorithmically, from the other `newtype_index`s.
pub struct MappedExpressionIndex {
derive [HashStable]
DEBUG_FORMAT = "MappedExpressionIndex({})",
MAX = 0xFFFF_FFFF,
}
#[derive(HashStable)]
#[max = 0xFFFF_FFFF]
#[debug_format = "MappedExpressionIndex({})"]
pub struct MappedExpressionIndex {}
}
impl From<CounterValueReference> for ExpressionOperandId {

32
compiler/rustc_middle/src/mir/mod.rs
View File

@ -654,10 +654,10 @@ impl SourceInfo {
// Variables and temps
rustc_index::newtype_index! {
#[derive(HashStable)]
#[debug_format = "_{}"]
pub struct Local {
derive [HashStable]
DEBUG_FORMAT = "_{}",
const RETURN_PLACE = 0,
const RETURN_PLACE = 0;
}
}
@ -1146,10 +1146,10 @@ rustc_index::newtype_index! {
/// https://rustc-dev-guide.rust-lang.org/appendix/background.html#what-is-a-dataflow-analysis
/// [`CriticalCallEdges`]: ../../rustc_const_eval/transform/add_call_guards/enum.AddCallGuards.html#variant.CriticalCallEdges
/// [guide-mir]: https://rustc-dev-guide.rust-lang.org/mir/
#[derive(HashStable)]
#[debug_format = "bb{}"]
pub struct BasicBlock {
derive [HashStable]
DEBUG_FORMAT = "bb{}",
const START_BLOCK = 0,
const START_BLOCK = 0;
}
}
@ -1530,10 +1530,9 @@ rustc_index::newtype_index! {
/// [wrapper]: https://rustc-dev-guide.rust-lang.org/appendix/glossary.html#newtype
/// [CFG]: https://rustc-dev-guide.rust-lang.org/appendix/background.html#cfg
/// [mir-datatypes]: https://rustc-dev-guide.rust-lang.org/mir/index.html#mir-data-types
pub struct Field {
derive [HashStable]
DEBUG_FORMAT = "field[{}]"
}
#[derive(HashStable)]
#[debug_format = "field[{}]"]
pub struct Field {}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@ -1757,10 +1756,10 @@ impl Debug for Place<'_> {
// Scopes
rustc_index::newtype_index! {
#[derive(HashStable)]
#[debug_format = "scope[{}]"]
pub struct SourceScope {
derive [HashStable]
DEBUG_FORMAT = "scope[{}]",
const OUTERMOST_SOURCE_SCOPE = 0,
const OUTERMOST_SOURCE_SCOPE = 0;
}
}
@ -2755,10 +2754,9 @@ impl<'tcx> TypeVisitable<'tcx> for UserTypeProjection {
}
rustc_index::newtype_index! {
pub struct Promoted {
derive [HashStable]
DEBUG_FORMAT = "promoted[{}]"
}
#[derive(HashStable)]
#[debug_format = "promoted[{}]"]
pub struct Promoted {}
}
impl<'tcx> Debug for Constant<'tcx> {

7
compiler/rustc_middle/src/mir/query.rs
View File

@ -130,10 +130,9 @@ pub struct UnsafetyCheckResult {
}
rustc_index::newtype_index! {
pub struct GeneratorSavedLocal {
derive [HashStable]
DEBUG_FORMAT = "_{}",
}
#[derive(HashStable)]
#[debug_format = "_{}"]
pub struct GeneratorSavedLocal {}
}
/// The layout of generator state.

5
compiler/rustc_middle/src/thir.rs
View File

@ -35,9 +35,8 @@ macro_rules! thir_with_elements {
$(
newtype_index! {
#[derive(HashStable)]
pub struct $id {
DEBUG_FORMAT = $format
}
#[debug_format = $format]
pub struct $id {}
}
)*

6
compiler/rustc_middle/src/ty/structural_impls.rs
View File

@ -99,12 +99,6 @@ impl<'tcx> fmt::Debug for ty::ConstVid<'tcx> {
}
}
impl fmt::Debug for ty::RegionVid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "'_#{}r", self.index())
}
}
impl<'tcx> fmt::Debug for ty::TraitRef<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
with_no_trimmed_paths!(fmt::Display::fmt(self, f))

7
compiler/rustc_middle/src/ty/sty.rs
View File

@ -1378,9 +1378,8 @@ pub struct ConstVid<'tcx> {
rustc_index::newtype_index! {
/// A **region** (lifetime) **v**ariable **ID**.
#[derive(HashStable)]
pub struct RegionVid {
DEBUG_FORMAT = custom,
}
#[debug_format = "'_#{}r"]
pub struct RegionVid {}
}
impl Atom for RegionVid {
@ -1391,7 +1390,7 @@ impl Atom for RegionVid {
rustc_index::newtype_index! {
#[derive(HashStable)]
pub struct BoundVar { .. }
pub struct BoundVar {}
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]

6
compiler/rustc_middle/src/ty/typeck_results.rs
View File

@ -608,10 +608,10 @@ impl<'a, V> LocalTableInContextMut<'a, V> {
}
rustc_index::newtype_index! {
#[derive(HashStable)]
#[debug_format = "UserType({})"]
pub struct UserTypeAnnotationIndex {
derive [HashStable]
DEBUG_FORMAT = "UserType({})",
const START_INDEX = 0,
const START_INDEX = 0;
}
}

2
compiler/rustc_mir_build/src/build/mod.rs
View File

@ -372,7 +372,7 @@ struct CFG<'tcx> {
}
rustc_index::newtype_index! {
struct ScopeId { .. }
struct ScopeId {}
}
#[derive(Debug)]

2
compiler/rustc_mir_build/src/build/scope.rs
View File

@ -185,7 +185,7 @@ pub(crate) enum BreakableTarget {
}
rustc_index::newtype_index! {
struct DropIdx { .. }
struct DropIdx {}
}
const ROOT_NODE: DropIdx = DropIdx::from_u32(0);

15
compiler/rustc_mir_dataflow/src/move_paths/mod.rs
View File

@ -14,9 +14,8 @@ use self::abs_domain::{AbstractElem, Lift};
mod abs_domain;
rustc_index::newtype_index! {
pub struct MovePathIndex {
DEBUG_FORMAT = "mp{}"
}
#[debug_format = "mp{}"]
pub struct MovePathIndex {}
}
impl polonius_engine::Atom for MovePathIndex {
@ -26,15 +25,13 @@ impl polonius_engine::Atom for MovePathIndex {
}
rustc_index::newtype_index! {
pub struct MoveOutIndex {
DEBUG_FORMAT = "mo{}"
}
#[debug_format = "mo{}"]
pub struct MoveOutIndex {}
}
rustc_index::newtype_index! {
pub struct InitIndex {
DEBUG_FORMAT = "in{}"
}
#[debug_format = "in{}"]
pub struct InitIndex {}
}
impl MoveOutIndex {

4
compiler/rustc_mir_transform/src/coverage/graph.rs
View File

@ -282,9 +282,9 @@ impl graph::WithPredecessors for CoverageGraph {
rustc_index::newtype_index! {
/// A node in the control-flow graph of CoverageGraph.
#[debug_format = "bcb{}"]
pub(super) struct BasicCoverageBlock {
DEBUG_FORMAT = "bcb{}",
const START_BCB = 0,
const START_BCB = 0;
}
}

10
compiler/rustc_passes/src/liveness.rs
View File

@ -108,15 +108,13 @@ use std::rc::Rc;
mod rwu_table;
rustc_index::newtype_index! {
pub struct Variable {
DEBUG_FORMAT = "v({})",
}
#[debug_format = "v({})"]
pub struct Variable {}
}
rustc_index::newtype_index! {
pub struct LiveNode {
DEBUG_FORMAT = "ln({})",
}
#[debug_format = "ln({})"]
pub struct LiveNode {}
}
#[derive(Copy, Clone, PartialEq, Debug)]

4
compiler/rustc_query_system/src/dep_graph/graph.rs
View File

@ -37,7 +37,7 @@ pub struct DepGraph<K: DepKind> {
}
rustc_index::newtype_index! {
pub struct DepNodeIndex { .. }
pub struct DepNodeIndex {}
}
impl DepNodeIndex {
@ -974,7 +974,7 @@ pub struct WorkProduct {
// Index type for `DepNodeData`'s edges.
rustc_index::newtype_index! {
struct EdgeIndex { .. }
struct EdgeIndex {}
}
/// `CurrentDepGraph` stores the dependency graph for the current session. It

5
compiler/rustc_query_system/src/dep_graph/serialized.rs
View File

@ -27,9 +27,8 @@ use smallvec::SmallVec;
// unused so that we can store multiple index types in `CompressedHybridIndex`,
// and use those bits to encode which index type it contains.
rustc_index::newtype_index! {
pub struct SerializedDepNodeIndex {
MAX = 0x7FFF_FFFF
}
#[max = 0x7FFF_FFFF]
pub struct SerializedDepNodeIndex {}
}
/// Data for use when recompiling the **current crate**.

14
compiler/rustc_span/src/def_id.rs
View File

@ -10,10 +10,9 @@ use std::fmt;
use std::hash::{Hash, Hasher};
rustc_index::newtype_index! {
pub struct CrateNum {
ENCODABLE = custom
DEBUG_FORMAT = "crate{}"
}
#[custom_encodable]
#[debug_format = "crate{}"]
pub struct CrateNum {}
}
/// Item definitions in the currently-compiled crate would have the `CrateNum`
@ -194,13 +193,12 @@ rustc_index::newtype_index! {
/// A DefIndex is an index into the hir-map for a crate, identifying a
/// particular definition. It should really be considered an interned
/// shorthand for a particular DefPath.
#[custom_encodable] // (only encodable in metadata)
#[debug_format = "DefIndex({})"]
pub struct DefIndex {
ENCODABLE = custom // (only encodable in metadata)
DEBUG_FORMAT = "DefIndex({})",
/// The crate root is always assigned index 0 by the AST Map code,
/// thanks to `NodeCollector::new`.
const CRATE_DEF_INDEX = 0,
const CRATE_DEF_INDEX = 0;
}
}

14
compiler/rustc_span/src/hygiene.rs
View File

@ -61,9 +61,8 @@ pub struct SyntaxContextData {
rustc_index::newtype_index! {
/// A unique ID associated with a macro invocation and expansion.
pub struct ExpnIndex {
ENCODABLE = custom
}
#[custom_encodable]
pub struct ExpnIndex {}
}
/// A unique ID associated with a macro invocation and expansion.
@ -82,11 +81,10 @@ impl fmt::Debug for ExpnId {
rustc_index::newtype_index! {
/// A unique ID associated with a macro invocation and expansion.
pub struct LocalExpnId {
ENCODABLE = custom
ORD_IMPL = custom
DEBUG_FORMAT = "expn{}"
}
#[custom_encodable]
#[no_ord_impl]
#[debug_format = "expn{}"]
pub struct LocalExpnId {}
}
// To ensure correctness of incremental compilation,

2
compiler/rustc_span/src/symbol.rs
View File

@ -1802,7 +1802,7 @@ impl fmt::Display for MacroRulesNormalizedIdent {
pub struct Symbol(SymbolIndex);
rustc_index::newtype_index! {
struct SymbolIndex { .. }
struct SymbolIndex {}
}
impl Symbol {

5
compiler/rustc_target/src/abi/mod.rs
View File

@ -20,9 +20,8 @@ impl ToJson for Endian {
}
rustc_index::newtype_index! {
pub struct VariantIdx {
derive [HashStable_Generic]
}
#[derive(HashStable_Generic)]
pub struct VariantIdx {}
}
#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)]

14
compiler/rustc_type_ir/src/lib.rs
View File

@ -301,9 +301,9 @@ rustc_index::newtype_index! {
///
/// [dbi]: https://en.wikipedia.org/wiki/De_Bruijn_index
#[derive(HashStable_Generic)]
#[debug_format = "DebruijnIndex({})"]
pub struct DebruijnIndex {
DEBUG_FORMAT = "DebruijnIndex({})",
const INNERMOST = 0,
const INNERMOST = 0;
}
}
@ -499,9 +499,8 @@ pub struct FloatVarValue(pub FloatTy);
rustc_index::newtype_index! {
/// A **ty**pe **v**ariable **ID**.
pub struct TyVid {
DEBUG_FORMAT = "_#{}t"
}
#[debug_format = "_#{}t"]
pub struct TyVid {}
}
/// An **int**egral (`u32`, `i32`, `usize`, etc.) type **v**ariable **ID**.
@ -788,9 +787,8 @@ rustc_index::newtype_index! {
/// type -- an idealized representative of "types in general" that we
/// use for checking generic functions.
#[derive(HashStable_Generic)]
pub struct UniverseIndex {
DEBUG_FORMAT = "U{}",
}
#[debug_format = "U{}"]
pub struct UniverseIndex {}
}
impl UniverseIndex {