Skip to content

Commit 931c94b

Browse files
fmeasefmease
committed
Move a diagnostic method to hir_ty_lowering::errors
We already have a submodule called `errors` specifically for lowering-related diagnostic code. Use it to keep the main module clean!
1 parent 9906a8c commit 931c94b

File tree

2 files changed

+112
-109
lines changed

2 files changed

+112
-109
lines changed

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

+112
Original file line numberDiff line numberDiff line change
@@ -349,6 +349,118 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
349349
})
350350
}
351351

352+
pub(super) fn report_ambiguous_assoc_type(
353+
&self,
354+
span: Span,
355+
types: &[String],
356+
traits: &[String],
357+
name: Symbol,
358+
) -> ErrorGuaranteed {
359+
let mut err =
360+
struct_span_code_err!(self.tcx().dcx(), span, E0223, "ambiguous associated type");
361+
if self
362+
.tcx()
363+
.resolutions(())
364+
.confused_type_with_std_module
365+
.keys()
366+
.any(|full_span| full_span.contains(span))
367+
{
368+
err.span_suggestion_verbose(
369+
span.shrink_to_lo(),
370+
"you are looking for the module in `std`, not the primitive type",
371+
"std::",
372+
Applicability::MachineApplicable,
373+
);
374+
} else {
375+
let mut types = types.to_vec();
376+
types.sort();
377+
let mut traits = traits.to_vec();
378+
traits.sort();
379+
match (&types[..], &traits[..]) {
380+
([], []) => {
381+
err.span_suggestion_verbose(
382+
span,
383+
format!(
384+
"if there were a type named `Type` that implements a trait named \
385+
`Trait` with associated type `{name}`, you could use the \
386+
fully-qualified path",
387+
),
388+
format!("<Type as Trait>::{name}"),
389+
Applicability::HasPlaceholders,
390+
);
391+
}
392+
([], [trait_str]) => {
393+
err.span_suggestion_verbose(
394+
span,
395+
format!(
396+
"if there were a type named `Example` that implemented `{trait_str}`, \
397+
you could use the fully-qualified path",
398+
),
399+
format!("<Example as {trait_str}>::{name}"),
400+
Applicability::HasPlaceholders,
401+
);
402+
}
403+
([], traits) => {
404+
err.span_suggestions(
405+
span,
406+
format!(
407+
"if there were a type named `Example` that implemented one of the \
408+
traits with associated type `{name}`, you could use the \
409+
fully-qualified path",
410+
),
411+
traits
412+
.iter()
413+
.map(|trait_str| format!("<Example as {trait_str}>::{name}"))
414+
.collect::<Vec<_>>(),
415+
Applicability::HasPlaceholders,
416+
);
417+
}
418+
([type_str], []) => {
419+
err.span_suggestion_verbose(
420+
span,
421+
format!(
422+
"if there were a trait named `Example` with associated type `{name}` \
423+
implemented for `{type_str}`, you could use the fully-qualified path",
424+
),
425+
format!("<{type_str} as Example>::{name}"),
426+
Applicability::HasPlaceholders,
427+
);
428+
}
429+
(types, []) => {
430+
err.span_suggestions(
431+
span,
432+
format!(
433+
"if there were a trait named `Example` with associated type `{name}` \
434+
implemented for one of the types, you could use the fully-qualified \
435+
path",
436+
),
437+
types
438+
.into_iter()
439+
.map(|type_str| format!("<{type_str} as Example>::{name}")),
440+
Applicability::HasPlaceholders,
441+
);
442+
}
443+
(types, traits) => {
444+
let mut suggestions = vec![];
445+
for type_str in types {
446+
for trait_str in traits {
447+
suggestions.push(format!("<{type_str} as {trait_str}>::{name}"));
448+
}
449+
}
450+
err.span_suggestions(
451+
span,
452+
"use fully-qualified syntax",
453+
suggestions,
454+
Applicability::MachineApplicable,
455+
);
456+
}
457+
}
458+
}
459+
let reported = err.emit();
460+
self.set_tainted_by_errors(reported);
461+
reported
462+
}
463+
352464
pub(crate) fn complain_about_ambiguous_inherent_assoc_type(
353465
&self,
354466
name: Ident,

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

-109
Original file line numberDiff line numberDiff line change
@@ -790,115 +790,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
790790
}
791791
}
792792

793-
fn report_ambiguous_assoc_type(
794-
&self,
795-
span: Span,
796-
types: &[String],
797-
traits: &[String],
798-
name: Symbol,
799-
) -> ErrorGuaranteed {
800-
let mut err =
801-
struct_span_code_err!(self.tcx().dcx(), span, E0223, "ambiguous associated type");
802-
if self
803-
.tcx()
804-
.resolutions(())
805-
.confused_type_with_std_module
806-
.keys()
807-
.any(|full_span| full_span.contains(span))
808-
{
809-
err.span_suggestion_verbose(
810-
span.shrink_to_lo(),
811-
"you are looking for the module in `std`, not the primitive type",
812-
"std::",
813-
Applicability::MachineApplicable,
814-
);
815-
} else {
816-
let mut types = types.to_vec();
817-
types.sort();
818-
let mut traits = traits.to_vec();
819-
traits.sort();
820-
match (&types[..], &traits[..]) {
821-
([], []) => {
822-
err.span_suggestion_verbose(
823-
span,
824-
format!(
825-
"if there were a type named `Type` that implements a trait named \
826-
`Trait` with associated type `{name}`, you could use the \
827-
fully-qualified path",
828-
),
829-
format!("<Type as Trait>::{name}"),
830-
Applicability::HasPlaceholders,
831-
);
832-
}
833-
([], [trait_str]) => {
834-
err.span_suggestion_verbose(
835-
span,
836-
format!(
837-
"if there were a type named `Example` that implemented `{trait_str}`, \
838-
you could use the fully-qualified path",
839-
),
840-
format!("<Example as {trait_str}>::{name}"),
841-
Applicability::HasPlaceholders,
842-
);
843-
}
844-
([], traits) => {
845-
err.span_suggestions(
846-
span,
847-
format!(
848-
"if there were a type named `Example` that implemented one of the \
849-
traits with associated type `{name}`, you could use the \
850-
fully-qualified path",
851-
),
852-
traits.iter().map(|trait_str| format!("<Example as {trait_str}>::{name}")),
853-
Applicability::HasPlaceholders,
854-
);
855-
}
856-
([type_str], []) => {
857-
err.span_suggestion_verbose(
858-
span,
859-
format!(
860-
"if there were a trait named `Example` with associated type `{name}` \
861-
implemented for `{type_str}`, you could use the fully-qualified path",
862-
),
863-
format!("<{type_str} as Example>::{name}"),
864-
Applicability::HasPlaceholders,
865-
);
866-
}
867-
(types, []) => {
868-
err.span_suggestions(
869-
span,
870-
format!(
871-
"if there were a trait named `Example` with associated type `{name}` \
872-
implemented for one of the types, you could use the fully-qualified \
873-
path",
874-
),
875-
types
876-
.into_iter()
877-
.map(|type_str| format!("<{type_str} as Example>::{name}")),
878-
Applicability::HasPlaceholders,
879-
);
880-
}
881-
(types, traits) => {
882-
let mut suggestions = vec![];
883-
for type_str in types {
884-
for trait_str in traits {
885-
suggestions.push(format!("<{type_str} as {trait_str}>::{name}"));
886-
}
887-
}
888-
err.span_suggestions(
889-
span,
890-
"use fully-qualified syntax",
891-
suggestions,
892-
Applicability::MachineApplicable,
893-
);
894-
}
895-
}
896-
}
897-
let reported = err.emit();
898-
self.set_tainted_by_errors(reported);
899-
reported
900-
}
901-
902793
/// Search for a trait bound on a type parameter whose trait defines the associated type given by `assoc_name`.
903794
///
904795
/// This fails if there is no such bound in the list of candidates or if there are multiple

0 commit comments

Comments
 (0)