Struct rustc_typeck::structured_errors::wrong_number_of_generic_args::WrongNumberOfGenericArgs

pub struct WrongNumberOfGenericArgs<'a, 'tcx> {
    pub(crate) tcx: TyCtxt<'tcx>,
    pub(crate) kind: &'static str,
    pub(crate) expected_min: usize,
    pub(crate) expected_max: usize,
    pub(crate) provided: usize,
    pub(crate) params_offset: usize,
    pub(crate) args_offset: usize,
    pub(crate) path_segment: &'a PathSegment<'a>,
    pub(crate) gen_params: &'a Generics,
    pub(crate) gen_args: &'a GenericArgs<'a>,
    pub(crate) def_id: DefId,
    pub(crate) span: Span,
}

Handles the wrong number of type / lifetime / ... arguments family of error messages.

Fields

tcx: TyCtxt<'tcx>

kind: &'static str

“type”, “lifetime” etc., put verbatim into the message

expected_min: usize

Minimum number of expected generic arguments (e.g. 2 for HashMap)

expected_max: usize

Maximum number of expected generic arguments (e.g. 3 for HashMap)

provided: usize

Number of generic arguments provided by the user

params_offset: usize

Offset into gen_params - depends on the kind; might be different than args_offset when user passed e.g. more arguments than was actually expected

args_offset: usize

Offset into gen_args - depends on the kind

path_segment: &'a PathSegment<'a>

Offending path segment

gen_params: &'a Generics

Generic parameters as expected by type or trait

gen_args: &'a GenericArgs<'a>

Generic arguments as provided by user

def_id: DefId

DefId of the generic type

span: Span

Offending place where the generic type has been misused

Implementations

impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx>

fn quantifier_and_bound(&self) -> (&'static str, usize)

fn start_diagnostics(&self) -> DiagnosticBuilder<'tcx>

fn notify(&self, err: &mut DiagnosticBuilder<'_>)

Builds the expected 1 type argument / supplied 2 type arguments message.

fn suggest(&self, err: &mut DiagnosticBuilder<'_>)

fn suggest_creating_generics(&self, err: &mut DiagnosticBuilder<'_>)

Suggests to create generics (<...>) when current invocation site contains no generics at all:

type Map = HashMap;

fn suggest_adding_args(&self, err: &mut DiagnosticBuilder<'_>)

Suggests to add missing argument(s) when current invocation site already contains some generics:

type Map = HashMap<String>;

fn suggest_removing_args_or_generics(&self, err: &mut DiagnosticBuilder<'_>)

Suggests to remove redundant argument(s):

type Map = HashMap<String, String, String, String>;

fn show_definition(&self, err: &mut DiagnosticBuilder<'_>)

Builds the type defined here message.

Trait Implementations

impl<'tcx> StructuredDiagnostic<'tcx> for WrongNumberOfGenericArgs<'_, 'tcx>

fn session(&self) -> &Session

fn code(&self) -> DiagnosticId

fn diagnostic_common(&self) -> DiagnosticBuilder<'tcx>

fn diagnostic(&self) -> DiagnosticBuilder<'tcx>

fn diagnostic_regular(
    &self,
    err: DiagnosticBuilder<'tcx>
) -> DiagnosticBuilder<'tcx>

fn diagnostic_extended(
    &self,
    err: DiagnosticBuilder<'tcx>
) -> DiagnosticBuilder<'tcx>