Rename value field to expr to simplify later commits' diffs

oli-obk · jdonszelmann · commit 53b2c7cc95a0 · 2024-12-15T18:47:45.000+01:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -1759,7 +1759,7 @@ pub enum AttrArgs {
         /// Span of the `=` token.
         eq_span: Span,
 
-        value: AttrArgsEq,
+        expr: AttrArgsEq,
     },
 }
 
@@ -1804,7 +1804,7 @@ impl AttrArgs {
         match self {
             AttrArgs::Empty => None,
             AttrArgs::Delimited(args) => Some(args.dspan.entire()),
-            AttrArgs::Eq { eq_span, value } => Some(eq_span.to(value.span())),
+            AttrArgs::Eq { eq_span, expr } => Some(eq_span.to(expr.span())),
         }
     }
 
@@ -1814,7 +1814,7 @@ impl AttrArgs {
         match self {
             AttrArgs::Empty => TokenStream::default(),
             AttrArgs::Delimited(args) => args.tokens.clone(),
-            AttrArgs::Eq { value, .. } => TokenStream::from_ast(value.unwrap_ast()),
+            AttrArgs::Eq { expr, .. } => TokenStream::from_ast(expr.unwrap_ast()),
         }
     }
 }
@@ -1828,10 +1828,10 @@ where
         match self {
             AttrArgs::Empty => {}
             AttrArgs::Delimited(args) => args.hash_stable(ctx, hasher),
-            AttrArgs::Eq { value: AttrArgsEq::Ast(expr), .. } => {
+            AttrArgs::Eq { expr: AttrArgsEq::Ast(expr), .. } => {
                 unreachable!("hash_stable {:?}", expr);
             }
-            AttrArgs::Eq { eq_span, value: AttrArgsEq::Hir(lit) } => {
+            AttrArgs::Eq { eq_span, expr: AttrArgsEq::Hir(lit) } => {
                 eq_span.hash_stable(ctx, hasher);
                 lit.hash_stable(ctx, hasher);
             }
diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
@@ -268,7 +268,7 @@ impl AttrItem {
     /// ```
     fn value_str(&self) -> Option<Symbol> {
         match &self.args {
-            AttrArgs::Eq { value, .. } => value.value_str(),
+            AttrArgs::Eq { expr, .. } => expr.value_str(),
             AttrArgs::Delimited(_) | AttrArgs::Empty => None,
         }
     }
@@ -492,7 +492,7 @@ impl MetaItemKind {
                 MetaItemKind::list_from_tokens(tokens.clone()).map(MetaItemKind::List)
             }
             AttrArgs::Delimited(..) => None,
-            AttrArgs::Eq { value: AttrArgsEq::Ast(expr), .. } => match expr.kind {
+            AttrArgs::Eq { expr: AttrArgsEq::Ast(expr), .. } => match expr.kind {
                 ExprKind::Lit(token_lit) => {
                     // Turn failures to `None`, we'll get parse errors elsewhere.
                     MetaItemLit::from_token_lit(token_lit, expr.span)
@@ -501,7 +501,7 @@ impl MetaItemKind {
                 }
                 _ => None,
             },
-            AttrArgs::Eq { value: AttrArgsEq::Hir(lit), .. } => {
+            AttrArgs::Eq { expr: AttrArgsEq::Hir(lit), .. } => {
                 Some(MetaItemKind::NameValue(lit.clone()))
             }
         }
@@ -704,7 +704,7 @@ pub fn mk_attr_name_value_str(
         tokens: None,
     });
     let path = Path::from_ident(Ident::new(name, span));
-    let args = AttrArgs::Eq { eq_span: span, value: AttrArgsEq::Ast(expr) };
+    let args = AttrArgs::Eq { eq_span: span, expr: AttrArgsEq::Ast(expr) };
     mk_attr(g, style, unsafety, path, args, span)
 }
 
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -451,8 +451,8 @@ fn visit_attr_args<T: MutVisitor>(vis: &mut T, args: &mut AttrArgs) {
     match args {
         AttrArgs::Empty => {}
         AttrArgs::Delimited(args) => visit_delim_args(vis, args),
-        AttrArgs::Eq { eq_span, value } => {
-            vis.visit_expr(value.unwrap_ast_mut());
+        AttrArgs::Eq { eq_span, expr } => {
+            vis.visit_expr(expr.unwrap_ast_mut());
             vis.visit_span(eq_span);
         }
     }
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -1287,7 +1287,7 @@ pub fn walk_attr_args<'a, V: Visitor<'a>>(visitor: &mut V, args: &'a AttrArgs) -
     match args {
         AttrArgs::Empty => {}
         AttrArgs::Delimited(_args) => {}
-        AttrArgs::Eq { value, .. } => try_visit!(visitor.visit_expr(value.unwrap_ast())),
+        AttrArgs::Eq { expr, .. } => try_visit!(visitor.visit_expr(expr.unwrap_ast())),
     }
     V::Result::output()
 }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -896,8 +896,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // This is an inert key-value attribute - it will never be visible to macros
             // after it gets lowered to HIR. Therefore, we can extract literals to handle
             // nonterminals in `#[doc]` (e.g. `#[doc = $e]`).
-            &AttrArgs::Eq { eq_span, ref value } => {
-                let expr = value.unwrap_ast();
+            &AttrArgs::Eq { eq_span, ref expr } => {
+                let expr = expr.unwrap_ast();
                 // In valid code the value always ends up as a single literal. Otherwise, a dummy
                 // literal suffices because the error is handled elsewhere.
                 let lit = if let ExprKind::Lit(token_lit) = expr.kind
@@ -913,7 +913,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         span: DUMMY_SP,
                     }
                 };
-                AttrArgs::Eq { eq_span, value: AttrArgsEq::Hir(lit) }
+                AttrArgs::Eq { eq_span, expr: AttrArgsEq::Hir(lit) }
             }
         }
     }
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -648,14 +648,14 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             AttrArgs::Empty => {
                 self.print_path(&item.path, false, 0);
             }
-            AttrArgs::Eq { value: AttrArgsEq::Ast(expr), .. } => {
+            AttrArgs::Eq { expr: AttrArgsEq::Ast(expr), .. } => {
                 self.print_path(&item.path, false, 0);
                 self.space();
                 self.word_space("=");
                 let token_str = self.expr_to_string(expr);
                 self.word(token_str);
             }
-            AttrArgs::Eq { value: AttrArgsEq::Hir(lit), .. } => {
+            AttrArgs::Eq { expr: AttrArgsEq::Hir(lit), .. } => {
                 self.print_path(&item.path, false, 0);
                 self.space();
                 self.word_space("=");
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
@@ -1376,7 +1376,7 @@ impl<'a> Parser<'a> {
             AttrArgs::Delimited(args)
         } else if self.eat(&token::Eq) {
             let eq_span = self.prev_token.span;
-            AttrArgs::Eq { eq_span, value: AttrArgsEq::Ast(self.parse_expr_force_collect()?) }
+            AttrArgs::Eq { eq_span, expr: AttrArgsEq::Ast(self.parse_expr_force_collect()?) }
         } else {
             AttrArgs::Empty
         })
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
@@ -70,7 +70,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
                     parse_in(psess, tokens.clone(), "meta list", |p| p.parse_meta_seq_top())?;
                 MetaItemKind::List(nmis)
             }
-            AttrArgs::Eq { value: AttrArgsEq::Ast(expr), .. } => {
+            AttrArgs::Eq { expr: AttrArgsEq::Ast(expr), .. } => {
                 if let ast::ExprKind::Lit(token_lit) = expr.kind {
                     let res = ast::MetaItemLit::from_token_lit(token_lit, expr.span);
                     let res = match res {
@@ -116,9 +116,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
                     return Err(err);
                 }
             }
-            AttrArgs::Eq { value: AttrArgsEq::Hir(lit), .. } => {
-                MetaItemKind::NameValue(lit.clone())
-            }
+            AttrArgs::Eq { expr: AttrArgsEq::Hir(lit), .. } => MetaItemKind::NameValue(lit.clone()),
         },
     })
 }
diff --git a/compiler/rustc_resolve/src/rustdoc.rs b/compiler/rustc_resolve/src/rustdoc.rs
@@ -220,9 +220,9 @@ pub fn attrs_to_doc_fragments<'a>(
 
 fn span_for_value(attr: &ast::Attribute) -> Span {
     if let ast::AttrKind::Normal(normal) = &attr.kind
-        && let ast::AttrArgs::Eq { value, .. } = &normal.item.args
+        && let ast::AttrArgs::Eq { expr, .. } = &normal.item.args
     {
-        value.span().with_ctxt(attr.span.ctxt())
+        expr.span().with_ctxt(attr.span.ctxt())
     } else {
         attr.span
     }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
@@ -639,7 +639,7 @@ impl<'tcx> OnUnimplementedDirective {
                 let report_span = match &item.args {
                     AttrArgs::Empty => item.path.span,
                     AttrArgs::Delimited(args) => args.dspan.entire(),
-                    AttrArgs::Eq { eq_span, value } => eq_span.to(value.span()),
+                    AttrArgs::Eq { eq_span, expr } => eq_span.to(expr.span()),
                 };
 
                 if let Some(item_def_id) = item_def_id.as_local() {
diff --git a/src/tools/clippy/clippy_lints/src/attrs/should_panic_without_expect.rs b/src/tools/clippy/clippy_lints/src/attrs/should_panic_without_expect.rs
@@ -9,7 +9,7 @@ use rustc_span::sym;
 
 pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute) {
     if let AttrKind::Normal(normal_attr) = &attr.kind {
-        if let AttrArgs::Eq { value:  AttrArgsEq::Ast(_), .. } = &normal_attr.item.args {
+        if let AttrArgs::Eq { expr:  AttrArgsEq::Ast(_), .. } = &normal_attr.item.args {
             // `#[should_panic = ".."]` found, good
             return;
         }
diff --git a/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs b/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs
@@ -12,7 +12,7 @@ pub fn check(cx: &LateContext<'_>, attrs: &[Attribute]) {
         if !attr.span.from_expansion()
             && let AttrKind::Normal(ref normal) = attr.kind
             && normal.item.path == sym::doc
-            && let AttrArgs::Eq { value: AttrArgsEq::Hir(ref meta), .. } = normal.item.args
+            && let AttrArgs::Eq { expr: AttrArgsEq::Hir(ref meta), .. } = normal.item.args
             && !attr.span.contains(meta.span)
             // Since the `include_str` is already expanded at this point, we can only take the
             // whole attribute snippet and then modify for our suggestion.
diff --git a/src/tools/clippy/clippy_lints/src/large_include_file.rs b/src/tools/clippy/clippy_lints/src/large_include_file.rs
@@ -96,7 +96,7 @@ impl LateLintPass<'_> for LargeIncludeFile {
             && let AttrKind::Normal(ref normal) = attr.kind
             && let Some(doc) = attr.doc_str()
             && doc.as_str().len() as u64 > self.max_file_size
-            && let AttrArgs::Eq { value: AttrArgsEq::Hir(ref meta), .. } = normal.item.args
+            && let AttrArgs::Eq { expr: AttrArgsEq::Hir(ref meta), .. } = normal.item.args
             && !attr.span.contains(meta.span)
             // Since the `include_str` is already expanded at this point, we can only take the
             // whole attribute snippet and then modify for our suggestion.
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils.rs b/src/tools/clippy/clippy_utils/src/ast_utils.rs
@@ -872,8 +872,8 @@ pub fn eq_attr_args(l: &AttrArgs, r: &AttrArgs) -> bool {
     match (l, r) {
         (Empty, Empty) => true,
         (Delimited(la), Delimited(ra)) => eq_delim_args(la, ra),
-        (Eq { value: AttrArgsEq::Ast(le), .. }, Eq{ value: AttrArgsEq::Ast(re), .. }) => eq_expr(le, re),
-        (Eq { value: AttrArgsEq::Hir(ll), .. }, Eq{ value: AttrArgsEq::Hir(rl), .. }) => ll.kind == rl.kind,
+        (Eq { expr: AttrArgsEq::Ast(le), .. }, Eq{ expr: AttrArgsEq::Ast(re), .. }) => eq_expr(le, re),
+        (Eq { expr: AttrArgsEq::Hir(ll), .. }, Eq{ expr: AttrArgsEq::Hir(rl), .. }) => ll.kind == rl.kind,
         _ => false,
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1759,7 +1759,7 @@ pub enum AttrArgs {`
`1759`	`1759`	/// Span of the `=` token.
`1760`	`1760`	`eq_span: Span,`
`1761`	`1761`
`1762`		`- value: AttrArgsEq,`
	`1762`	`+ expr: AttrArgsEq,`
`1763`	`1763`	`},`
`1764`	`1764`	`}`
`1765`	`1765`
`@@ -1804,7 +1804,7 @@ impl AttrArgs {`
`1804`	`1804`	`match self {`
`1805`	`1805`	`AttrArgs::Empty => None,`
`1806`	`1806`	`AttrArgs::Delimited(args) => Some(args.dspan.entire()),`
`1807`		`- AttrArgs::Eq { eq_span, value } => Some(eq_span.to(value.span())),`
	`1807`	`+ AttrArgs::Eq { eq_span, expr } => Some(eq_span.to(expr.span())),`
`1808`	`1808`	`}`
`1809`	`1809`	`}`
`1810`	`1810`
`@@ -1814,7 +1814,7 @@ impl AttrArgs {`
`1814`	`1814`	`match self {`
`1815`	`1815`	`AttrArgs::Empty => TokenStream::default(),`
`1816`	`1816`	`AttrArgs::Delimited(args) => args.tokens.clone(),`
`1817`		`- AttrArgs::Eq { value, .. } => TokenStream::from_ast(value.unwrap_ast()),`
	`1817`	`+ AttrArgs::Eq { expr, .. } => TokenStream::from_ast(expr.unwrap_ast()),`
`1818`	`1818`	`}`
`1819`	`1819`	`}`
`1820`	`1820`	`}`
`@@ -1828,10 +1828,10 @@ where`
`1828`	`1828`	`match self {`
`1829`	`1829`	`AttrArgs::Empty => {}`
`1830`	`1830`	`AttrArgs::Delimited(args) => args.hash_stable(ctx, hasher),`
`1831`		`- AttrArgs::Eq { value: AttrArgsEq::Ast(expr), .. } => {`
	`1831`	`+ AttrArgs::Eq { expr: AttrArgsEq::Ast(expr), .. } => {`
`1832`	`1832`	`unreachable!("hash_stable {:?}", expr);`
`1833`	`1833`	`}`
`1834`		`- AttrArgs::Eq { eq_span, value: AttrArgsEq::Hir(lit) } => {`
	`1834`	`+ AttrArgs::Eq { eq_span, expr: AttrArgsEq::Hir(lit) } => {`
`1835`	`1835`	`eq_span.hash_stable(ctx, hasher);`
`1836`	`1836`	`lit.hash_stable(ctx, hasher);`
`1837`	`1837`	`}`
Original file line number	Diff line number	Diff line change
`@@ -268,7 +268,7 @@ impl AttrItem {`
`268`	`268`	/// ```
`269`	`269`	`fn value_str(&self) -> Option<Symbol> {`
`270`	`270`	`match &self.args {`
`271`		`- AttrArgs::Eq { value, .. } => value.value_str(),`
	`271`	`+ AttrArgs::Eq { expr, .. } => expr.value_str(),`
`272`	`272`	`AttrArgs::Delimited(_) \| AttrArgs::Empty => None,`
`273`	`273`	`}`
`274`	`274`	`}`
`@@ -492,7 +492,7 @@ impl MetaItemKind {`
`492`	`492`	`MetaItemKind::list_from_tokens(tokens.clone()).map(MetaItemKind::List)`
`493`	`493`	`}`
`494`	`494`	`AttrArgs::Delimited(..) => None,`
`495`		`- AttrArgs::Eq { value: AttrArgsEq::Ast(expr), .. } => match expr.kind {`
	`495`	`+ AttrArgs::Eq { expr: AttrArgsEq::Ast(expr), .. } => match expr.kind {`
`496`	`496`	`ExprKind::Lit(token_lit) => {`
`497`	`497`	// Turn failures to `None`, we'll get parse errors elsewhere.
`498`	`498`	`MetaItemLit::from_token_lit(token_lit, expr.span)`
`@@ -501,7 +501,7 @@ impl MetaItemKind {`
`501`	`501`	`}`
`502`	`502`	`_ => None,`
`503`	`503`	`},`
`504`		`- AttrArgs::Eq { value: AttrArgsEq::Hir(lit), .. } => {`
	`504`	`+ AttrArgs::Eq { expr: AttrArgsEq::Hir(lit), .. } => {`
`505`	`505`	`Some(MetaItemKind::NameValue(lit.clone()))`
`506`	`506`	`}`
`507`	`507`	`}`
`@@ -704,7 +704,7 @@ pub fn mk_attr_name_value_str(`
`704`	`704`	`tokens: None,`
`705`	`705`	`});`
`706`	`706`	`let path = Path::from_ident(Ident::new(name, span));`
`707`		`- let args = AttrArgs::Eq { eq_span: span, value: AttrArgsEq::Ast(expr) };`
	`707`	`+ let args = AttrArgs::Eq { eq_span: span, expr: AttrArgsEq::Ast(expr) };`
`708`	`708`	`mk_attr(g, style, unsafety, path, args, span)`
`709`	`709`	`}`
`710`	`710`
Original file line number	Diff line number	Diff line change
`@@ -451,8 +451,8 @@ fn visit_attr_args<T: MutVisitor>(vis: &mut T, args: &mut AttrArgs) {`
`451`	`451`	`match args {`
`452`	`452`	`AttrArgs::Empty => {}`
`453`	`453`	`AttrArgs::Delimited(args) => visit_delim_args(vis, args),`
`454`		`- AttrArgs::Eq { eq_span, value } => {`
`455`		`- vis.visit_expr(value.unwrap_ast_mut());`
	`454`	`+ AttrArgs::Eq { eq_span, expr } => {`
	`455`	`+ vis.visit_expr(expr.unwrap_ast_mut());`
`456`	`456`	`vis.visit_span(eq_span);`
`457`	`457`	`}`
`458`	`458`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1287,7 +1287,7 @@ pub fn walk_attr_args<'a, V: Visitor<'a>>(visitor: &mut V, args: &'a AttrArgs) -`
`1287`	`1287`	`match args {`
`1288`	`1288`	`AttrArgs::Empty => {}`
`1289`	`1289`	`AttrArgs::Delimited(_args) => {}`
`1290`		`- AttrArgs::Eq { value, .. } => try_visit!(visitor.visit_expr(value.unwrap_ast())),`
	`1290`	`+ AttrArgs::Eq { expr, .. } => try_visit!(visitor.visit_expr(expr.unwrap_ast())),`
`1291`	`1291`	`}`
`1292`	`1292`	`V::Result::output()`
`1293`	`1293`	`}`
Original file line number	Diff line number	Diff line change
`@@ -896,8 +896,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`896`	`896`	`// This is an inert key-value attribute - it will never be visible to macros`
`897`	`897`	`// after it gets lowered to HIR. Therefore, we can extract literals to handle`
`898`	`898`	// nonterminals in `#[doc]` (e.g. `#[doc = $e]`).
`899`		`- &AttrArgs::Eq { eq_span, ref value } => {`
`900`		`- let expr = value.unwrap_ast();`
	`899`	`+ &AttrArgs::Eq { eq_span, ref expr } => {`
	`900`	`+ let expr = expr.unwrap_ast();`
`901`	`901`	`// In valid code the value always ends up as a single literal. Otherwise, a dummy`
`902`	`902`	`// literal suffices because the error is handled elsewhere.`
`903`	`903`	`let lit = if let ExprKind::Lit(token_lit) = expr.kind`
`@@ -913,7 +913,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`913`	`913`	`span: DUMMY_SP,`
`914`	`914`	`}`
`915`	`915`	`};`
`916`		`- AttrArgs::Eq { eq_span, value: AttrArgsEq::Hir(lit) }`
	`916`	`+ AttrArgs::Eq { eq_span, expr: AttrArgsEq::Hir(lit) }`
`917`	`917`	`}`
`918`	`918`	`}`
`919`	`919`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met`
`70`	`70`	`parse_in(psess, tokens.clone(), "meta list", \|p\| p.parse_meta_seq_top())?;`
`71`	`71`	`MetaItemKind::List(nmis)`
`72`	`72`	`}`
`73`		`- AttrArgs::Eq { value: AttrArgsEq::Ast(expr), .. } => {`
	`73`	`+ AttrArgs::Eq { expr: AttrArgsEq::Ast(expr), .. } => {`
`74`	`74`	`if let ast::ExprKind::Lit(token_lit) = expr.kind {`
`75`	`75`	`let res = ast::MetaItemLit::from_token_lit(token_lit, expr.span);`
`76`	`76`	`let res = match res {`
`@@ -116,9 +116,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met`
`116`	`116`	`return Err(err);`
`117`	`117`	`}`
`118`	`118`	`}`
`119`		`- AttrArgs::Eq { value: AttrArgsEq::Hir(lit), .. } => {`
`120`		`- MetaItemKind::NameValue(lit.clone())`
`121`		`- }`
	`119`	`+ AttrArgs::Eq { expr: AttrArgsEq::Hir(lit), .. } => MetaItemKind::NameValue(lit.clone()),`
`122`	`120`	`},`
`123`	`121`	`})`
`124`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -220,9 +220,9 @@ pub fn attrs_to_doc_fragments<'a>(`
`220`	`220`
`221`	`221`	`fn span_for_value(attr: &ast::Attribute) -> Span {`
`222`	`222`	`if let ast::AttrKind::Normal(normal) = &attr.kind`
`223`		`- && let ast::AttrArgs::Eq { value, .. } = &normal.item.args`
	`223`	`+ && let ast::AttrArgs::Eq { expr, .. } = &normal.item.args`
`224`	`224`	`{`
`225`		`- value.span().with_ctxt(attr.span.ctxt())`
	`225`	`+ expr.span().with_ctxt(attr.span.ctxt())`
`226`	`226`	`} else {`
`227`	`227`	`attr.span`
`228`	`228`	`}`