Enum Diagnostic

pub enum Diagnostic<S>
where
    S: Copy,
{
    UnrecognizedTokens(UnrecognizedTokens<S>),
    MissingOperationDefinitionName(MissingOperationDefinitionName<S>),
    MissingOperationDefinitionSelectionSet(MissingOperationDefinitionSelectionSet<S>),
    MissingSelectionSetClosingBrace(MissingSelectionSetClosingBrace<S>),
    MissingFieldName(MissingFieldName<S>),
    MissingArgumentsClosingParentheses(MissingArgumentsClosingParentheses<S>),
    MissingArgumentColon(MissingArgumentColon<S>),
    MissingArgumentValue(MissingArgumentValue<S>),
    MissingInlineFragmentSelectionSet(MissingInlineFragmentSelectionSet<S>),
    MissingFragmentName(MissingFragmentName<S>),
    MissingFragmentTypeCondition(MissingFragmentTypeCondition<S>),
    MissingFragmentSelectionSet(MissingFragmentSelectionSet<S>),
    MissingTypeConditionNamedType(MissingTypeConditionNamedType<S>),
    MissingListValueClosingBracket(MissingListValueClosingBracket<S>),
    MissingObjectValueClosingBrace(MissingObjectValueClosingBrace<S>),
    MissingObjectFieldColon(MissingObjectFieldColon<S>),
    MissingObjectFieldValue(MissingObjectFieldValue<S>),
    MissingVariableDefinitionsClosingParenthesis(MissingVariableDefinitionsClosingParenthesis<S>),
    MissingVariableDefinitionColon(MissingVariableDefinitionColon<S>),
    MissingVariableDefinitionType(MissingVariableDefinitionType<S>),
    MissingDefaultValue(MissingDefaultValue<S>),
    MissingListTypeClosingBracket(MissingListTypeClosingBracket<S>),
    MissingListTypeWrappedType(MissingListTypeWrappedType<S>),
    MissingDirectiveName(MissingDirectiveName<S>),
    MissingRootOperationTypeDefinitions(MissingRootOperationTypeDefinitions<S>),
    MissingRootOperationTypeDefinitionsClosingBrace(MissingRootOperationTypeDefinitionsClosingBrace<S>),
    MissingRootOperationTypeDefinitionColon(MissingRootOperationTypeDefinitionColon<S>),
    MissingRootOperationTypeDefinitionNamedType(MissingRootOperationTypeDefinitionNamedType<S>),
    MissingScalarTypeDefinitionName(MissingScalarTypeDefinitionName<S>),
    MissingScalarTypeExtensionName(MissingScalarTypeExtensionName<S>),
    MissingScalarTypeExtensionDirectives(MissingScalarTypeExtensionDirectives<S>),
    MissingObjectTypeDefinitionName(MissingObjectTypeDefinitionName<S>),
    MissingFirstImplementsInterface(MissingFirstImplementsInterface<S>),
    MissingSecondImplementsInterface(MissingSecondImplementsInterface<S>),
    MissingFieldsDefinitionClosingBrace(MissingFieldsDefinitionClosingBrace<S>),
    MissingFieldDefinitionColon(MissingFieldDefinitionColon<S>),
    MissingFieldDefinitionType(MissingFieldDefinitionType<S>),
    MissingArgumentsDefinitionClosingParenthesis(MissingArgumentsDefinitionClosingParenthesis<S>),
    MissingInputValueDefinitionColon(MissingInputValueDefinitionColon<S>),
    MissingInputValueDefinitionType(MissingInputValueDefinitionType<S>),
    MissingObjectTypeExtensionName(MissingObjectTypeExtensionName<S>),
    MissingInterfaceTypeDefinitionName(MissingInterfaceTypeDefinitionName<S>),
    MissingInterfaceTypeExtensionName(MissingInterfaceTypeExtensionName<S>),
    MissingUnionTypeDefinitionName(MissingUnionTypeDefinitionName<S>),
    MissingFirstUnionMemberType(MissingFirstUnionMemberType<S>),
    MissingSecondUnionMemberType(MissingSecondUnionMemberType<S>),
    MissingUnionTypeExtensionName(MissingUnionTypeExtensionName<S>),
    MissingEnumTypeDefinitionName(MissingEnumTypeDefinitionName<S>),
    MissingEnumValuesClosingBrace(MissingEnumValuesClosingBrace<S>),
    MissingEnumTypeExtensionName(MissingEnumTypeExtensionName<S>),
    MissingInputObjectTypeDefinitionName(MissingInputObjectTypeDefinitionName<S>),
    MissingInputFieldsDefinitionClosingBrace(MissingInputFieldsDefinitionClosingBrace<S>),
    MissingInputObjectTypeExtensionName(MissingInputObjectTypeExtensionName<S>),
    MissingDirectiveDefinitionAt(MissingDirectiveDefinitionAt<S>),
    MissingDirectiveDefinitionName(MissingDirectiveDefinitionName<S>),
    MissingDirectiveDefinitionLocations(MissingDirectiveDefinitionLocations<S>),
    MissingFirstDirectiveLocation(MissingFirstDirectiveLocation<S>),
    MissingSecondDirectiveLocation(MissingSecondDirectiveLocation<S>),
    UnknownNamedType(UnknownNamedType<S>),
    EmptyType(EmptyType<S>),
    DuplicateField(DuplicateField<S>),
    DuplicateExtendedField(DuplicateExtendedField<S>),
    ReservedFieldName(ReservedFieldName<S>),
    FieldNotOutputType(FieldNotOutputType<S>),
    DuplicateArgumentName(DuplicateArgumentName<S>),
    ReservedInputValueName(ReservedInputValueName<S>),
    InputValueNotInputType(InputValueNotInputType<S>),
    DuplicateImplementsInterface(DuplicateImplementsInterface<S>),
    ImplementsNonInterfaceType(ImplementsNonInterfaceType<S>),
    MissingInheritedInterface(MissingInheritedInterface<S>),
    MissingInterfaceField(MissingInterfaceField<S>),
    MissingInterfaceFieldArgument(MissingInterfaceFieldArgument<S>),
    InvalidInterfaceFieldArgumentType(InvalidInterfaceFieldArgumentType<S>),
    UnexpectedNonNullExtraInterfaceFieldArgument(UnexpectedNonNullExtraInterfaceFieldArgument<S>),
    NonCovariantInterfaceField(NonCovariantInterfaceField<S>),
    SelfReferentialInterface(SelfReferentialInterface<S>),
    MissingUnionMembers(MissingUnionMembers<S>),
    DuplicateUnionMember(DuplicateUnionMember<S>),
    NonObjectUnionMember(NonObjectUnionMember<S>),
    MissingEnumValues(MissingEnumValues<S>),
    DuplicateEnumValue(DuplicateEnumValue<S>),
    SelfReferentialInputType(SelfReferentialInputType<S>),
    ReservedDirectiveName(ReservedDirectiveName<S>),
    SelfReferentialDirective(SelfReferentialDirective<S>),
    DuplicateTypeName(DuplicateTypeName<S>),
    DuplicateDirectiveName(DuplicateDirectiveName<S>),
    DifferentExtensionType(DifferentExtensionType<S>),
    ExpectedNonNullValue(ExpectedNonNullValue<S>),
    ExpectedListValue(ExpectedListValue<S>),
    ExpectedIntValue(ExpectedIntValue<S>),
    ExpectedFloatValue(ExpectedFloatValue<S>),
    ExpectedStringValue(ExpectedStringValue<S>),
    ExpectedBooleanValue(ExpectedBooleanValue<S>),
    ExpectedInputObjectValue(ExpectedInputObjectValue<S>),
    MissingInputField(MissingInputField<S>),
    UnrecognizedInputField(UnrecognizedInputField<S>),
    UnrecognizedEnumValue(UnrecognizedEnumValue<S>),
    ExpectedEnumValue(ExpectedEnumValue<S>),
    DuplicateOperationName(DuplicateOperationName<S>),
    LoneAnonymousOperation(LoneAnonymousOperation<S>),
    UndefinedField(UndefinedField<S>),
    IncompatibleResponseShape(IncompatibleResponseShape<S>),
    DifferentFieldNames(DifferentFieldNames<S>),
    DifferentFieldArguments(DifferentFieldArguments<S>),
    IncompatibleResponseFields(IncompatibleResponseFields<S>),
    MissingSelectionSet(MissingSelectionSet<S>),
    UnexpectedSelectionSet(UnexpectedSelectionSet<S>),
    UndefinedArgument(UndefinedArgument<S>),
    DuplicateArgument(DuplicateArgument<S>),
    MissingRequiredArgument(MissingRequiredArgument<S>),
    DuplicateFragmentName(DuplicateFragmentName<S>),
    FragmentOnNonCompositeType(FragmentOnNonCompositeType<S>),
    UnusedFragmentDefinition(UnusedFragmentDefinition<S>),
    UndefinedFragment(UndefinedFragment<S>),
    CyclicFragmentDefinition(CyclicFragmentDefinition<S>),
    ImpossibleFragmentSpread(ImpossibleFragmentSpread<S>),
    UndefinedDirective(UndefinedDirective<S>),
    DirectiveInInvalidLocation(DirectiveInInvalidLocation<S>),
    DuplicateNonRepeatableDirective(DuplicateNonRepeatableDirective<S>),
    DuplicateVariable(DuplicateVariable<S>),
    VariableMustBeInputType(VariableMustBeInputType<S>),
    UndefinedVariable(UndefinedVariable<S>),
    UndefinedVariableInFragment(UndefinedVariableInFragment<S>),
    UnusedVariable(UnusedVariable<S>),
    IncompatibleVariable(IncompatibleVariable<S>),
    IncompatibleVariableInFragment(IncompatibleVariableInFragment<S>),
    UnsupportedOperation(UnsupportedOperation<S>),
}

Enum that contains all possible diagnostics that Litho can return.

Variants

UnrecognizedTokens(UnrecognizedTokens<S>)

(E0001) Syntax error.

MissingOperationDefinitionName(MissingOperationDefinitionName<S>)

(E0002) Operation definition must have a name.

MissingOperationDefinitionSelectionSet(MissingOperationDefinitionSelectionSet<S>)

(E0003) Operation definition must have a selection set.

MissingSelectionSetClosingBrace(MissingSelectionSetClosingBrace<S>)

(E0004) Selection set is missing closing curly brace.

MissingFieldName(MissingFieldName<S>)

(E0005) Field must have a name.

MissingArgumentsClosingParentheses(MissingArgumentsClosingParentheses<S>)

(E0006) Arguments are missing closing parenthesis.

MissingArgumentColon(MissingArgumentColon<S>)

(E0007) Argument is missing colon.

MissingArgumentValue(MissingArgumentValue<S>)

(E0008) Argument is missing value.

MissingInlineFragmentSelectionSet(MissingInlineFragmentSelectionSet<S>)

(E0009) Inline fragment is missing selection set.

MissingFragmentName(MissingFragmentName<S>)

(E0010) Fragment definition must have a name.

MissingFragmentTypeCondition(MissingFragmentTypeCondition<S>)

(E0011) Fragment definition must have a type condition.

MissingFragmentSelectionSet(MissingFragmentSelectionSet<S>)

(E0012) Fragment definition must have a selection set.

MissingTypeConditionNamedType(MissingTypeConditionNamedType<S>)

(E0013) Type condition must have a named type.

MissingListValueClosingBracket(MissingListValueClosingBracket<S>)

(E0014) List value must have closing bracket.

MissingObjectValueClosingBrace(MissingObjectValueClosingBrace<S>)

(E0015) Object value must have closing brace.

MissingObjectFieldColon(MissingObjectFieldColon<S>)

(E0016) Object field must have a colon.

MissingObjectFieldValue(MissingObjectFieldValue<S>)

(E0017) Object field must have a value.

MissingVariableDefinitionsClosingParenthesis(MissingVariableDefinitionsClosingParenthesis<S>)

(E0018) Variable definitions must have a closing parenthesis.

MissingVariableDefinitionColon(MissingVariableDefinitionColon<S>)

(E0019) Variable definition must have a colon.

MissingVariableDefinitionType(MissingVariableDefinitionType<S>)

(E0020) Variable definition must have a type.

MissingDefaultValue(MissingDefaultValue<S>)

(E0021) Default value must have a value.

MissingListTypeClosingBracket(MissingListTypeClosingBracket<S>)

(E0022) List type must have a closing bracket.

MissingListTypeWrappedType(MissingListTypeWrappedType<S>)

(E0023) List type must wrap another type.

MissingDirectiveName(MissingDirectiveName<S>)

(E0024) Directive must have a name.

MissingRootOperationTypeDefinitions(MissingRootOperationTypeDefinitions<S>)

(E0025) Schema definition must define one or more root operation types.

MissingRootOperationTypeDefinitionsClosingBrace(MissingRootOperationTypeDefinitionsClosingBrace<S>)

(E0026) Root operation type definitions must have a closing brace.

MissingRootOperationTypeDefinitionColon(MissingRootOperationTypeDefinitionColon<S>)

(E0027) Root operation type definition must have a colon.

MissingRootOperationTypeDefinitionNamedType(MissingRootOperationTypeDefinitionNamedType<S>)

(E0028) Root operation type definition must have a named type.

MissingScalarTypeDefinitionName(MissingScalarTypeDefinitionName<S>)

(E0029) Scalar type definition must have a name.

MissingScalarTypeExtensionName(MissingScalarTypeExtensionName<S>)

(E0030) Scalar type extension must have a name.

MissingScalarTypeExtensionDirectives(MissingScalarTypeExtensionDirectives<S>)

(E0031) Scalar type extension must have one or more directives.

MissingObjectTypeDefinitionName(MissingObjectTypeDefinitionName<S>)

(E0032) Object type definition must have a name.

MissingFirstImplementsInterface(MissingFirstImplementsInterface<S>)

(E0033) Implemented interfaces must not be empty.

MissingSecondImplementsInterface(MissingSecondImplementsInterface<S>)

(E0034) Implemented interface name is missing.

MissingFieldsDefinitionClosingBrace(MissingFieldsDefinitionClosingBrace<S>)

(E0035) Fields definition must have a closing brace.

MissingFieldDefinitionColon(MissingFieldDefinitionColon<S>)

(E0036) Field definition must have a colon.

MissingFieldDefinitionType(MissingFieldDefinitionType<S>)

(E0037) Field definition must have a type.

MissingArgumentsDefinitionClosingParenthesis(MissingArgumentsDefinitionClosingParenthesis<S>)

(E0038) Arguments definition must have a closing parenthesis.

MissingInputValueDefinitionColon(MissingInputValueDefinitionColon<S>)

(E0039) Input value definition must have a colon.

MissingInputValueDefinitionType(MissingInputValueDefinitionType<S>)

(E0040) Input value definition must have a type.

MissingObjectTypeExtensionName(MissingObjectTypeExtensionName<S>)

(E0041) Object type extension must have a name.

MissingInterfaceTypeDefinitionName(MissingInterfaceTypeDefinitionName<S>)

(E0042) Interface type definition must have a name.

MissingInterfaceTypeExtensionName(MissingInterfaceTypeExtensionName<S>)

(E0043) Interface type extension must have a name.

MissingUnionTypeDefinitionName(MissingUnionTypeDefinitionName<S>)

(E0044) Union type definition must have a name.

MissingFirstUnionMemberType(MissingFirstUnionMemberType<S>)

(E0045) Union type definition must have one or more member types.

MissingSecondUnionMemberType(MissingSecondUnionMemberType<S>)

(E0046) Union member type must have a name.

MissingUnionTypeExtensionName(MissingUnionTypeExtensionName<S>)

(E0047) Union type extension must have a name.

MissingEnumTypeDefinitionName(MissingEnumTypeDefinitionName<S>)

(E0048) Enum type definition must have a name.

MissingEnumValuesClosingBrace(MissingEnumValuesClosingBrace<S>)

(E0049) Enum values must have a closing brace.

MissingEnumTypeExtensionName(MissingEnumTypeExtensionName<S>)

(E0050) Enum type extension must have a name.

MissingInputObjectTypeDefinitionName(MissingInputObjectTypeDefinitionName<S>)

(E0051) Input object type definition must have a name.

MissingInputFieldsDefinitionClosingBrace(MissingInputFieldsDefinitionClosingBrace<S>)

(E0052) Input fields definition must have a closing brace.

MissingInputObjectTypeExtensionName(MissingInputObjectTypeExtensionName<S>)

(E0053) Input object type extension must have a name.

MissingDirectiveDefinitionAt(MissingDirectiveDefinitionAt<S>)

(E0054) Directive’s name must start with an @.

MissingDirectiveDefinitionName(MissingDirectiveDefinitionName<S>)

(E0055) Directive definition must have a name.

MissingDirectiveDefinitionLocations(MissingDirectiveDefinitionLocations<S>)

(E0056) Directive definition must have one or more locations.

MissingFirstDirectiveLocation(MissingFirstDirectiveLocation<S>)

(E0057) Directive definition must have one or more locations.

MissingSecondDirectiveLocation(MissingSecondDirectiveLocation<S>)

(E0058) Directive location must be defined.

UnknownNamedType(UnknownNamedType<S>)

(E0100) Named type must exist.

EmptyType(EmptyType<S>)

(E0101) Type must define one or more fields.

DuplicateField(DuplicateField<S>)

(E0102) Field name must be unique.

DuplicateExtendedField(DuplicateExtendedField<S>)

(E0103) Field name must be unique across extended types.

ReservedFieldName(ReservedFieldName<S>)

(E0104) Field name must not start with __.

FieldNotOutputType(FieldNotOutputType<S>)

(E0105) Field must be output type.

DuplicateArgumentName(DuplicateArgumentName<S>)

(E0106) Argument name must be unique.

ReservedInputValueName(ReservedInputValueName<S>)

(E0107) Input value name must not start with __.

InputValueNotInputType(InputValueNotInputType<S>)

(E0108) Input value must be input type.

DuplicateImplementsInterface(DuplicateImplementsInterface<S>)

(E0109) Type must not implement same interface twice.

ImplementsNonInterfaceType(ImplementsNonInterfaceType<S>)

(E0110) Implemented type must be interface.

MissingInheritedInterface(MissingInheritedInterface<S>)

(E0111) Type must also implement inherited interfaces.

MissingInterfaceField(MissingInterfaceField<S>)

(E0112) Type must implement field from interface.

MissingInterfaceFieldArgument(MissingInterfaceFieldArgument<S>)

(E0113) Type must implement field with argument from interface.

InvalidInterfaceFieldArgumentType(InvalidInterfaceFieldArgumentType<S>)

(E0114) Type must implement field with argument of same type as interface.

UnexpectedNonNullExtraInterfaceFieldArgument(UnexpectedNonNullExtraInterfaceFieldArgument<S>)

(E0115) Type must not require extra arguments for fields implementing interface.

NonCovariantInterfaceField(NonCovariantInterfaceField<S>)

(E0116) Implemented type and type from interface must be covariant.

SelfReferentialInterface(SelfReferentialInterface<S>)

(E0117) Interface must not implement itself.

MissingUnionMembers(MissingUnionMembers<S>)

(E0118) Union must have at least one member type.

DuplicateUnionMember(DuplicateUnionMember<S>)

(E0119) Union members must be unique.

NonObjectUnionMember(NonObjectUnionMember<S>)

(E0120) Union members must be object types.

MissingEnumValues(MissingEnumValues<S>)

(E0121) Enum must have at least one value.

DuplicateEnumValue(DuplicateEnumValue<S>)

(E0122) Enum values must be unique.

SelfReferentialInputType(SelfReferentialInputType<S>)

(E0123) Input type must not be self-referential.

ReservedDirectiveName(ReservedDirectiveName<S>)

(E0124) Directive name must not start with __.

SelfReferentialDirective(SelfReferentialDirective<S>)

(E0125) Directive must not be self-referential.

DuplicateTypeName(DuplicateTypeName<S>)

(E0126) Type name must be unique.

DuplicateDirectiveName(DuplicateDirectiveName<S>)

(E0126) Directive name must be unique.

DifferentExtensionType(DifferentExtensionType<S>)

(E0127) Type extension must extend type of same kind.

ExpectedNonNullValue(ExpectedNonNullValue<S>)

(E0200) Expected a non-null value.

ExpectedListValue(ExpectedListValue<S>)

(E0201) Expected a list value.

ExpectedIntValue(ExpectedIntValue<S>)

(E0202) Expected an int value.

ExpectedFloatValue(ExpectedFloatValue<S>)

(E0203) Expected a float value.

ExpectedStringValue(ExpectedStringValue<S>)

(E0204) Expected a string value.

ExpectedBooleanValue(ExpectedBooleanValue<S>)

(E0205) Expected a boolean value.

ExpectedInputObjectValue(ExpectedInputObjectValue<S>)

(E0206) Expected an input object value.

MissingInputField(MissingInputField<S>)

(E0207) Expected a value for required input field.

UnrecognizedInputField(UnrecognizedInputField<S>)

(E0208) All fields in input object must exist in schema definition.

UnrecognizedEnumValue(UnrecognizedEnumValue<S>)

(E0209) Enum values must exist in schema definition.

ExpectedEnumValue(ExpectedEnumValue<S>)

(E0210) Expected an enum value.

DuplicateOperationName(DuplicateOperationName<S>)

(E0300) Operation definitions must be unique.

LoneAnonymousOperation(LoneAnonymousOperation<S>)

(E0301) Anonymous operation definitions must be alone.

UndefinedField(UndefinedField<S>)

(E0303) Queried field does not exist.

IncompatibleResponseShape(IncompatibleResponseShape<S>)

(E0304) Selection set contains multiple fields of incompatible types with the same name.

DifferentFieldNames(DifferentFieldNames<S>)

(E0305) Selection set contains different fields with the same name.

DifferentFieldArguments(DifferentFieldArguments<S>)

(E0306) Selection set contains fields with the same name but different arguments.

IncompatibleResponseFields(IncompatibleResponseFields<S>)

(E0307) Selection set contains multiple fields with the same name with incompatible selection sets.

MissingSelectionSet(MissingSelectionSet<S>)

(E0308) Field of composite type must have selection set.

UnexpectedSelectionSet(UnexpectedSelectionSet<S>)

(E0309) Field of scalar-like type must not have a selection set.

UndefinedArgument(UndefinedArgument<S>)

(E0310) Argument must exist in schema.

DuplicateArgument(DuplicateArgument<S>)

(E0311) Argument may be provided only once.

MissingRequiredArgument(MissingRequiredArgument<S>)

(E0312) Missing required argument.

DuplicateFragmentName(DuplicateFragmentName<S>)

(E0313) Fragment definitions must be unique.

FragmentOnNonCompositeType(FragmentOnNonCompositeType<S>)

(E0314) Fragment definitions must target composite type.

UnusedFragmentDefinition(UnusedFragmentDefinition<S>)

(E0315) Fragment definitions must be used.

UndefinedFragment(UndefinedFragment<S>)

(E0316) Fragment definition must be defined.

CyclicFragmentDefinition(CyclicFragmentDefinition<S>)

(E0317) Fragment definition must not be cyclic.

ImpossibleFragmentSpread(ImpossibleFragmentSpread<S>)

(E0318) Fragment spread must be possible.

UndefinedDirective(UndefinedDirective<S>)

(E0319) Directive must be defined.

DirectiveInInvalidLocation(DirectiveInInvalidLocation<S>)

(E0320) Directive must be used in valid location.

DuplicateNonRepeatableDirective(DuplicateNonRepeatableDirective<S>)

(E0321) Non-repeatable directive must be unique per location.

DuplicateVariable(DuplicateVariable<S>)

(E0322) Variables must be unique per operation definition.

VariableMustBeInputType(VariableMustBeInputType<S>)

(E0323) Variables must be input types.

UndefinedVariable(UndefinedVariable<S>)

(E0324) Variables must be defined before they can be used.

UndefinedVariableInFragment(UndefinedVariableInFragment<S>)

(E0325) Operations must define variables for all transitively included fragments.

UnusedVariable(UnusedVariable<S>)

(E0326) Variables must be used.

IncompatibleVariable(IncompatibleVariable<S>)

(E0327) Variable must be compatible with usage.

IncompatibleVariableInFragment(IncompatibleVariableInFragment<S>)

(E0328) Variable must be compatible with usage.

UnsupportedOperation(UnsupportedOperation<S>)

(E0329) Operation must be defined in schema before it can be used.

Implementations

impl<S> Diagnostic<S>

where S: Copy,

pub fn unrecognized_tokens(span: S) -> Diagnostic<S>

(E0001) Syntax error.

pub fn missing_operation_definition_name(span: S) -> Diagnostic<S>

(E0002) Operation definition must have a name.

pub fn missing_operation_definition_selection_set(span: S) -> Diagnostic<S>

(E0003) Operation definition must have a selection set.

pub fn missing_selection_set_closing_brace(first: S, second: S) -> Diagnostic<S>

(E0004) Selection set is missing closing curly brace.

pub fn missing_field_name(span: S) -> Diagnostic<S>

(E0005) Field must have a name.

pub fn missing_arguments_closing_parentheses( first: S, second: S, ) -> Diagnostic<S>

(E0006) Arguments are missing closing parenthesis.

pub fn missing_argument_colon(span: S) -> Diagnostic<S>

(E0007) Argument is missing colon.

pub fn missing_argument_value(span: S) -> Diagnostic<S>

(E0008) Argument is missing value.

pub fn missing_inline_fragment_selection_set(span: S) -> Diagnostic<S>

(E0009) Inline fragment is missing selection set.

pub fn missing_fragment_name(span: S) -> Diagnostic<S>

(E0010) Fragment definition must have a name.

pub fn missing_fragment_type_condition(span: S) -> Diagnostic<S>

(E0011) Fragment definition must have a type condition.

pub fn missing_fragment_selection_set(span: S) -> Diagnostic<S>

(E0012) Fragment definition must have a selection set.

pub fn missing_type_condition_named_type(span: S) -> Diagnostic<S>

(E0013) Type condition must have a named type.

pub fn missing_list_value_closing_bracket(first: S, second: S) -> Diagnostic<S>

(E0014) List value must have closing bracket.

pub fn missing_object_value_closing_brace(first: S, second: S) -> Diagnostic<S>

(E0015) Object value must have closing brace.

pub fn missing_object_field_colon(span: S) -> Diagnostic<S>

(E0016) Object field must have a colon.

pub fn missing_object_field_value(span: S) -> Diagnostic<S>

(E0017) Object field must have a value.

pub fn missing_variable_definitions_closing_parenthesis( first: S, second: S, ) -> Diagnostic<S>

(E0018) Variable definitions must have a closing parenthesis.

pub fn missing_variable_definition_colon(span: S) -> Diagnostic<S>

(E0019) Variable definition must have a colon.

pub fn missing_variable_definition_type(span: S) -> Diagnostic<S>

(E0020) Variable definition must have a type.

pub fn missing_default_value(span: S) -> Diagnostic<S>

(E0021) Default value must have a value.

pub fn missing_list_type_closing_bracket(first: S, second: S) -> Diagnostic<S>

(E0022) List type must have a closing bracket.

pub fn missing_list_type_wrapped_type(span: S) -> Diagnostic<S>

(E0023) List type must wrap another type.

pub fn missing_directive_name(span: S) -> Diagnostic<S>

(E0024) Directive must have a name.

pub fn missing_root_operation_type_definitions(span: S) -> Diagnostic<S>

(E0025) Schema definition must define one or more root operation types.

pub fn missing_root_operation_type_definitions_closing_brace( first: S, second: S, ) -> Diagnostic<S>

(E0026) Root operation type definitions must have a closing brace.

pub fn missing_root_operation_type_definition_colon(span: S) -> Diagnostic<S>

(E0027) Root operation type definition must have a colon.

pub fn missing_root_operation_type_definition_named_type( span: S, ) -> Diagnostic<S>

(E0028) Root operation type definition must have a named type.

pub fn missing_scalar_type_definition_name(span: S) -> Diagnostic<S>

(E0029) Scalar type definition must have a name.

pub fn missing_scalar_type_extension_name(span: S) -> Diagnostic<S>

(E0030) Scalar type extension must have a name.

pub fn missing_scalar_type_extension_directives(span: S) -> Diagnostic<S>

(E0031) Scalar type extension must have one or more directives.

pub fn missing_object_type_definition_name(span: S) -> Diagnostic<S>

(E0032) Object type definition must have a name.

pub fn missing_first_implements_interface(span: S) -> Diagnostic<S>

(E0033) Implemented interfaces must not be empty.

pub fn missing_second_implements_interface(span: S) -> Diagnostic<S>

(E0034) Implemented interface name is missing.

pub fn missing_fields_definition_closing_brace( first: S, second: S, ) -> Diagnostic<S>

(E0035) Fields definition must have a closing brace.

pub fn missing_field_definition_colon(span: S) -> Diagnostic<S>

(E0036) Field definition must have a colon.

pub fn missing_field_definition_type(span: S) -> Diagnostic<S>

(E0037) Field definition must have a type.

pub fn missing_arguments_definition_closing_parenthesis( first: S, second: S, ) -> Diagnostic<S>

(E0038) Arguments definition must have a closing parenthesis.

pub fn missing_input_value_definition_colon(span: S) -> Diagnostic<S>

(E0039) Input value definition must have a colon.

pub fn missing_input_value_definition_type(span: S) -> Diagnostic<S>

(E0040) Input value definition must have a type.

pub fn missing_object_type_extension_name(span: S) -> Diagnostic<S>

(E0041) Object type extension must have a name.

pub fn missing_interface_type_definition_name(span: S) -> Diagnostic<S>

(E0042) Interface type definition must have a name.

pub fn missing_interface_type_extension_name(span: S) -> Diagnostic<S>

(E0043) Interface type extension must have a name.

pub fn missing_union_type_definition_name(span: S) -> Diagnostic<S>

(E0044) Union type definition must have a name.

pub fn missing_first_union_member_type(span: S) -> Diagnostic<S>

(E0045) Union type definition must have one or more member types.

pub fn missing_second_union_member_type(span: S) -> Diagnostic<S>

(E0046) Union member type must have a name.

pub fn missing_union_type_extension_name(span: S) -> Diagnostic<S>

(E0047) Union type extension must have a name.

pub fn missing_enum_type_definition_name(span: S) -> Diagnostic<S>

(E0048) Enum type definition must have a name.

pub fn missing_enum_values_closing_brace(first: S, second: S) -> Diagnostic<S>

(E0049) Enum values must have a closing brace.

pub fn missing_enum_type_extension_name(span: S) -> Diagnostic<S>

(E0050) Enum type extension must have a name.

pub fn missing_input_object_type_definition_name(span: S) -> Diagnostic<S>

(E0051) Input object type definition must have a name.

pub fn missing_input_fields_definition_closing_brace( first: S, second: S, ) -> Diagnostic<S>

(E0052) Input fields definition must have a closing brace.

pub fn missing_input_object_type_extension_name(span: S) -> Diagnostic<S>

(E0053) Input object type extension must have a name.

pub fn missing_directive_definition_at(span: S) -> Diagnostic<S>

(E0054) Directive’s name must start with an @.

pub fn missing_directive_definition_name(span: S) -> Diagnostic<S>

(E0055) Directive definition must have a name.

pub fn missing_directive_definition_locations(span: S) -> Diagnostic<S>

(E0056) Directive definition must have one or more locations.

pub fn missing_first_directive_location(span: S) -> Diagnostic<S>

(E0057) Directive definition must have one or more locations.

pub fn missing_second_directive_location(span: S) -> Diagnostic<S>

(E0058) Directive location must be defined.

pub fn unknown_named_type(name: String, span: S) -> Diagnostic<S>

(E0100) Named type must exist.

pub fn empty_type(name: String, span: S) -> Diagnostic<S>

(E0101) Type must define one or more fields.

pub fn duplicate_field(field: String, first: S, second: S) -> Diagnostic<S>

(E0102) Field name must be unique.

pub fn duplicate_extended_field( name: String, field: String, first: S, extension: S, second: S, ) -> Diagnostic<S>

(E0103) Field name must be unique across extended types.

pub fn reserved_field_name(name: String, span: S) -> Diagnostic<S>

(E0104) Field name must not start with __.

pub fn field_not_output_type(name: String, ty: String, span: S) -> Diagnostic<S>

(E0105) Field must be output type.

pub fn duplicate_argument_name( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0106) Argument name must be unique.

pub fn reserved_input_value_name(name: String, span: S) -> Diagnostic<S>

(E0107) Input value name must not start with __.

pub fn input_value_not_input_type( name: String, ty: String, span: S, ) -> Diagnostic<S>

(E0108) Input value must be input type.

pub fn duplicate_implements_interface( name: String, interface: String, first: S, second: S, ) -> Diagnostic<S>

(E0109) Type must not implement same interface twice.

pub fn implements_non_interface_type( name: String, interface: String, span: S, ) -> Diagnostic<S>

(E0110) Implemented type must be interface.

pub fn missing_inherited_interface( name: String, interface: String, inherited: String, span: S, ) -> Diagnostic<S>

(E0111) Type must also implement inherited interfaces.

pub fn missing_interface_field( name: String, interface: String, field: String, span: S, ) -> Diagnostic<S>

(E0112) Type must implement field from interface.

pub fn missing_interface_field_argument( name: String, interface: String, field: String, argument: String, span: S, ) -> Diagnostic<S>

(E0113) Type must implement field with argument from interface.

pub fn invalid_interface_field_argument_type( name: String, interface: String, field: String, argument: String, expected: String, ty: String, span: S, ) -> Diagnostic<S>

(E0114) Type must implement field with argument of same type as interface.

pub fn unexpected_non_null_extra_interface_field_argument( name: String, interface: String, field: String, argument: String, ty: String, span: S, ) -> Diagnostic<S>

(E0115) Type must not require extra arguments for fields implementing interface.

pub fn non_covariant_interface_field( name: String, interface: String, field: String, expected: String, ty: String, span: S, ) -> Diagnostic<S>

(E0116) Implemented type and type from interface must be covariant.

pub fn self_referential_interface(name: String, span: S) -> Diagnostic<S>

(E0117) Interface must not implement itself.

pub fn missing_union_members(name: String, span: S) -> Diagnostic<S>

(E0118) Union must have at least one member type.

pub fn duplicate_union_member( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0119) Union members must be unique.

pub fn non_object_union_member(name: String, span: S) -> Diagnostic<S>

(E0120) Union members must be object types.

pub fn missing_enum_values(name: String, span: S) -> Diagnostic<S>

(E0121) Enum must have at least one value.

pub fn duplicate_enum_value(name: String, first: S, second: S) -> Diagnostic<S>

(E0122) Enum values must be unique.

pub fn self_referential_input_type( name: String, field: String, ty: String, span: S, ) -> Diagnostic<S>

(E0123) Input type must not be self-referential.

pub fn reserved_directive_name(name: String, span: S) -> Diagnostic<S>

(E0124) Directive name must not start with __.

pub fn self_referential_directive( name: String, directive: String, span: S, ) -> Diagnostic<S>

(E0125) Directive must not be self-referential.

pub fn duplicate_type_name(name: String, first: S, second: S) -> Diagnostic<S>

(E0126) Type name must be unique.

pub fn duplicate_directive_name( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0126) Directive name must be unique.

pub fn different_extension_type( name: String, first_type: String, second_type: String, first: S, second: S, ) -> Diagnostic<S>

(E0127) Type extension must extend type of same kind.

pub fn expected_non_null_value(ty: String, span: S) -> Diagnostic<S>

(E0200) Expected a non-null value.

pub fn expected_list_value(ty: String, span: S) -> Diagnostic<S>

(E0201) Expected a list value.

pub fn expected_int_value(ty: String, span: S) -> Diagnostic<S>

(E0202) Expected an int value.

pub fn expected_float_value(ty: String, span: S) -> Diagnostic<S>

(E0203) Expected a float value.

pub fn expected_string_value(ty: String, span: S) -> Diagnostic<S>

(E0204) Expected a string value.

pub fn expected_boolean_value(ty: String, span: S) -> Diagnostic<S>

(E0205) Expected a boolean value.

pub fn expected_input_object_value(ty: String, span: S) -> Diagnostic<S>

(E0206) Expected an input object value.

pub fn missing_input_field(name: String, ty: String, span: S) -> Diagnostic<S>

(E0207) Expected a value for required input field.

pub fn unrecognized_input_field( name: String, ty: String, span: S, ) -> Diagnostic<S>

(E0208) All fields in input object must exist in schema definition.

pub fn unrecognized_enum_value( name: String, value: String, span: S, ) -> Diagnostic<S>

(E0209) Enum values must exist in schema definition.

pub fn expected_enum_value(ty: String, span: S) -> Diagnostic<S>

(E0210) Expected an enum value.

pub fn duplicate_operation_name( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0300) Operation definitions must be unique.

pub fn lone_anonymous_operation(span: S) -> Diagnostic<S>

(E0301) Anonymous operation definitions must be alone.

pub fn undefined_field(ty: String, field: String, span: S) -> Diagnostic<S>

(E0303) Queried field does not exist.

pub fn incompatible_response_shape( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0304) Selection set contains multiple fields of incompatible types with the same name.

pub fn different_field_names(name: String, first: S, second: S) -> Diagnostic<S>

(E0305) Selection set contains different fields with the same name.

pub fn different_field_arguments( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0306) Selection set contains fields with the same name but different arguments.

pub fn incompatible_response_fields( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0307) Selection set contains multiple fields with the same name with incompatible selection sets.

pub fn missing_selection_set( ty: String, field: String, span: S, ) -> Diagnostic<S>

(E0308) Field of composite type must have selection set.

pub fn unexpected_selection_set( ty: String, field: String, span: S, ) -> Diagnostic<S>

(E0309) Field of scalar-like type must not have a selection set.

pub fn undefined_argument(name: String, span: S) -> Diagnostic<S>

(E0310) Argument must exist in schema.

pub fn duplicate_argument(name: String, first: S, second: S) -> Diagnostic<S>

(E0311) Argument may be provided only once.

pub fn missing_required_argument( name: String, ty: String, span: S, ) -> Diagnostic<S>

(E0312) Missing required argument.

pub fn duplicate_fragment_name( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0313) Fragment definitions must be unique.

pub fn fragment_on_non_composite_type( name: String, ty: String, span: S, ) -> Diagnostic<S>

(E0314) Fragment definitions must target composite type.

pub fn unused_fragment_definition(name: String, span: S) -> Diagnostic<S>

(E0315) Fragment definitions must be used.

pub fn undefined_fragment(name: String, span: S) -> Diagnostic<S>

(E0316) Fragment definition must be defined.

pub fn cyclic_fragment_definition( name: String, spread: String, span: S, ) -> Diagnostic<S>

(E0317) Fragment definition must not be cyclic.

pub fn impossible_fragment_spread( ty: String, scope: String, span: S, ) -> Diagnostic<S>

(E0318) Fragment spread must be possible.

pub fn undefined_directive(name: String, span: S) -> Diagnostic<S>

(E0319) Directive must be defined.

pub fn directive_in_invalid_location( name: String, location: String, locations: String, span: S, ) -> Diagnostic<S>

(E0320) Directive must be used in valid location.

pub fn duplicate_non_repeatable_directive( name: String, first: S, second: S, ) -> Diagnostic<S>

(E0321) Non-repeatable directive must be unique per location.

pub fn duplicate_variable(name: String, first: S, second: S) -> Diagnostic<S>

(E0322) Variables must be unique per operation definition.

pub fn variable_must_be_input_type( name: String, ty: String, span: S, ) -> Diagnostic<S>

(E0323) Variables must be input types.

pub fn undefined_variable(name: String, span: S) -> Diagnostic<S>

(E0324) Variables must be defined before they can be used.

pub fn undefined_variable_in_fragment( fragment: String, name: String, span: S, usage: S, ) -> Diagnostic<S>

(E0325) Operations must define variables for all transitively included fragments.

pub fn unused_variable(name: String, span: S) -> Diagnostic<S>

(E0326) Variables must be used.

pub fn incompatible_variable( name: String, ty: String, expected: String, first: S, second: S, ) -> Diagnostic<S>

(E0327) Variable must be compatible with usage.

pub fn incompatible_variable_in_fragment( fragment: String, name: String, ty: String, expected: String, span: S, second: S, first: S, ) -> Diagnostic<S>

(E0328) Variable must be compatible with usage.

pub fn unsupported_operation(name: String, span: S) -> Diagnostic<S>

(E0329) Operation must be defined in schema before it can be used.

pub fn code(&self) -> &'static str

Returns the code of this diagnostic. This is usually a letter (e.g. E) followed by 4 digits that represent the error number.

pub fn message(&self) -> &'static str

Returns the message of this diagnostic.

pub fn span(&self) -> S

Returns the primary span that triggered this diagnostic.

pub fn labels(&self) -> Vec<(S, String)>

Returns additional labels for this diagnostic: pairs of spans and explanations.

Trait Implementations

impl<S> Clone for Diagnostic<S>

where S: Copy + Clone,

fn clone(&self) -> Diagnostic<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for Diagnostic<S>

where S: Copy + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S> Into<Report<S>> for Diagnostic<S>

where S: Copy + Span,

fn into(self) -> Report<S>

Converts this type into the (usually inferred) input type.