From 24057f74a590be09a683096de25b39f1cbc4ce99 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 2 Jul 2024 09:38:49 +0000 Subject: [PATCH 1/7] Replace kw_span by full span. --- compiler/rustc_ast/src/ast.rs | 9 +++------ compiler/rustc_ast/src/mut_visit.rs | 3 ++- compiler/rustc_ast/src/visit.rs | 2 +- compiler/rustc_ast_lowering/src/lib.rs | 2 +- compiler/rustc_ast_passes/src/ast_validation.rs | 4 ++-- .../src/deriving/generic/mod.rs | 4 ++-- compiler/rustc_parse/src/parser/generics.rs | 14 ++++++++++++-- compiler/rustc_resolve/src/late.rs | 2 +- compiler/rustc_resolve/src/late/diagnostics.rs | 2 +- src/tools/clippy/clippy_utils/src/ast_utils.rs | 4 ++-- src/tools/rustfmt/src/spanned.rs | 2 +- src/tools/rustfmt/src/types.rs | 4 ++-- 12 files changed, 30 insertions(+), 22 deletions(-) diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs index 8e4f4c8e71a2e..92d663cd6c8ce 100644 --- a/compiler/rustc_ast/src/ast.rs +++ b/compiler/rustc_ast/src/ast.rs @@ -353,8 +353,8 @@ pub enum GenericParamKind { }, Const { ty: P, - /// Span of the `const` keyword. - kw_span: Span, + /// Span of the whole parameter definition, including default. + span: Span, /// Optional default value for the const generic param. default: Option, }, @@ -378,10 +378,7 @@ impl GenericParam { self.ident.span } GenericParamKind::Type { default: Some(ty) } => self.ident.span.to(ty.span), - GenericParamKind::Const { kw_span, default: Some(default), .. } => { - kw_span.to(default.value.span) - } - GenericParamKind::Const { kw_span, default: None, ty } => kw_span.to(ty.span), + GenericParamKind::Const { span, .. } => *span, } } } diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs index 2afbd979c3023..d8c7f89e507f5 100644 --- a/compiler/rustc_ast/src/mut_visit.rs +++ b/compiler/rustc_ast/src/mut_visit.rs @@ -950,8 +950,9 @@ pub fn walk_flat_map_generic_param( GenericParamKind::Type { default } => { visit_opt(default, |default| vis.visit_ty(default)); } - GenericParamKind::Const { ty, kw_span: _, default } => { + GenericParamKind::Const { ty, span, default } => { vis.visit_ty(ty); + vis.visit_span(span); visit_opt(default, |default| vis.visit_anon_const(default)); } } diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs index eb71ec5f4ec93..231b3ceb72210 100644 --- a/compiler/rustc_ast/src/visit.rs +++ b/compiler/rustc_ast/src/visit.rs @@ -753,7 +753,7 @@ pub fn walk_generic_param<'a, V: Visitor<'a>>( match kind { GenericParamKind::Lifetime => (), GenericParamKind::Type { default } => visit_opt!(visitor, visit_ty, default), - GenericParamKind::Const { ty, default, kw_span: _ } => { + GenericParamKind::Const { ty, default, span: _ } => { try_visit!(visitor.visit_ty(ty)); visit_opt!(visitor, visit_anon_const, default); } diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 34b8137aea8ef..d7ea4fc529ccb 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -2108,7 +2108,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { (hir::ParamName::Plain(self.lower_ident(param.ident)), kind) } - GenericParamKind::Const { ty, kw_span: _, default } => { + GenericParamKind::Const { ty, span: _, default } => { let ty = self .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault)); diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs index 1d149e91b8513..53117e85b318c 100644 --- a/compiler/rustc_ast_passes/src/ast_validation.rs +++ b/compiler/rustc_ast_passes/src/ast_validation.rs @@ -826,11 +826,11 @@ fn validate_generic_param_order(dcx: DiagCtxtHandle<'_>, generics: &[GenericPara } GenericParamKind::Type { default: None } => (), GenericParamKind::Lifetime => (), - GenericParamKind::Const { ty: _, kw_span: _, default: Some(default) } => { + GenericParamKind::Const { ty: _, span: _, default: Some(default) } => { ordered_params += " = "; ordered_params += &pprust::expr_to_string(&default.value); } - GenericParamKind::Const { ty: _, kw_span: _, default: None } => (), + GenericParamKind::Const { ty: _, span: _, default: None } => (), } first = false; } diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs index 82baaca9a4641..06156b2cc0a14 100644 --- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs +++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs @@ -667,10 +667,10 @@ impl<'a> TraitDef<'a> { cx.typaram(param.ident.span.with_ctxt(ctxt), param.ident, bounds, None) } - GenericParamKind::Const { ty, kw_span, .. } => { + GenericParamKind::Const { ty, span, .. } => { let const_nodefault_kind = GenericParamKind::Const { ty: ty.clone(), - kw_span: kw_span.with_ctxt(ctxt), + span: span.with_ctxt(ctxt), // We can't have default values inside impl block default: None, diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs index 5aebe716b0a10..dc56f56165d65 100644 --- a/compiler/rustc_parse/src/parser/generics.rs +++ b/compiler/rustc_parse/src/parser/generics.rs @@ -114,13 +114,18 @@ impl<'a> Parser<'a> { // Parse optional const generics default value. let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None }; + let span = if let Some(ref default) = default { + const_span.to(default.value.span) + } else { + const_span.to(ty.span) + }; Ok(GenericParam { ident, id: ast::DUMMY_NODE_ID, attrs: preceding_attrs, bounds: Vec::new(), - kind: GenericParamKind::Const { ty, kw_span: const_span, default }, + kind: GenericParamKind::Const { ty, span, default }, is_placeholder: false, colon_span: None, }) @@ -137,6 +142,11 @@ impl<'a> Parser<'a> { // Parse optional const generics default value. let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None }; + let span = if let Some(ref default) = default { + mistyped_const_ident.span.to(default.value.span) + } else { + mistyped_const_ident.span.to(ty.span) + }; self.dcx() .struct_span_err( @@ -156,7 +166,7 @@ impl<'a> Parser<'a> { id: ast::DUMMY_NODE_ID, attrs: preceding_attrs, bounds: Vec::new(), - kind: GenericParamKind::Const { ty, kw_span: mistyped_const_ident.span, default }, + kind: GenericParamKind::Const { ty, span, default }, is_placeholder: false, colon_span: None, }) diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs index adb0ba7c82036..f53198cb6f966 100644 --- a/compiler/rustc_resolve/src/late.rs +++ b/compiler/rustc_resolve/src/late.rs @@ -1552,7 +1552,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> { .bindings .remove(&Ident::with_dummy_span(param.ident.name)); } - GenericParamKind::Const { ref ty, kw_span: _, ref default } => { + GenericParamKind::Const { ref ty, span: _, ref default } => { // Const parameters can't have param bounds. assert!(param.bounds.is_empty()); diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs index f0632a21091bb..73b2563092a0a 100644 --- a/compiler/rustc_resolve/src/late/diagnostics.rs +++ b/compiler/rustc_resolve/src/late/diagnostics.rs @@ -2564,7 +2564,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> { let span = if let [.., bound] = ¶m.bounds[..] { bound.span() } else if let GenericParam { - kind: GenericParamKind::Const { ty, kw_span: _, default }, .. + kind: GenericParamKind::Const { ty, span: _, default }, .. } = param { default.as_ref().map(|def| def.value.span).unwrap_or(ty.span) } else { diff --git a/src/tools/clippy/clippy_utils/src/ast_utils.rs b/src/tools/clippy/clippy_utils/src/ast_utils.rs index 0be6dc15a8e13..711832f78bbd6 100644 --- a/src/tools/clippy/clippy_utils/src/ast_utils.rs +++ b/src/tools/clippy/clippy_utils/src/ast_utils.rs @@ -804,13 +804,13 @@ pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool { ( Const { ty: lt, - kw_span: _, default: ld, + span: _, }, Const { ty: rt, - kw_span: _, default: rd, + span: _, }, ) => eq_ty(lt, rt) && both(ld.as_ref(), rd.as_ref(), eq_anon_const), _ => false, diff --git a/src/tools/rustfmt/src/spanned.rs b/src/tools/rustfmt/src/spanned.rs index 4d684f3c6350d..e0c7473381781 100644 --- a/src/tools/rustfmt/src/spanned.rs +++ b/src/tools/rustfmt/src/spanned.rs @@ -121,7 +121,7 @@ impl Spanned for ast::GenericParam { fn span(&self) -> Span { let lo = match self.kind { _ if !self.attrs.is_empty() => self.attrs[0].span.lo(), - ast::GenericParamKind::Const { kw_span, .. } => kw_span.lo(), + ast::GenericParamKind::Const { span, .. } => span.lo(), _ => self.ident.span.lo(), }; let hi = if self.bounds.is_empty() { diff --git a/src/tools/rustfmt/src/types.rs b/src/tools/rustfmt/src/types.rs index e237662f5aa22..5a293d330fd3e 100644 --- a/src/tools/rustfmt/src/types.rs +++ b/src/tools/rustfmt/src/types.rs @@ -656,7 +656,7 @@ impl Rewrite for ast::GenericParam { let param_start = if let ast::GenericParamKind::Const { ref ty, - kw_span, + span, default, } = &self.kind { @@ -678,7 +678,7 @@ impl Rewrite for ast::GenericParam { default.rewrite_result(context, Shape::legacy(budget, shape.indent))?; param.push_str(&rewrite); } - kw_span.lo() + span.lo() } else { param.push_str(rewrite_ident(context, self.ident)); self.ident.span.lo() From e7618cf10c957439920777a650b542ae516c3609 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 2 Jul 2024 09:39:17 +0000 Subject: [PATCH 2/7] Complete mut_visit. --- compiler/rustc_ast/src/mut_visit.rs | 105 ++++++++++++++++++++++++---- 1 file changed, 90 insertions(+), 15 deletions(-) diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs index d8c7f89e507f5..cf35e4fd04047 100644 --- a/compiler/rustc_ast/src/mut_visit.rs +++ b/compiler/rustc_ast/src/mut_visit.rs @@ -860,7 +860,8 @@ fn visit_constness(vis: &mut T, constness: &mut Const) { fn walk_closure_binder(vis: &mut T, binder: &mut ClosureBinder) { match binder { ClosureBinder::NotPresent => {} - ClosureBinder::For { span: _, generic_params } => { + ClosureBinder::For { span, generic_params } => { + vis.visit_span(span); generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param)); } } @@ -924,6 +925,22 @@ fn walk_param_bound(vis: &mut T, pb: &mut GenericBound) { } } +fn walk_trait_bound_modifier(vis: &mut T, tbm: &mut TraitBoundModifiers) { + let TraitBoundModifiers { constness, asyncness, polarity } = tbm; + match constness { + BoundConstness::Never => {} + BoundConstness::Always(span) | BoundConstness::Maybe(span) => vis.visit_span(span), + } + match asyncness { + BoundAsyncness::Normal => {} + BoundAsyncness::Async(span) => vis.visit_span(span), + } + match polarity { + BoundPolarity::Positive => {} + BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => vis.visit_span(span), + } +} + fn walk_precise_capturing_arg(vis: &mut T, arg: &mut PreciseCapturingArg) { match arg { PreciseCapturingArg::Lifetime(lt) => { @@ -1035,9 +1052,10 @@ fn walk_trait_ref(vis: &mut T, TraitRef { path, ref_id }: &mut Tr } fn walk_poly_trait_ref(vis: &mut T, p: &mut PolyTraitRef) { - let PolyTraitRef { bound_generic_params, modifiers: _, trait_ref, span } = p; + let PolyTraitRef { bound_generic_params, modifiers, trait_ref, span } = p; bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param)); vis.visit_trait_ref(trait_ref); + walk_trait_bound_modifier(vis, modifiers); vis.visit_span(span); } @@ -1377,22 +1395,32 @@ pub fn walk_pat(vis: &mut T, pat: &mut P) { vis.visit_span(span); } -fn walk_anon_const(vis: &mut T, AnonConst { id, value }: &mut AnonConst) { +pub fn walk_anon_const(vis: &mut T, AnonConst { id, value }: &mut AnonConst) { vis.visit_id(id); vis.visit_expr(value); } fn walk_inline_asm(vis: &mut T, asm: &mut InlineAsm) { - // FIXME: Visit spans inside all this currently ignored stuff. let InlineAsm { asm_macro: _, - template: _, - template_strs: _, + template, + template_strs, operands, - clobber_abis: _, + clobber_abis, options: _, - line_spans: _, + line_spans, } = asm; + for piece in template.iter_mut() { + match piece { + InlineAsmTemplatePiece::String(_str) => {} + InlineAsmTemplatePiece::Placeholder { operand_idx: _, modifier: _, span } => { + vis.visit_span(span) + } + } + } + for (_s1, _s2, span) in template_strs.iter_mut() { + vis.visit_span(span) + } for (op, span) in operands { match op { InlineAsmOperand::In { expr, reg: _ } @@ -1411,6 +1439,12 @@ fn walk_inline_asm(vis: &mut T, asm: &mut InlineAsm) { } vis.visit_span(span); } + for (_s1, span) in clobber_abis.iter_mut() { + vis.visit_span(span) + } + for span in line_spans.iter_mut() { + vis.visit_span(span) + } } fn walk_inline_asm_sym( @@ -1423,8 +1457,7 @@ fn walk_inline_asm_sym( } fn walk_format_args(vis: &mut T, fmt: &mut FormatArgs) { - // FIXME: visit the template exhaustively. - let FormatArgs { span, template: _, arguments } = fmt; + let FormatArgs { span, template, arguments } = fmt; for FormatArgument { kind, expr } in arguments.all_args_mut() { match kind { FormatArgumentKind::Named(ident) | FormatArgumentKind::Captured(ident) => { @@ -1434,9 +1467,48 @@ fn walk_format_args(vis: &mut T, fmt: &mut FormatArgs) { } vis.visit_expr(expr); } + for piece in template.iter_mut() { + match piece { + FormatArgsPiece::Literal(_symbol) => {} + FormatArgsPiece::Placeholder(placeholder) => walk_format_placeholder(vis, placeholder), + } + } vis.visit_span(span); } +fn walk_format_placeholder( + vis: &mut T, + FormatPlaceholder { argument, span, format_options, format_trait: _ }: &mut FormatPlaceholder, +) { + visit_opt(span, |span| vis.visit_span(span)); + let FormatArgPosition { span, index: _, kind: _ } = argument; + visit_opt(span, |span| vis.visit_span(span)); + let FormatOptions { + width, + precision, + alignment: _, + fill: _, + sign: _, + alternate: _, + zero_pad: _, + debug_hex: _, + } = format_options; + match width { + None => {} + Some(FormatCount::Literal(_)) => {} + Some(FormatCount::Argument(FormatArgPosition { span, index: _, kind: _ })) => { + visit_opt(span, |span| vis.visit_span(span)) + } + } + match precision { + None => {} + Some(FormatCount::Literal(_)) => {} + Some(FormatCount::Argument(FormatArgPosition { span, index: _, kind: _ })) => { + visit_opt(span, |span| vis.visit_span(span)) + } + } +} + pub fn walk_expr(vis: &mut T, Expr { kind, id, span, attrs, tokens }: &mut Expr) { vis.visit_id(id); visit_attrs(vis, attrs); @@ -1467,7 +1539,8 @@ pub fn walk_expr(vis: &mut T, Expr { kind, id, span, attrs, token visit_thin_exprs(vis, call_args); vis.visit_span(span); } - ExprKind::Binary(_binop, lhs, rhs) => { + ExprKind::Binary(Spanned { node: _binop, span }, lhs, rhs) => { + vis.visit_span(span); vis.visit_expr(lhs); vis.visit_expr(rhs); } @@ -1533,9 +1606,10 @@ pub fn walk_expr(vis: &mut T, Expr { kind, id, span, attrs, token visit_opt(label, |label| vis.visit_label(label)); vis.visit_block(blk); } - ExprKind::Gen(_capture_by, body, _kind, decl_span) => { + ExprKind::Gen(capture_clause, body, _kind, decl_span) => { vis.visit_block(body); vis.visit_span(decl_span); + vis.visit_capture_by(capture_clause); } ExprKind::Await(expr, await_kw_span) => { vis.visit_expr(expr); @@ -1546,7 +1620,8 @@ pub fn walk_expr(vis: &mut T, Expr { kind, id, span, attrs, token vis.visit_expr(er); vis.visit_span(span); } - ExprKind::AssignOp(_op, el, er) => { + ExprKind::AssignOp(Spanned { node: _binop, span }, el, er) => { + vis.visit_span(span); vis.visit_expr(el); vis.visit_expr(er); } @@ -1598,7 +1673,7 @@ pub fn walk_expr(vis: &mut T, Expr { kind, id, span, attrs, token fields.flat_map_in_place(|field| vis.flat_map_expr_field(field)); match rest { StructRest::Base(expr) => vis.visit_expr(expr), - StructRest::Rest(_span) => {} + StructRest::Rest(span) => vis.visit_span(span), StructRest::None => {} } } @@ -1631,6 +1706,7 @@ pub fn walk_flat_map_stmt( Stmt { kind, mut span, mut id }: Stmt, ) -> SmallVec<[Stmt; 1]> { vis.visit_id(&mut id); + vis.visit_span(&mut span); let stmts: SmallVec<_> = walk_flat_map_stmt_kind(vis, kind) .into_iter() .map(|kind| Stmt { id, kind, span }) @@ -1641,7 +1717,6 @@ pub fn walk_flat_map_stmt( the visitor should implement custom statement visiting" ); } - vis.visit_span(&mut span); stmts } From 2fbda8abd934f71ab5c003374c2542c4ca0d28e1 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 2 Jul 2024 13:52:47 +0000 Subject: [PATCH 3/7] Remove parents from diagnostic hashing. --- compiler/rustc_error_messages/src/lib.rs | 11 ++++++++++ compiler/rustc_errors/src/diagnostic.rs | 28 +++++++++++++++++++----- compiler/rustc_errors/src/lib.rs | 27 ++++++++++++++++++----- 3 files changed, 55 insertions(+), 11 deletions(-) diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs index 2ede7d805fa40..c6d9f98ebc96d 100644 --- a/compiler/rustc_error_messages/src/lib.rs +++ b/compiler/rustc_error_messages/src/lib.rs @@ -511,6 +511,17 @@ impl MultiSpan { pub fn clone_ignoring_labels(&self) -> Self { Self { primary_spans: self.primary_spans.clone(), ..MultiSpan::new() } } + + pub fn clone_ignoring_parents(&self) -> Self { + Self { + primary_spans: self.primary_spans.iter().map(|s| s.with_parent(None)).collect(), + span_labels: self + .span_labels + .iter() + .map(|(s, l)| (s.with_parent(None), l.clone())) + .collect(), + } + } } impl From for MultiSpan { diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs index 4352de3ad25fe..d3d2e155fb7db 100644 --- a/compiler/rustc_errors/src/diagnostic.rs +++ b/compiler/rustc_errors/src/diagnostic.rs @@ -403,19 +403,28 @@ impl DiagInner { &Level, &[(DiagMessage, Style)], &Option, - &MultiSpan, - &[Subdiag], - &Suggestions, + MultiSpan, + Vec, + Suggestions, Vec<(&DiagArgName, &DiagArgValue)>, &Option, ) { + let suggestions = match &self.suggestions { + Suggestions::Enabled(sugg) => Suggestions::Enabled( + sugg.iter().map(CodeSuggestion::clone_ignoring_parents).collect(), + ), + Suggestions::Sealed(sugg) => Suggestions::Sealed( + sugg.iter().map(CodeSuggestion::clone_ignoring_parents).collect(), + ), + Suggestions::Disabled => Suggestions::Disabled, + }; ( &self.level, &self.messages, &self.code, - &self.span, - &self.children, - &self.suggestions, + self.span.clone_ignoring_parents(), + self.children.iter().map(Subdiag::clone_ignoring_parents).collect(), + suggestions, self.args.iter().collect(), // omit self.sort_span &self.is_lint, @@ -448,6 +457,13 @@ pub struct Subdiag { pub span: MultiSpan, } +impl Subdiag { + fn clone_ignoring_parents(&self) -> Subdiag { + let Subdiag { level, messages, span } = self; + Subdiag { level: *level, messages: messages.clone(), span: span.clone_ignoring_parents() } + } +} + /// Used for emitting structured error messages and other diagnostic information. /// Wraps a `DiagInner`, adding some useful things. /// - The `dcx` field, allowing it to (a) emit itself, and (b) do a drop check diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index 94365a89adc7e..cac89f3a0c8c1 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -233,9 +233,29 @@ impl SubstitutionPart { sm.span_to_snippet(self.span) .map_or(!self.span.is_empty(), |snippet| !snippet.trim().is_empty()) } + + fn clone_ignoring_parents(&self) -> SubstitutionPart { + let SubstitutionPart { span, snippet } = self; + SubstitutionPart { span: span.with_parent(None), snippet: snippet.clone() } + } } impl CodeSuggestion { + pub fn clone_ignoring_parents(&self) -> CodeSuggestion { + let CodeSuggestion { substitutions, msg, style, applicability } = self; + CodeSuggestion { + substitutions: substitutions + .iter() + .map(|Substitution { parts }| Substitution { + parts: parts.iter().map(SubstitutionPart::clone_ignoring_parents).collect(), + }) + .collect(), + msg: msg.clone(), + style: *style, + applicability: *applicability, + } + } + /// Returns the assembled code suggestions, whether they should be shown with an underline /// and whether the substitution only differs in capitalization. pub(crate) fn splice_lines( @@ -1533,6 +1553,7 @@ impl DiagCtxtInner { let mut hasher = StableHasher::new(); diagnostic.hash(&mut hasher); let diagnostic_hash = hasher.finish(); + debug!(?diagnostic, ?diagnostic_hash); !self.emitted_diagnostics.insert(diagnostic_hash) }; @@ -1542,18 +1563,14 @@ impl DiagCtxtInner { // Only emit the diagnostic if we've been asked to deduplicate or // haven't already emitted an equivalent diagnostic. if !(self.flags.deduplicate_diagnostics && already_emitted) { - debug!(?diagnostic); - debug!(?self.emitted_diagnostics); - let already_emitted_sub = |sub: &mut Subdiag| { - debug!(?sub); if sub.level != OnceNote && sub.level != OnceHelp { return false; } let mut hasher = StableHasher::new(); sub.hash(&mut hasher); let diagnostic_hash = hasher.finish(); - debug!(?diagnostic_hash); + debug!(?sub, ?diagnostic_hash); !self.emitted_diagnostics.insert(diagnostic_hash) }; diagnostic.children.extract_if(already_emitted_sub).for_each(|_| {}); From c6c5243395cfe614d36a1c64544f35fe1f38ac3d Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 2 Jul 2024 11:28:17 +0000 Subject: [PATCH 4/7] Make def_collector a MutVisitor. --- compiler/rustc_ast/src/mut_visit.rs | 23 +- compiler/rustc_expand/src/base.rs | 2 +- compiler/rustc_expand/src/expand.rs | 4 +- .../rustc_resolve/src/build_reduced_graph.rs | 2 +- compiler/rustc_resolve/src/def_collector.rs | 322 +++++++++++------- compiler/rustc_resolve/src/macros.rs | 2 +- 6 files changed, 217 insertions(+), 138 deletions(-) diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs index cf35e4fd04047..3b92e39d86667 100644 --- a/compiler/rustc_ast/src/mut_visit.rs +++ b/compiler/rustc_ast/src/mut_visit.rs @@ -367,7 +367,7 @@ where } // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. -fn visit_attrs(vis: &mut T, attrs: &mut AttrVec) { +pub fn visit_attrs(vis: &mut T, attrs: &mut AttrVec) { for attr in attrs.iter_mut() { vis.visit_attribute(attr); } @@ -626,7 +626,7 @@ fn walk_local(vis: &mut T, local: &mut P) { vis.visit_span(span); } -fn walk_attribute(vis: &mut T, attr: &mut Attribute) { +pub fn walk_attribute(vis: &mut T, attr: &mut Attribute) { let Attribute { kind, id: _, style: _, span } = attr; match kind { AttrKind::Normal(normal) => { @@ -825,7 +825,7 @@ fn visit_nonterminal(vis: &mut T, nt: &mut token::Nonterminal) { } // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. -fn visit_defaultness(vis: &mut T, defaultness: &mut Defaultness) { +pub fn visit_defaultness(vis: &mut T, defaultness: &mut Defaultness) { match defaultness { Defaultness::Default(span) => vis.visit_span(span), Defaultness::Final => {} @@ -879,7 +879,7 @@ fn walk_coroutine_kind(vis: &mut T, coroutine_kind: &mut Coroutin } } -fn walk_fn(vis: &mut T, kind: FnKind<'_>) { +pub fn walk_fn(vis: &mut T, kind: FnKind<'_>) { match kind { FnKind::Fn(FnSig { header, decl, span }, generics, body) => { // Identifier and visibility are visited as a part of the item. @@ -891,8 +891,9 @@ fn walk_fn(vis: &mut T, kind: FnKind<'_>) { } vis.visit_span(span); } - FnKind::Closure(binder, decl, body) => { + FnKind::Closure(binder, coroutine_kind, decl, body) => { vis.visit_closure_binder(binder); + coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind)); vis.visit_fn_decl(decl); vis.visit_expr(body); } @@ -905,7 +906,7 @@ fn walk_fn_decl(vis: &mut T, decl: &mut P) { walk_fn_ret_ty(vis, output); } -fn walk_fn_ret_ty(vis: &mut T, fn_ret_ty: &mut FnRetTy) { +pub fn walk_fn_ret_ty(vis: &mut T, fn_ret_ty: &mut FnRetTy) { match fn_ret_ty { FnRetTy::Default(span) => vis.visit_span(span), FnRetTy::Ty(ty) => vis.visit_ty(ty), @@ -1596,9 +1597,8 @@ pub fn walk_expr(vis: &mut T, Expr { kind, id, span, attrs, token fn_arg_span, }) => { visit_constness(vis, constness); - coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind)); vis.visit_capture_by(capture_clause); - vis.visit_fn(FnKind::Closure(binder, fn_decl, body), *span, *id); + vis.visit_fn(FnKind::Closure(binder, coroutine_kind, fn_decl, body), *span, *id); vis.visit_span(fn_decl_span); vis.visit_span(fn_arg_span); } @@ -1864,5 +1864,10 @@ pub enum FnKind<'a> { Fn(&'a mut FnSig, &'a mut Generics, &'a mut Option>), /// E.g., `|x, y| body`. - Closure(&'a mut ClosureBinder, &'a mut P, &'a mut P), + Closure( + &'a mut ClosureBinder, + &'a mut Option, + &'a mut P, + &'a mut P, + ), } diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs index 7e4bc508e5c77..9bf3395717bb4 100644 --- a/compiler/rustc_expand/src/base.rs +++ b/compiler/rustc_expand/src/base.rs @@ -999,7 +999,7 @@ pub trait ResolverExpand { fn visit_ast_fragment_with_placeholders( &mut self, expn_id: LocalExpnId, - fragment: &AstFragment, + fragment: &mut AstFragment, ); fn register_builtin_macro(&mut self, name: Symbol, ext: SyntaxExtensionKind); diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs index 5ffafcaa54262..51e4fd1090137 100644 --- a/compiler/rustc_expand/src/expand.rs +++ b/compiler/rustc_expand/src/expand.rs @@ -130,7 +130,7 @@ macro_rules! ast_fragments { T::fragment_to_output(self) } - pub(crate) fn mut_visit_with(&mut self, vis: &mut F) { + pub fn mut_visit_with(&mut self, vis: &mut F) { match self { AstFragment::OptExpr(opt_expr) => { visit_clobber(opt_expr, |opt_expr| { @@ -602,7 +602,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { if self.monotonic { self.cx .resolver - .visit_ast_fragment_with_placeholders(self.cx.current_expansion.id, &fragment); + .visit_ast_fragment_with_placeholders(self.cx.current_expansion.id, &mut fragment); if self.cx.sess.opts.incremental.is_some() { for (invoc, _) in invocations.iter_mut() { diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs index 031ffaed808bd..552b0c72f1411 100644 --- a/compiler/rustc_resolve/src/build_reduced_graph.rs +++ b/compiler/rustc_resolve/src/build_reduced_graph.rs @@ -186,7 +186,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> { pub(crate) fn build_reduced_graph( &mut self, - fragment: &AstFragment, + fragment: &mut AstFragment, parent_scope: ParentScope<'ra>, ) -> MacroRulesScopeRef<'ra> { collect_definitions(self, fragment, parent_scope.expansion); diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs index 0047f2c4b51e9..2c396ec03b574 100644 --- a/compiler/rustc_resolve/src/def_collector.rs +++ b/compiler/rustc_resolve/src/def_collector.rs @@ -1,8 +1,11 @@ use std::mem; -use rustc_ast::visit::FnKind; +use rustc_ast::mut_visit::FnKind; +use rustc_ast::ptr::P; +use rustc_ast::visit::AssocCtxt; use rustc_ast::*; use rustc_ast_pretty::pprust; +use rustc_data_structures::flat_map_in_place::FlatMapInPlace; use rustc_expand::expand::AstFragment; use rustc_hir as hir; use rustc_hir::def::{CtorKind, CtorOf, DefKind}; @@ -10,13 +13,14 @@ use rustc_hir::def_id::LocalDefId; use rustc_span::Span; use rustc_span::hygiene::LocalExpnId; use rustc_span::symbol::{Symbol, kw, sym}; +use smallvec::{SmallVec, smallvec}; use tracing::debug; use crate::{ImplTraitContext, InvocationParent, PendingAnonConstInfo, Resolver}; pub(crate) fn collect_definitions( resolver: &mut Resolver<'_, '_>, - fragment: &AstFragment, + fragment: &mut AstFragment, expansion: LocalExpnId, ) { let InvocationParent { parent_def, pending_anon_const_info, impl_trait_context, in_attr } = @@ -29,7 +33,7 @@ pub(crate) fn collect_definitions( impl_trait_context, in_attr, }; - fragment.visit_with(&mut visitor); + fragment.mut_visit_with(&mut visitor); } /// Creates `DefId`s for nodes in the AST. @@ -73,23 +77,26 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> { .def_id() } - fn with_parent(&mut self, parent_def: LocalDefId, f: F) { + fn with_parent R>(&mut self, parent_def: LocalDefId, f: F) -> R { let orig_parent_def = mem::replace(&mut self.parent_def, parent_def); - f(self); + let res = f(self); self.parent_def = orig_parent_def; + res } - fn with_impl_trait( + fn with_impl_trait R>( &mut self, impl_trait_context: ImplTraitContext, f: F, - ) { + ) -> R { let orig_itc = mem::replace(&mut self.impl_trait_context, impl_trait_context); - f(self); + let res = f(self); self.impl_trait_context = orig_itc; + res } - fn collect_field(&mut self, field: &'a FieldDef, index: Option) { + #[tracing::instrument(level = "trace", skip(self))] + fn collect_field(&mut self, field: FieldDef, index: Option) -> SmallVec<[FieldDef; 1]> { let index = |this: &Self| { index.unwrap_or_else(|| { let node_id = NodeId::placeholder_from_expn_id(this.expansion); @@ -101,13 +108,15 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> { let old_index = self.resolver.placeholder_field_indices.insert(field.id, index(self)); assert!(old_index.is_none(), "placeholder field index is reset for a node ID"); self.visit_macro_invoc(field.id); + return smallvec![field]; } else { let name = field.ident.map_or_else(|| sym::integer(index(self)), |ident| ident.name); let def = self.create_def(field.id, name, DefKind::Field, field.span); - self.with_parent(def, |this| visit::walk_field_def(this, field)); + self.with_parent(def, |this| mut_visit::walk_flat_map_field_def(this, field)) } } + #[tracing::instrument(level = "trace", skip(self))] fn visit_macro_invoc(&mut self, id: NodeId) { let id = id.placeholder_to_expn_id(); let pending_anon_const_info = self.pending_anon_const_info.take(); @@ -129,17 +138,14 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> { fn is_const_arg_trivial_macro_expansion( &self, anon_const: &'a AnonConst, - ) -> Option<(PendingAnonConstInfo, NodeId)> { + ) -> Option { let (block_was_stripped, expr) = anon_const.value.maybe_unwrap_block(); match expr { - Expr { kind: ExprKind::MacCall(..), id, .. } => Some(( - PendingAnonConstInfo { - id: anon_const.id, - span: anon_const.value.span, - block_was_stripped, - }, - *id, - )), + Expr { kind: ExprKind::MacCall(..), .. } => Some(PendingAnonConstInfo { + id: anon_const.id, + span: anon_const.value.span, + block_was_stripped, + }), _ => None, } } @@ -176,8 +182,9 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> { } } -impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { - fn visit_item(&mut self, i: &'a Item) { +impl<'a, 'ra, 'tcx> mut_visit::MutVisitor for DefCollector<'a, 'ra, 'tcx> { + #[tracing::instrument(level = "trace", skip(self))] + fn flat_map_item(&mut self, mut i: P) -> SmallVec<[P; 1]> { // Pick the def data. This need not be unique, but the more // information we encapsulate into, the better let mut opt_macro_data = None; @@ -200,15 +207,16 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { ItemKind::Const(..) => DefKind::Const, ItemKind::Fn(..) | ItemKind::Delegation(..) => DefKind::Fn, ItemKind::MacroDef(..) => { - let macro_data = self.resolver.compile_macro(i, self.resolver.tcx.sess.edition()); + let macro_data = self.resolver.compile_macro(&i, self.resolver.tcx.sess.edition()); let macro_kind = macro_data.ext.macro_kind(); opt_macro_data = Some(macro_data); DefKind::Macro(macro_kind) } ItemKind::GlobalAsm(..) => DefKind::GlobalAsm, - ItemKind::Use(..) => return visit::walk_item(self, i), + ItemKind::Use(..) => DefKind::Use, ItemKind::MacCall(..) | ItemKind::DelegationMac(..) => { - return self.visit_macro_invoc(i.id); + self.visit_macro_invoc(i.id); + return smallvec![i]; } }; let def_id = self.create_def(i.id, i.ident.name, def_kind, i.span); @@ -219,7 +227,8 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { self.with_parent(def_id, |this| { this.with_impl_trait(ImplTraitContext::Existential, |this| { - match i.kind { + let item = &mut *i; + match &mut item.kind { ItemKind::Struct(ref struct_def, _) | ItemKind::Union(ref struct_def, _) => { // If this is a unit or tuple-like struct, register the constructor. if let Some((ctor_kind, ctor_node_id)) = CtorKind::from_ast(struct_def) { @@ -227,71 +236,107 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { ctor_node_id, kw::Empty, DefKind::Ctor(CtorOf::Struct, ctor_kind), - i.span, + item.span, ); } } _ => {} } - visit::walk_item(this, i); + mut_visit::walk_flat_map_item(this, i) }) - }); + }) } - fn visit_fn(&mut self, fn_kind: FnKind<'a>, span: Span, _: NodeId) { - match fn_kind { - FnKind::Fn(_ctxt, _ident, FnSig { header, decl, span: _ }, _vis, generics, body) - if let Some(coroutine_kind) = header.coroutine_kind => - { + fn visit_fn(&mut self, mut fn_kind: FnKind<'_>, fn_span: Span, _: NodeId) { + match &mut fn_kind { + FnKind::Fn(FnSig { header, decl, span }, ref mut generics, ref mut body) => { + // Identifier and visibility are visited as a part of the item. self.visit_fn_header(header); self.visit_generics(generics); // For async functions, we need to create their inner defs inside of a // closure to match their desugared representation. Besides that, // we must mirror everything that `visit::walk_fn` below does. - let FnDecl { inputs, output } = &**decl; - for param in inputs { - self.visit_param(param); - } - - let (return_id, return_span) = coroutine_kind.return_id(); - let return_def = - self.create_def(return_id, kw::Empty, DefKind::OpaqueTy, return_span); - self.with_parent(return_def, |this| this.visit_fn_ret_ty(output)); + let FnDecl { inputs, output } = &mut **decl; + inputs.flat_map_in_place(|param| self.flat_map_param(param)); + + let return_def = if let Some(coroutine_kind) = header.coroutine_kind { + let (return_id, return_span) = coroutine_kind.return_id(); + self.create_def(return_id, kw::Empty, DefKind::OpaqueTy, return_span) + } else { + self.parent_def + }; + self.with_parent(return_def, |this| mut_visit::walk_fn_ret_ty(this, output)); // If this async fn has no body (i.e. it's an async fn signature in a trait) // then the closure_def will never be used, and we should avoid generating a // def-id for it. if let Some(body) = body { - let closure_def = self.create_def( - coroutine_kind.closure_id(), - kw::Empty, - DefKind::Closure, - span, - ); + let closure_def = if let Some(coroutine_kind) = header.coroutine_kind { + self.create_def( + coroutine_kind.closure_id(), + kw::Empty, + DefKind::Closure, + fn_span, + ) + } else { + self.parent_def + }; self.with_parent(closure_def, |this| this.visit_block(body)); } + self.visit_span(span); } - FnKind::Closure(binder, Some(coroutine_kind), decl, body) => { + FnKind::Closure(binder, coroutine_kind, decl, body) => { self.visit_closure_binder(binder); - visit::walk_fn_decl(self, decl); + self.visit_fn_decl(decl); // Async closures desugar to closures inside of closures, so // we must create two defs. - let coroutine_def = - self.create_def(coroutine_kind.closure_id(), kw::Empty, DefKind::Closure, span); - self.with_parent(coroutine_def, |this| this.visit_expr(body)); + let closure_def = if let Some(coroutine_kind) = coroutine_kind { + self.create_def( + coroutine_kind.closure_id(), + kw::Empty, + DefKind::Closure, + fn_span, + ) + } else { + self.parent_def + }; + self.with_parent(closure_def, |this| this.visit_expr(body)); } - _ => visit::walk_fn(self, fn_kind), } } - fn visit_use_tree(&mut self, use_tree: &'a UseTree, id: NodeId, _nested: bool) { - self.create_def(id, kw::Empty, DefKind::Use, use_tree.span); - visit::walk_use_tree(self, use_tree, id); + fn visit_use_tree(&mut self, use_tree: &mut UseTree) { + let UseTree { prefix, kind, span } = use_tree; + self.visit_path(prefix); + match kind { + UseTreeKind::Simple(None) => {} + UseTreeKind::Simple(Some(rename)) => self.visit_ident(rename), + UseTreeKind::Nested { items, span } => { + for (tree, id) in items { + self.visit_id(id); + // HIR lowers use trees as a flat stream of `ItemKind::Use`. + // This means all the def-ids must be parented to the module, + // and not to `self.parent_def` which is the topmost `use` item. + self.resolver.create_def( + self.resolver.tcx.local_parent(self.parent_def), + *id, + kw::Empty, + DefKind::Use, + self.expansion.to_expn_id(), + span.with_parent(None), + ); + self.visit_use_tree(tree); + } + self.visit_span(span); + } + UseTreeKind::Glob => {} + } + self.visit_span(span); } - fn visit_foreign_item(&mut self, fi: &'a ForeignItem) { + fn flat_map_foreign_item(&mut self, fi: P) -> SmallVec<[P; 1]> { let def_kind = match fi.kind { ForeignItemKind::Static(box StaticItem { ty: _, mutability, expr: _, safety }) => { let safety = match safety { @@ -303,17 +348,21 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { } ForeignItemKind::Fn(_) => DefKind::Fn, ForeignItemKind::TyAlias(_) => DefKind::ForeignTy, - ForeignItemKind::MacCall(_) => return self.visit_macro_invoc(fi.id), + ForeignItemKind::MacCall(_) => { + self.visit_macro_invoc(fi.id); + return smallvec![fi]; + } }; let def = self.create_def(fi.id, fi.ident.name, def_kind, fi.span); - self.with_parent(def, |this| visit::walk_item(this, fi)); + self.with_parent(def, |this| mut_visit::walk_flat_map_item(this, fi)) } - fn visit_variant(&mut self, v: &'a Variant) { + fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> { if v.is_placeholder { - return self.visit_macro_invoc(v.id); + self.visit_macro_invoc(v.id); + return smallvec![v]; } let def = self.create_def(v.id, v.ident.name, DefKind::Variant, v.span); self.with_parent(def, |this| { @@ -325,23 +374,37 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { v.span, ); } - visit::walk_variant(this, v) - }); + mut_visit::walk_flat_map_variant(this, v) + }) } - fn visit_variant_data(&mut self, data: &'a VariantData) { + fn visit_variant_data(&mut self, data: &mut VariantData) { // The assumption here is that non-`cfg` macro expansion cannot change field indices. // It currently holds because only inert attributes are accepted on fields, // and every such attribute expands into a single field after it's resolved. - for (index, field) in data.fields().iter().enumerate() { - self.collect_field(field, Some(index)); - } + let fields = match data { + VariantData::Struct { fields, recovered: _ } => fields, + VariantData::Tuple(fields, id) => { + self.visit_id(id); + fields + } + VariantData::Unit(id) => { + self.visit_id(id); + return; + } + }; + let mut index = 0; + fields.flat_map_in_place(|field| { + let field = self.collect_field(field, Some(index)); + index = index + 1; + field + }) } - fn visit_generic_param(&mut self, param: &'a GenericParam) { + fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> { if param.is_placeholder { self.visit_macro_invoc(param.id); - return; + return smallvec![param]; } let def_kind = match param.kind { GenericParamKind::Lifetime { .. } => DefKind::LifetimeParam, @@ -357,32 +420,38 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { // // In that case, the impl-trait is lowered as an additional generic parameter. self.with_impl_trait(ImplTraitContext::Universal, |this| { - visit::walk_generic_param(this, param) - }); + mut_visit::walk_flat_map_generic_param(this, param) + }) } - fn visit_assoc_item(&mut self, i: &'a AssocItem, ctxt: visit::AssocCtxt) { + fn flat_map_assoc_item( + &mut self, + i: P, + _: AssocCtxt, + ) -> SmallVec<[P; 1]> { let def_kind = match &i.kind { AssocItemKind::Fn(..) | AssocItemKind::Delegation(..) => DefKind::AssocFn, AssocItemKind::Const(..) => DefKind::AssocConst, AssocItemKind::Type(..) => DefKind::AssocTy, AssocItemKind::MacCall(..) | AssocItemKind::DelegationMac(..) => { - return self.visit_macro_invoc(i.id); + self.visit_macro_invoc(i.id); + return smallvec![i]; } }; - let def = self.create_def(i.id, i.ident.name, def_kind, i.span); - self.with_parent(def, |this| visit::walk_assoc_item(this, i, ctxt)); + let span = i.span; + let def = self.create_def(i.id, i.ident.name, def_kind, span); + self.with_parent(def, |this| mut_visit::walk_flat_map_item(this, i)) } - fn visit_pat(&mut self, pat: &'a Pat) { - match pat.kind { - PatKind::MacCall(..) => self.visit_macro_invoc(pat.id), - _ => visit::walk_pat(self, pat), + fn visit_pat(&mut self, pat: &mut P) { + if let PatKind::MacCall(..) = pat.kind { + return self.visit_macro_invoc(pat.id); } + mut_visit::walk_pat(self, pat) } - fn visit_anon_const(&mut self, constant: &'a AnonConst) { + fn visit_anon_const(&mut self, constant: &mut AnonConst) { // HACK(min_generic_const_args): don't create defs for anon consts if we think they will // later be turned into ConstArgKind::Path's. because this is before resolve is done, we // may accidentally identify a construction of a unit struct as a param and not create a @@ -390,20 +459,18 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { // items will be messed up, but that's ok because there can't be any if we're just looking // for bare idents. - if let Some((pending_anon, macro_invoc)) = - self.is_const_arg_trivial_macro_expansion(constant) - { + if let Some(pending_anon) = self.is_const_arg_trivial_macro_expansion(constant) { self.pending_anon_const_info = Some(pending_anon); - return self.visit_macro_invoc(macro_invoc); + return mut_visit::walk_anon_const(self, constant); } else if constant.value.is_potential_trivial_const_arg(true) { - return visit::walk_anon_const(self, constant); + return mut_visit::walk_anon_const(self, constant); } let def = self.create_def(constant.id, kw::Empty, DefKind::AnonConst, constant.value.span); - self.with_parent(def, |this| visit::walk_anon_const(this, constant)); + self.with_parent(def, |this| mut_visit::walk_anon_const(this, constant)); } - fn visit_expr(&mut self, expr: &'a Expr) { + fn visit_expr(&mut self, expr: &mut P) { // If we're visiting the expression of a const argument that was a macro call then // check if it is *still* unknown whether it is a trivial const arg or not. If so // recurse into the macro call and delay creating the anon const def until expansion. @@ -431,33 +498,34 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { }) .unwrap_or(self.parent_def); + let expr = &mut **expr; self.with_parent(parent_def, |this| { let parent_def = match expr.kind { ExprKind::MacCall(..) => return this.visit_macro_invoc(expr.id), ExprKind::Closure(..) | ExprKind::Gen(..) => { this.create_def(expr.id, kw::Empty, DefKind::Closure, expr.span) } - ExprKind::ConstBlock(ref constant) => { - for attr in &expr.attrs { - visit::walk_attribute(this, attr); - } + ExprKind::ConstBlock(ref mut constant) => { + mut_visit::visit_attrs(this, &mut expr.attrs); let def = this.create_def( constant.id, kw::Empty, DefKind::InlineConst, constant.value.span, ); - this.with_parent(def, |this| visit::walk_anon_const(this, constant)); + this.with_parent(def, |this| mut_visit::walk_anon_const(this, constant)); + this.visit_span(&mut expr.span); return; } _ => this.parent_def, }; - this.with_parent(parent_def, |this| visit::walk_expr(this, expr)) + this.with_parent(parent_def, |this| mut_visit::walk_expr(this, expr)) }) } - fn visit_ty(&mut self, ty: &'a Ty) { + #[tracing::instrument(level = "trace", skip(self))] + fn visit_ty(&mut self, ty: &mut P) { match &ty.kind { TyKind::MacCall(..) => self.visit_macro_invoc(ty.id), TyKind::ImplTrait(id, _) => { @@ -474,68 +542,74 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> { match self.impl_trait_context { // Do not nest APIT, as we desugar them as `impl_trait: bounds`, // so the `impl_trait` node is not a parent to `bounds`. - ImplTraitContext::Universal => visit::walk_ty(self, ty), + ImplTraitContext::Universal => mut_visit::walk_ty(self, ty), ImplTraitContext::Existential => { - self.with_parent(id, |this| visit::walk_ty(this, ty)) + self.with_parent(id, |this| mut_visit::walk_ty(this, ty)) } }; } - _ => visit::walk_ty(self, ty), + _ => mut_visit::walk_ty(self, ty), } } - fn visit_stmt(&mut self, stmt: &'a Stmt) { - match stmt.kind { - StmtKind::MacCall(..) => self.visit_macro_invoc(stmt.id), - _ => visit::walk_stmt(self, stmt), + fn flat_map_stmt(&mut self, stmt: Stmt) -> SmallVec<[Stmt; 1]> { + if let StmtKind::MacCall(..) = stmt.kind { + self.visit_macro_invoc(stmt.id); + return smallvec![stmt]; } + mut_visit::walk_flat_map_stmt(self, stmt) } - fn visit_arm(&mut self, arm: &'a Arm) { - if arm.is_placeholder { self.visit_macro_invoc(arm.id) } else { visit::walk_arm(self, arm) } + fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> { + if arm.is_placeholder { + self.visit_macro_invoc(arm.id); + return smallvec![arm]; + } + mut_visit::walk_flat_map_arm(self, arm) } - fn visit_expr_field(&mut self, f: &'a ExprField) { + fn flat_map_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> { if f.is_placeholder { - self.visit_macro_invoc(f.id) - } else { - visit::walk_expr_field(self, f) + self.visit_macro_invoc(f.id); + return smallvec![f]; } + mut_visit::walk_flat_map_expr_field(self, f) } - fn visit_pat_field(&mut self, fp: &'a PatField) { + fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> { if fp.is_placeholder { - self.visit_macro_invoc(fp.id) - } else { - visit::walk_pat_field(self, fp) + self.visit_macro_invoc(fp.id); + return smallvec![fp]; } + mut_visit::walk_flat_map_pat_field(self, fp) } - fn visit_param(&mut self, p: &'a Param) { + fn flat_map_param(&mut self, p: Param) -> SmallVec<[Param; 1]> { if p.is_placeholder { - self.visit_macro_invoc(p.id) - } else { - self.with_impl_trait(ImplTraitContext::Universal, |this| visit::walk_param(this, p)) + self.visit_macro_invoc(p.id); + return smallvec![p]; } + self.with_impl_trait(ImplTraitContext::Universal, |this| { + mut_visit::walk_flat_map_param(this, p) + }) } // This method is called only when we are visiting an individual field // after expanding an attribute on it. - fn visit_field_def(&mut self, field: &'a FieldDef) { - self.collect_field(field, None); + fn flat_map_field_def(&mut self, field: FieldDef) -> SmallVec<[FieldDef; 1]> { + self.collect_field(field, None) } - fn visit_crate(&mut self, krate: &'a Crate) { + fn visit_crate(&mut self, krate: &mut Crate) { if krate.is_placeholder { - self.visit_macro_invoc(krate.id) - } else { - visit::walk_crate(self, krate) + return self.visit_macro_invoc(krate.id); } + mut_visit::walk_crate(self, krate) } - fn visit_attribute(&mut self, attr: &'a Attribute) -> Self::Result { + fn visit_attribute(&mut self, attr: &mut Attribute) { let orig_in_attr = mem::replace(&mut self.in_attr, true); - visit::walk_attribute(self, attr); + mut_visit::walk_attribute(self, attr); self.in_attr = orig_in_attr; } } diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs index a9ebffea8a10b..760d259679d7b 100644 --- a/compiler/rustc_resolve/src/macros.rs +++ b/compiler/rustc_resolve/src/macros.rs @@ -199,7 +199,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> { fn visit_ast_fragment_with_placeholders( &mut self, expansion: LocalExpnId, - fragment: &AstFragment, + fragment: &mut AstFragment, ) { // Integrate the new AST fragment into all the definition and module structures. // We are inside the `expansion` now, but other parent scope components are still the same. From 709d05293c9d4993157359f6e11ea78e28dacf18 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 2 Jul 2024 11:40:02 +0000 Subject: [PATCH 5/7] Mark span parent in def_collector. --- compiler/rustc_ast_lowering/src/expr.rs | 36 +++++++++++++------ compiler/rustc_ast_lowering/src/item.rs | 2 ++ .../rustc_hir_typeck/src/method/suggest.rs | 4 +-- compiler/rustc_resolve/src/def_collector.rs | 6 ++++ .../incremental/hashes/function_interfaces.rs | 2 +- 5 files changed, 35 insertions(+), 15 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs index a1a16d0ca2632..5592069bb1381 100644 --- a/compiler/rustc_ast_lowering/src/expr.rs +++ b/compiler/rustc_ast_lowering/src/expr.rs @@ -10,7 +10,7 @@ use rustc_middle::span_bug; use rustc_session::errors::report_lit_error; use rustc_span::source_map::{Spanned, respan}; use rustc_span::symbol::{Ident, Symbol, kw, sym}; -use rustc_span::{DUMMY_SP, DesugaringKind, Span}; +use rustc_span::{DesugaringKind, Span}; use thin_vec::{ThinVec, thin_vec}; use super::errors::{ @@ -196,7 +196,9 @@ impl<'hir> LoweringContext<'_, 'hir> { MatchKind::Postfix => hir::MatchSource::Postfix, }, ), - ExprKind::Await(expr, await_kw_span) => self.lower_expr_await(*await_kw_span, expr), + ExprKind::Await(expr, await_kw_span) => { + self.lower_expr_await(*await_kw_span, e.span, expr) + } ExprKind::Closure(box Closure { binder, capture_clause, @@ -262,9 +264,11 @@ impl<'hir> LoweringContext<'_, 'hir> { ExprKind::Field(el, ident) => { hir::ExprKind::Field(self.lower_expr(el), self.lower_ident(*ident)) } - ExprKind::Index(el, er, brackets_span) => { - hir::ExprKind::Index(self.lower_expr(el), self.lower_expr(er), *brackets_span) - } + ExprKind::Index(el, er, brackets_span) => hir::ExprKind::Index( + self.lower_expr(el), + self.lower_expr(er), + self.lower_span(*brackets_span), + ), ExprKind::Range(Some(e1), Some(e2), RangeLimits::Closed) => { self.lower_expr_range_closed(e.span, e1, e2) } @@ -405,7 +409,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let last_segment = path.segments.last_mut().unwrap(); assert!(last_segment.args.is_none()); last_segment.args = Some(AstP(GenericArgs::AngleBracketed(AngleBracketedArgs { - span: DUMMY_SP, + span: last_segment.span().shrink_to_hi(), args: generic_args, }))); @@ -753,20 +757,24 @@ impl<'hir> LoweringContext<'_, 'hir> { /// } /// } /// ``` - fn lower_expr_await(&mut self, await_kw_span: Span, expr: &Expr) -> hir::ExprKind<'hir> { + fn lower_expr_await( + &mut self, + await_kw_span: Span, + full_span: Span, + expr: &Expr, + ) -> hir::ExprKind<'hir> { let expr = self.arena.alloc(self.lower_expr_mut(expr)); - self.make_lowered_await(await_kw_span, expr, FutureKind::Future) + self.make_lowered_await(await_kw_span, full_span, expr, FutureKind::Future) } /// Takes an expr that has already been lowered and generates a desugared await loop around it fn make_lowered_await( &mut self, await_kw_span: Span, + full_span: Span, expr: &'hir hir::Expr<'hir>, await_kind: FutureKind, ) -> hir::ExprKind<'hir> { - let full_span = expr.span.to(await_kw_span); - let is_async_gen = match self.coroutine_kind { Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, _)) => false, Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::AsyncGen, _)) => true, @@ -1706,7 +1714,12 @@ impl<'hir> LoweringContext<'_, 'hir> { )); // `unsafe { ... }` let iter = self.arena.alloc(self.expr_unsafe(iter)); - let kind = self.make_lowered_await(head_span, iter, FutureKind::AsyncIterator); + let kind = self.make_lowered_await( + head_span, + head_span, + iter, + FutureKind::AsyncIterator, + ); self.arena.alloc(hir::Expr { hir_id: self.next_id(), kind, span: head_span }) } }; @@ -2012,6 +2025,7 @@ impl<'hir> LoweringContext<'_, 'hir> { } pub(super) fn expr_str(&mut self, sp: Span, value: Symbol) -> hir::Expr<'hir> { + let sp = self.lower_span(sp); let lit = self .arena .alloc(hir::Lit { span: sp, node: ast::LitKind::Str(value, ast::StrStyle::Cooked) }); diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 97fa90d340ea2..b6a08d09c1c3c 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -183,6 +183,7 @@ impl<'hir> LoweringContext<'_, 'hir> { // Start with an empty prefix. let prefix = Path { segments: ThinVec::new(), span: use_tree.span, tokens: None }; + let vis_span = self.lower_span(vis_span); self.lower_use_tree(use_tree, &prefix, id, vis_span, ident, attrs) } ItemKind::Static(box ast::StaticItem { ty: t, safety: _, mutability: m, expr: e }) => { @@ -570,6 +571,7 @@ impl<'hir> LoweringContext<'_, 'hir> { } else { // For non-empty lists we can just drop all the data, the prefix is already // present in HIR as a part of nested imports. + let span = self.lower_span(span); self.arena.alloc(hir::UsePath { res: smallvec![], segments: &[], span }) }; hir::ItemKind::Use(path, hir::UseKind::ListStem) diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index eaf40a193a634..c732a95e1883f 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -776,9 +776,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { expected.only_has_type(self), ); } - if let Some(span) = - tcx.resolutions(()).confused_type_with_std_module.get(&span.with_parent(None)) - { + if let Some(span) = tcx.resolutions(()).confused_type_with_std_module.get(&span) { err.span_suggestion( span.shrink_to_lo(), "you are looking for the module in `std`, not the primitive type", diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs index 2c396ec03b574..044faceed5acd 100644 --- a/compiler/rustc_resolve/src/def_collector.rs +++ b/compiler/rustc_resolve/src/def_collector.rs @@ -183,6 +183,12 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> { } impl<'a, 'ra, 'tcx> mut_visit::MutVisitor for DefCollector<'a, 'ra, 'tcx> { + fn visit_span(&mut self, span: &mut Span) { + if self.resolver.tcx.sess.opts.incremental.is_some() { + *span = span.with_parent(Some(self.parent_def)); + } + } + #[tracing::instrument(level = "trace", skip(self))] fn flat_map_item(&mut self, mut i: P) -> SmallVec<[P; 1]> { // Pick the def data. This need not be unique, but the more diff --git a/tests/incremental/hashes/function_interfaces.rs b/tests/incremental/hashes/function_interfaces.rs index 016a1813babd7..a1adc546390c6 100644 --- a/tests/incremental/hashes/function_interfaces.rs +++ b/tests/incremental/hashes/function_interfaces.rs @@ -320,7 +320,7 @@ pub fn change_return_impl_trait() -> impl Clone { #[cfg(not(any(cfail1,cfail4)))] #[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes")] #[rustc_clean(cfg = "cfail3")] -#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck")] +#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes")] #[rustc_clean(cfg = "cfail6")] pub fn change_return_impl_trait() -> impl Copy { 0u32 From b61a4c2cf1764abc3fba031c33073d5d25f9e2ee Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 2 Jul 2024 12:51:33 +0000 Subject: [PATCH 6/7] Stop lowering spans for HIR. --- compiler/rustc_ast_lowering/src/asm.rs | 11 +- compiler/rustc_ast_lowering/src/block.rs | 12 +- compiler/rustc_ast_lowering/src/delegation.rs | 2 +- compiler/rustc_ast_lowering/src/expr.rs | 153 ++++------- compiler/rustc_ast_lowering/src/item.rs | 100 +++----- compiler/rustc_ast_lowering/src/lib.rs | 241 +++++++----------- compiler/rustc_ast_lowering/src/pat.rs | 14 +- compiler/rustc_ast_lowering/src/path.rs | 20 +- 8 files changed, 213 insertions(+), 340 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs index 6585a7de24591..c98ec1dff24c6 100644 --- a/compiler/rustc_ast_lowering/src/asm.rs +++ b/compiler/rustc_ast_lowering/src/asm.rs @@ -249,7 +249,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { hir::InlineAsmOperand::Label { block: self.lower_block(block, false) } } }; - (op, self.lower_span(*op_sp)) + (op, *op_sp) }) .collect(); @@ -457,7 +457,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { late: true, expr: None, }, - self.lower_span(abi_span), + abi_span, )); clobbered.insert(clobber); } @@ -467,12 +467,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let operands = self.arena.alloc_from_iter(operands); let template = self.arena.alloc_from_iter(asm.template.iter().cloned()); let template_strs = self.arena.alloc_from_iter( - asm.template_strs - .iter() - .map(|(sym, snippet, span)| (*sym, *snippet, self.lower_span(*span))), + asm.template_strs.iter().map(|(sym, snippet, span)| (*sym, *snippet, *span)), ); - let line_spans = - self.arena.alloc_from_iter(asm.line_spans.iter().map(|span| self.lower_span(*span))); + let line_spans = self.arena.alloc_from_iter(asm.line_spans.iter().copied()); let hir_asm = hir::InlineAsm { asm_macro: asm.asm_macro, template, diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs index 9d2b5690c23d9..8d6b3616c24da 100644 --- a/compiler/rustc_ast_lowering/src/block.rs +++ b/compiler/rustc_ast_lowering/src/block.rs @@ -21,7 +21,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let (stmts, expr) = self.lower_stmts(&b.stmts); let rules = self.lower_block_check_mode(&b.rules); let hir_id = self.lower_node_id(b.id); - hir::Block { hir_id, stmts, expr, rules, span: self.lower_span(b.span), targeted_by_break } + hir::Block { hir_id, stmts, expr, rules, span: b.span, targeted_by_break } } fn lower_stmts( @@ -37,7 +37,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let local = self.lower_local(local); self.alias_attrs(hir_id, local.hir_id); let kind = hir::StmtKind::Let(local); - let span = self.lower_span(s.span); + let span = s.span; stmts.push(hir::Stmt { hir_id, kind, span }); } StmtKind::Item(it) => { @@ -48,7 +48,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { _ => self.next_id(), }; let kind = hir::StmtKind::Item(item_id); - let span = self.lower_span(s.span); + let span = s.span; hir::Stmt { hir_id, kind, span } }, )); @@ -61,7 +61,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let hir_id = self.lower_node_id(s.id); self.alias_attrs(hir_id, e.hir_id); let kind = hir::StmtKind::Expr(e); - let span = self.lower_span(s.span); + let span = s.span; stmts.push(hir::Stmt { hir_id, kind, span }); } } @@ -70,7 +70,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let hir_id = self.lower_node_id(s.id); self.alias_attrs(hir_id, e.hir_id); let kind = hir::StmtKind::Semi(e); - let span = self.lower_span(s.span); + let span = s.span; stmts.push(hir::Stmt { hir_id, kind, span }); } StmtKind::Empty => {} @@ -94,7 +94,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } else { None }; - let span = self.lower_span(l.span); + let span = l.span; let source = hir::LocalSource::Normal; self.lower_attrs(hir_id, &l.attrs); self.arena.alloc(hir::LetStmt { hir_id, ty, pat, init, els, span, source }) diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs index 3b85f1737bdd9..c48df0527a9da 100644 --- a/compiler/rustc_ast_lowering/src/delegation.rs +++ b/compiler/rustc_ast_lowering/src/delegation.rs @@ -88,7 +88,7 @@ impl<'hir> LoweringContext<'_, 'hir> { delegation: &Delegation, item_id: NodeId, ) -> DelegationResults<'hir> { - let span = self.lower_span(delegation.path.segments.last().unwrap().ident.span); + let span = delegation.path.segments.last().unwrap().ident.span; let sig_id = self.get_delegation_sig_id(item_id, delegation.id, span); match sig_id { Ok(sig_id) => { diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs index 5592069bb1381..e61e9ab73ef86 100644 --- a/compiler/rustc_ast_lowering/src/expr.rs +++ b/compiler/rustc_ast_lowering/src/expr.rs @@ -42,7 +42,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let mut ex = self.lower_expr_mut(ex); // Include parens in span, but only if it is a super-span. if e.span.contains(ex.span) { - ex.span = self.lower_span(e.span); + ex.span = e.span; } // Merge attributes into the inner expression. if !e.attrs.is_empty() { @@ -115,7 +115,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let receiver = self.lower_expr(receiver); let args = self.arena.alloc_from_iter(args.iter().map(|x| self.lower_expr_mut(x))); - hir::ExprKind::MethodCall(hir_seg, receiver, args, self.lower_span(*span)) + hir::ExprKind::MethodCall(hir_seg, receiver, args, *span) } ExprKind::Binary(binop, lhs, rhs) => { let binop = self.lower_binop(*binop); @@ -137,14 +137,13 @@ impl<'hir> LoweringContext<'_, 'hir> { LitKind::Err(guar) } }; - let lit = self.arena.alloc(respan(self.lower_span(e.span), lit_kind)); + let lit = self.arena.alloc(respan(e.span, lit_kind)); hir::ExprKind::Lit(lit) } ExprKind::IncludedBytes(bytes) => { - let lit = self.arena.alloc(respan( - self.lower_span(e.span), - LitKind::ByteStr(bytes.clone(), StrStyle::Cooked), - )); + let lit = self + .arena + .alloc(respan(e.span, LitKind::ByteStr(bytes.clone(), StrStyle::Cooked))); hir::ExprKind::Lit(lit) } ExprKind::Cast(expr, ty) => { @@ -165,7 +164,7 @@ impl<'hir> LoweringContext<'_, 'hir> { } ExprKind::Let(pat, scrutinee, span, recovered) => { hir::ExprKind::Let(self.arena.alloc(hir::LetExpr { - span: self.lower_span(*span), + span: *span, pat: self.lower_pat(pat), ty: None, init: self.lower_expr(scrutinee), @@ -182,9 +181,9 @@ impl<'hir> LoweringContext<'_, 'hir> { ExprKind::Loop(body, opt_label, span) => self.with_loop_scope(e.id, |this| { hir::ExprKind::Loop( this.lower_block(body, false), - this.lower_label(*opt_label), + *opt_label, hir::LoopSource::Loop, - this.lower_span(*span), + *span, ) }), ExprKind::TryBlock(body) => self.lower_expr_try_block(body), @@ -252,8 +251,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ) } ExprKind::Block(blk, opt_label) => { - let opt_label = self.lower_label(*opt_label); - hir::ExprKind::Block(self.lower_block(blk, opt_label.is_some()), opt_label) + hir::ExprKind::Block(self.lower_block(blk, opt_label.is_some()), *opt_label) } ExprKind::Assign(el, er, span) => self.lower_expr_assign(el, er, *span, e.span), ExprKind::AssignOp(op, el, er) => hir::ExprKind::AssignOp( @@ -261,14 +259,10 @@ impl<'hir> LoweringContext<'_, 'hir> { self.lower_expr(el), self.lower_expr(er), ), - ExprKind::Field(el, ident) => { - hir::ExprKind::Field(self.lower_expr(el), self.lower_ident(*ident)) + ExprKind::Field(el, ident) => hir::ExprKind::Field(self.lower_expr(el), *ident), + ExprKind::Index(el, er, brackets_span) => { + hir::ExprKind::Index(self.lower_expr(el), self.lower_expr(er), *brackets_span) } - ExprKind::Index(el, er, brackets_span) => hir::ExprKind::Index( - self.lower_expr(el), - self.lower_expr(er), - self.lower_span(*brackets_span), - ), ExprKind::Range(Some(e1), Some(e2), RangeLimits::Closed) => { self.lower_expr_range_closed(e.span, e1, e2) } @@ -316,7 +310,7 @@ impl<'hir> LoweringContext<'_, 'hir> { container, ImplTraitContext::Disallowed(ImplTraitPosition::OffsetOf), ), - self.arena.alloc_from_iter(fields.iter().map(|&ident| self.lower_ident(ident))), + self.arena.alloc_from_iter(fields.iter().copied()), ), ExprKind::Struct(se) => { let rest = match &se.rest { @@ -358,7 +352,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ExprKind::MacCall(_) => panic!("{:?} shouldn't exist here", e.span), }; - hir::Expr { hir_id, kind, span: self.lower_span(e.span) } + hir::Expr { hir_id, kind, span: e.span } }) } @@ -371,7 +365,7 @@ impl<'hir> LoweringContext<'_, 'hir> { } fn lower_binop(&mut self, b: BinOp) -> BinOp { - Spanned { node: b.node, span: self.lower_span(b.span) } + Spanned { node: b.node, span: b.span } } fn lower_legacy_const_generics( @@ -507,8 +501,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let if_kind = hir::ExprKind::If(lowered_cond, self.arena.alloc(then), Some(else_expr)); let if_expr = self.expr(span, if_kind); let block = self.block_expr(self.arena.alloc(if_expr)); - let span = self.lower_span(span.with_hi(cond.span.hi())); - let opt_label = self.lower_label(opt_label); + let span = span.with_hi(cond.span.hi()); hir::ExprKind::Loop(block, opt_label, hir::LoopSource::While, span) } @@ -569,7 +562,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let pat = self.lower_pat(&arm.pat); let guard = arm.guard.as_ref().map(|cond| self.lower_expr(cond)); let hir_id = self.next_id(); - let span = self.lower_span(arm.span); + let span = arm.span; self.lower_attrs(hir_id, &arm.attrs); let is_never_pattern = pat.is_never_pattern(); let body = if let Some(body) = &arm.body @@ -641,7 +634,7 @@ impl<'hir> LoweringContext<'_, 'hir> { // Resume argument type: `ResumeTy` let unstable_span = self.mark_span_with_reason( DesugaringKind::Async, - self.lower_span(span), + span, Some(self.allow_gen_future.clone()), ); let resume_ty = @@ -659,12 +652,7 @@ impl<'hir> LoweringContext<'_, 'hir> { Ident::with_dummy_span(sym::_task_context), hir::BindingMode::MUT, ); - let param = hir::Param { - hir_id: self.next_id(), - pat, - ty_span: self.lower_span(span), - span: self.lower_span(span), - }; + let param = hir::Param { hir_id: self.next_id(), pat, ty_span: span, span }; let params = arena_vec![self; param]; (inputs, params, Some(task_context_hid)) @@ -672,8 +660,7 @@ impl<'hir> LoweringContext<'_, 'hir> { hir::CoroutineDesugaring::Gen => (&[], &[], None), }; - let output = - return_ty.unwrap_or_else(|| hir::FnRetTy::DefaultReturn(self.lower_span(span))); + let output = return_ty.unwrap_or_else(|| hir::FnRetTy::DefaultReturn(span)); let fn_decl = self.arena.alloc(hir::FnDecl { inputs, @@ -706,7 +693,7 @@ impl<'hir> LoweringContext<'_, 'hir> { bound_generic_params: &[], fn_decl, body, - fn_decl_span: self.lower_span(fn_decl_span), + fn_decl_span, fn_arg_span: None, kind: hir::ClosureKind::Coroutine(coroutine_kind), constness: hir::Constness::NotConst, @@ -923,8 +910,7 @@ impl<'hir> LoweringContext<'_, 'hir> { }; let lhs = self.expr_ident(span, task_context_ident, task_context_hid); - let assign = - self.expr(span, hir::ExprKind::Assign(lhs, yield_expr, self.lower_span(span))); + let assign = self.expr(span, hir::ExprKind::Assign(lhs, yield_expr, span)); self.stmt_expr(span, assign) }; @@ -933,13 +919,8 @@ impl<'hir> LoweringContext<'_, 'hir> { // loop { .. } let loop_expr = self.arena.alloc(hir::Expr { hir_id: loop_hir_id, - kind: hir::ExprKind::Loop( - loop_block, - None, - hir::LoopSource::Loop, - self.lower_span(span), - ), - span: self.lower_span(span), + kind: hir::ExprKind::Loop(loop_block, None, hir::LoopSource::Loop, span), + span, }); // mut __awaitee => loop { ... } @@ -1017,8 +998,8 @@ impl<'hir> LoweringContext<'_, 'hir> { bound_generic_params, fn_decl, body: body_id, - fn_decl_span: self.lower_span(fn_decl_span), - fn_arg_span: Some(self.lower_span(fn_arg_span)), + fn_decl_span, + fn_arg_span: Some(fn_arg_span), kind: closure_kind, constness: self.lower_constness(constness), }); @@ -1063,7 +1044,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let (binder, params) = match binder { ClosureBinder::NotPresent => (hir::ClosureBinder::Default, &[][..]), ClosureBinder::For { span, generic_params } => { - let span = self.lower_span(*span); + let span = *span; (hir::ClosureBinder::For { span }, &**generic_params) } }; @@ -1132,8 +1113,8 @@ impl<'hir> LoweringContext<'_, 'hir> { bound_generic_params, fn_decl, body, - fn_decl_span: self.lower_span(fn_decl_span), - fn_arg_span: Some(self.lower_span(fn_arg_span)), + fn_decl_span, + fn_arg_span: Some(fn_arg_span), // Lower this as a `CoroutineClosure`. That will ensure that HIR typeck // knows that a `FnDecl` output type like `-> &str` actually means // "coroutine that returns &str", rather than directly returning a `&str`. @@ -1174,11 +1155,7 @@ impl<'hir> LoweringContext<'_, 'hir> { } } if is_ordinary(self, lhs) { - return hir::ExprKind::Assign( - self.lower_expr(lhs), - self.lower_expr(rhs), - self.lower_span(eq_sign_span), - ); + return hir::ExprKind::Assign(self.lower_expr(lhs), self.lower_expr(rhs), eq_sign_span); } let mut assignments = vec![]; @@ -1193,7 +1170,7 @@ impl<'hir> LoweringContext<'_, 'hir> { whole_span, Some(rhs), pat, - hir::LocalSource::AssignDesugar(self.lower_span(eq_sign_span)), + hir::LocalSource::AssignDesugar(eq_sign_span), ); // `a = lhs1; b = lhs2;`. @@ -1335,10 +1312,10 @@ impl<'hir> LoweringContext<'_, 'hir> { let pat = self.destructure_assign(&f.expr, eq_sign_span, assignments); hir::PatField { hir_id: self.next_id(), - ident: self.lower_ident(f.ident), + ident: f.ident, pat, is_shorthand: f.is_shorthand, - span: self.lower_span(f.span), + span: f.span, } })); let qpath = self.lower_qpath( @@ -1382,11 +1359,10 @@ impl<'hir> LoweringContext<'_, 'hir> { _ => {} } // Treat all other cases as normal lvalue. - let ident = Ident::new(sym::lhs, self.lower_span(lhs.span)); + let ident = Ident::new(sym::lhs, lhs.span); let (pat, binding) = self.pat_ident_mut(lhs.span, ident); let ident = self.expr_ident(lhs.span, ident, binding); - let assign = - hir::ExprKind::Assign(self.lower_expr(lhs), ident, self.lower_span(eq_sign_span)); + let assign = hir::ExprKind::Assign(self.lower_expr(lhs), ident, eq_sign_span); let expr = self.expr(lhs.span, assign); assignments.push(self.stmt_expr(lhs.span, expr)); pat @@ -1426,7 +1402,7 @@ impl<'hir> LoweringContext<'_, 'hir> { fn lower_expr_range_closed(&mut self, span: Span, e1: &Expr, e2: &Expr) -> hir::ExprKind<'hir> { let e1 = self.lower_expr_mut(e1); let e2 = self.lower_expr_mut(e2); - let fn_path = hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, self.lower_span(span)); + let fn_path = hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, span); let fn_expr = self.arena.alloc(self.expr(span, hir::ExprKind::Path(fn_path))); hir::ExprKind::Call(fn_expr, arena_vec![self; e1, e2]) } @@ -1460,22 +1436,13 @@ impl<'hir> LoweringContext<'_, 'hir> { e1.iter().map(|e| (sym::start, e)).chain(e2.iter().map(|e| (sym::end, e))).map( |(s, e)| { let expr = self.lower_expr(e); - let ident = Ident::new(s, self.lower_span(e.span)); + let ident = Ident::new(s, e.span); self.expr_field(ident, expr, e.span) }, ), ); - hir::ExprKind::Struct( - self.arena.alloc(hir::QPath::LangItem(lang_item, self.lower_span(span))), - fields, - None, - ) - } - - fn lower_label(&self, opt_label: Option