Remove parents from diagnostic hashing.

Author: cjgillot

compiler/rustc_error_messages/src/lib.rs

@@ -513,6 +513,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<Span> for MultiSpan {

compiler/rustc_errors/src/diagnostic.rs

@@ -431,19 +431,23 @@ impl DiagInner {
         &Level,
         &[(DiagMessage, Style)],
         &Option<ErrCode>,
-        &MultiSpan,
-        &[Subdiag],
-        &Result<Vec<CodeSuggestion>, SuggestionsDisabled>,
+        MultiSpan,
+        Vec<Subdiag>,
+        Result<Vec<CodeSuggestion>, SuggestionsDisabled>,
         Vec<(&DiagArgName, &DiagArgValue)>,
         &Option<IsLint>,
     ) {
+        let suggestions = match &self.suggestions {
+            Ok(sugg) => Ok(sugg.iter().map(CodeSuggestion::clone_ignoring_parents).collect()),
+            Err(SuggestionsDisabled) => Err(SuggestionsDisabled),
+        };
         (
             &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,
@@ -476,6 +480,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

compiler/rustc_errors/src/lib.rs

@@ -197,9 +197,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(
@@ -1575,6 +1595,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)
             };
 
@@ -1584,18 +1605,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(|_| {});