Skip to content

Commit 3afdd34

Browse files
fmeasefmease
committed
Move a diagnostic method to hir_ty_lowering::errors
1 parent 4e1811f commit 3afdd34

2 files changed

Lines changed: 112 additions & 112 deletions

File tree

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

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -349,6 +349,118 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
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‎

Lines changed: 0 additions & 112 deletions
Original file line numberDiff line numberDiff line change
@@ -815,118 +815,6 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
815815
}
816816
}
817817

818-
fn report_ambiguous_assoc_type(
819-
&self,
820-
span: Span,
821-
types: &[String],
822-
traits: &[String],
823-
name: Symbol,
824-
) -> ErrorGuaranteed {
825-
let mut err =
826-
struct_span_code_err!(self.tcx().dcx(), span, E0223, "ambiguous associated type");
827-
if self
828-
.tcx()
829-
.resolutions(())
830-
.confused_type_with_std_module
831-
.keys()
832-
.any(|full_span| full_span.contains(span))
833-
{
834-
err.span_suggestion_verbose(
835-
span.shrink_to_lo(),
836-
"you are looking for the module in `std`, not the primitive type",
837-
"std::",
838-
Applicability::MachineApplicable,
839-
);
840-
} else {
841-
let mut types = types.to_vec();
842-
types.sort();
843-
let mut traits = traits.to_vec();
844-
traits.sort();
845-
match (&types[..], &traits[..]) {
846-
([], []) => {
847-
err.span_suggestion_verbose(
848-
span,
849-
format!(
850-
"if there were a type named `Type` that implements a trait named \
851-
`Trait` with associated type `{name}`, you could use the \
852-
fully-qualified path",
853-
),
854-
format!("<Type as Trait>::{name}"),
855-
Applicability::HasPlaceholders,
856-
);
857-
}
858-
([], [trait_str]) => {
859-
err.span_suggestion_verbose(
860-
span,
861-
format!(
862-
"if there were a type named `Example` that implemented `{trait_str}`, \
863-
you could use the fully-qualified path",
864-
),
865-
format!("<Example as {trait_str}>::{name}"),
866-
Applicability::HasPlaceholders,
867-
);
868-
}
869-
([], traits) => {
870-
err.span_suggestions(
871-
span,
872-
format!(
873-
"if there were a type named `Example` that implemented one of the \
874-
traits with associated type `{name}`, you could use the \
875-
fully-qualified path",
876-
),
877-
traits
878-
.iter()
879-
.map(|trait_str| format!("<Example as {trait_str}>::{name}"))
880-
.collect::<Vec<_>>(),
881-
Applicability::HasPlaceholders,
882-
);
883-
}
884-
([type_str], []) => {
885-
err.span_suggestion_verbose(
886-
span,
887-
format!(
888-
"if there were a trait named `Example` with associated type `{name}` \
889-
implemented for `{type_str}`, you could use the fully-qualified path",
890-
),
891-
format!("<{type_str} as Example>::{name}"),
892-
Applicability::HasPlaceholders,
893-
);
894-
}
895-
(types, []) => {
896-
err.span_suggestions(
897-
span,
898-
format!(
899-
"if there were a trait named `Example` with associated type `{name}` \
900-
implemented for one of the types, you could use the fully-qualified \
901-
path",
902-
),
903-
types
904-
.into_iter()
905-
.map(|type_str| format!("<{type_str} as Example>::{name}")),
906-
Applicability::HasPlaceholders,
907-
);
908-
}
909-
(types, traits) => {
910-
let mut suggestions = vec![];
911-
for type_str in types {
912-
for trait_str in traits {
913-
suggestions.push(format!("<{type_str} as {trait_str}>::{name}"));
914-
}
915-
}
916-
err.span_suggestions(
917-
span,
918-
"use fully-qualified syntax",
919-
suggestions,
920-
Applicability::MachineApplicable,
921-
);
922-
}
923-
}
924-
}
925-
let reported = err.emit();
926-
self.set_tainted_by_errors(reported);
927-
reported
928-
}
929-
930818
/// Search for a bound on a type parameter which includes the associated item given by `assoc_name`.
931819
///
932820
/// `ty_param_def_id` is the `DefId` of the type parameter.

0 commit comments

Comments
 (0)