Struct async_graphql_parser::Positioned

pub struct Positioned<T: ?Sized> {
    pub pos: Pos,
    pub node: T,
}

An AST node that stores its original position.

Fields

pos: Pos

The position of the node.

node: T

The node itself.

Implementations

impl<T> Positioned<T>

pub const fn new(node: T, pos: Pos) -> Positioned<T>

Create a new positioned node from the node and its position.

Examples found in repository

src/pos.rs (line 71)

    pub fn position_node<U>(&self, other: U) -> Positioned<U> {
        Positioned::new(other, self.pos)
    }

    /// Map the inner value of this positioned node.
    #[must_use]
    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Positioned<U> {
        Positioned::new(f(self.node), self.pos)
    }

src/types/mod.rs (line 168)

    pub fn into_const(self) -> Option<ConstDirective> {
        Some(ConstDirective {
            name: self.name,
            arguments: self
                .arguments
                .into_iter()
                .map(|(name, value)| {
                    Some((name, Positioned::new(value.node.into_const()?, value.pos)))
                })
                .collect::<Option<_>>()?,
        })
    }

src/parse/mod.rs (lines 41-49)

fn parse_operation_type(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<OperationType>> {
    debug_assert_eq!(pair.as_rule(), Rule::operation_type);

    let pos = pc.step(&pair);

    Ok(Positioned::new(
        match pair.as_str() {
            "query" => OperationType::Query,
            "mutation" => OperationType::Mutation,
            "subscription" => OperationType::Subscription,
            _ => unreachable!(),
        },
        pos,
    ))
}

fn parse_default_value(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<ConstValue>> {
    debug_assert_eq!(pair.as_rule(), Rule::default_value);

    parse_const_value(exactly_one(pair.into_inner()), pc)
}

fn parse_type(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Type>> {
    debug_assert_eq!(pair.as_rule(), Rule::type_);

    Ok(Positioned::new(
        Type::new(pair.as_str()).unwrap(),
        pc.step(&pair),
    ))
}

fn parse_const_value(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<ConstValue>> {
    debug_assert_eq!(pair.as_rule(), Rule::const_value);

    let pos = pc.step(&pair);
    let pair = exactly_one(pair.into_inner());

    Ok(Positioned::new(
        match pair.as_rule() {
            Rule::number => ConstValue::Number(parse_number(pair, pc)?.node),
            Rule::string => ConstValue::String(parse_string(pair, pc)?.node),
            Rule::boolean => ConstValue::Boolean(parse_boolean(pair, pc)?.node),
            Rule::null => ConstValue::Null,
            Rule::enum_value => ConstValue::Enum(parse_enum_value(pair, pc)?.node),
            Rule::const_list => ConstValue::List(
                pair.into_inner()
                    .map(|pair| Ok(parse_const_value(pair, pc)?.node))
                    .collect::<Result<_>>()?,
            ),
            Rule::const_object => ConstValue::Object(
                pair.into_inner()
                    .map(|pair| {
                        debug_assert_eq!(pair.as_rule(), Rule::const_object_field);

                        let mut pairs = pair.into_inner();

                        let name = parse_name(pairs.next().unwrap(), pc)?;
                        let value = parse_const_value(pairs.next().unwrap(), pc)?;

                        debug_assert_eq!(pairs.next(), None);

                        Ok((name.node, value.node))
                    })
                    .collect::<Result<_>>()?,
            ),
            _ => unreachable!(),
        },
        pos,
    ))
}
fn parse_value(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Value>> {
    debug_assert_eq!(pair.as_rule(), Rule::value);

    let pos = pc.step(&pair);
    let pair = exactly_one(pair.into_inner());

    Ok(Positioned::new(
        match pair.as_rule() {
            Rule::variable => Value::Variable(parse_variable(pair, pc)?.node),
            Rule::number => Value::Number(parse_number(pair, pc)?.node),
            Rule::string => Value::String(parse_string(pair, pc)?.node),
            Rule::boolean => Value::Boolean(parse_boolean(pair, pc)?.node),
            Rule::null => Value::Null,
            Rule::enum_value => Value::Enum(parse_enum_value(pair, pc)?.node),
            Rule::list => Value::List(
                pair.into_inner()
                    .map(|pair| Ok(parse_value(pair, pc)?.node))
                    .collect::<Result<_>>()?,
            ),
            Rule::object => Value::Object(
                pair.into_inner()
                    .map(|pair| {
                        debug_assert_eq!(pair.as_rule(), Rule::object_field);
                        let mut pairs = pair.into_inner();

                        let name = parse_name(pairs.next().unwrap(), pc)?;
                        let value = parse_value(pairs.next().unwrap(), pc)?;

                        debug_assert_eq!(pairs.next(), None);

                        Ok((name.node, value.node))
                    })
                    .collect::<Result<_>>()?,
            ),
            _ => unreachable!(),
        },
        pos,
    ))
}

fn parse_variable(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Name>> {
    debug_assert_eq!(pair.as_rule(), Rule::variable);
    parse_name(exactly_one(pair.into_inner()), pc)
}
fn parse_number(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Number>> {
    debug_assert_eq!(pair.as_rule(), Rule::number);
    let pos = pc.step(&pair);
    Ok(Positioned::new(
        pair.as_str().parse().map_err(|err| Error::Syntax {
            message: format!("invalid number: {}", err),
            start: pos,
            end: None,
        })?,
        pos,
    ))
}
fn parse_string(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<String>> {
    debug_assert_eq!(pair.as_rule(), Rule::string);
    let pos = pc.step(&pair);
    let pair = exactly_one(pair.into_inner());
    Ok(Positioned::new(
        match pair.as_rule() {
            Rule::block_string_content => block_string_value(pair.as_str()),
            Rule::string_content => string_value(pair.as_str()),
            _ => unreachable!(),
        },
        pos,
    ))
}
fn parse_boolean(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<bool>> {
    debug_assert_eq!(pair.as_rule(), Rule::boolean);
    let pos = pc.step(&pair);
    Ok(Positioned::new(
        match pair.as_str() {
            "true" => true,
            "false" => false,
            _ => unreachable!(),
        },
        pos,
    ))
}
fn parse_enum_value(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Name>> {
    debug_assert_eq!(pair.as_rule(), Rule::enum_value);
    parse_name(exactly_one(pair.into_inner()), pc)
}

fn parse_opt_const_directives<'a>(
    pairs: &mut Pairs<'a, Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<Positioned<ConstDirective>>> {
    Ok(parse_if_rule(pairs, Rule::const_directives, |pair| {
        parse_const_directives(pair, pc)
    })?
    .unwrap_or_default())
}
fn parse_opt_directives<'a>(
    pairs: &mut Pairs<'a, Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<Positioned<Directive>>> {
    Ok(
        parse_if_rule(pairs, Rule::directives, |pair| parse_directives(pair, pc))?
            .unwrap_or_default(),
    )
}
fn parse_const_directives(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<Positioned<ConstDirective>>> {
    debug_assert_eq!(pair.as_rule(), Rule::const_directives);

    pair.into_inner()
        .map(|pair| parse_const_directive(pair, pc))
        .collect()
}
fn parse_directives(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<Positioned<Directive>>> {
    debug_assert_eq!(pair.as_rule(), Rule::directives);

    pair.into_inner()
        .map(|pair| parse_directive(pair, pc))
        .collect()
}

fn parse_const_directive(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<ConstDirective>> {
    debug_assert_eq!(pair.as_rule(), Rule::const_directive);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let name = parse_name(pairs.next().unwrap(), pc)?;
    let arguments = parse_if_rule(&mut pairs, Rule::const_arguments, |pair| {
        parse_const_arguments(pair, pc)
    })?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        ConstDirective {
            name,
            arguments: arguments.unwrap_or_default(),
        },
        pos,
    ))
}
fn parse_directive(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Directive>> {
    debug_assert_eq!(pair.as_rule(), Rule::directive);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let name = parse_name(pairs.next().unwrap(), pc)?;
    let arguments = parse_if_rule(&mut pairs, Rule::arguments, |pair| {
        parse_arguments(pair, pc)
    })?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        Directive {
            name,
            arguments: arguments.unwrap_or_default(),
        },
        pos,
    ))
}

fn parse_const_arguments(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<(Positioned<Name>, Positioned<ConstValue>)>> {
    debug_assert_eq!(pair.as_rule(), Rule::const_arguments);
    pair.into_inner()
        .map(|pair| {
            debug_assert_eq!(pair.as_rule(), Rule::const_argument);
            let mut pairs = pair.into_inner();

            let name = parse_name(pairs.next().unwrap(), pc)?;
            let value = parse_const_value(pairs.next().unwrap(), pc)?;

            debug_assert_eq!(pairs.next(), None);

            Ok((name, value))
        })
        .collect()
}
fn parse_arguments(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<(Positioned<Name>, Positioned<Value>)>> {
    debug_assert_eq!(pair.as_rule(), Rule::arguments);
    pair.into_inner()
        .map(|pair| {
            debug_assert_eq!(pair.as_rule(), Rule::argument);
            let mut pairs = pair.into_inner();

            let name = parse_name(pairs.next().unwrap(), pc)?;
            let value = parse_value(pairs.next().unwrap(), pc)?;

            debug_assert_eq!(pairs.next(), None);

            Ok((name, value))
        })
        .collect()
}

fn parse_name(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Name>> {
    debug_assert_eq!(pair.as_rule(), Rule::name);
    Ok(Positioned::new(Name::new(pair.as_str()), pc.step(&pair)))
}

src/parse/service.rs (lines 95-104)

fn parse_schema_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<SchemaDefinition>> {
    debug_assert_eq!(pair.as_rule(), Rule::schema_definition);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let extend = next_if_rule(&mut pairs, Rule::extend).is_some();
    let directives = parse_opt_const_directives(&mut pairs, pc)?;

    let mut query = None;
    let mut mutation = None;
    let mut subscription = None;

    for pair in pairs {
        debug_assert_eq!(pair.as_rule(), Rule::operation_type_definition);

        let mut pairs = pair.into_inner();

        let operation_type = parse_operation_type(pairs.next().unwrap(), pc)?;
        let name = parse_name(pairs.next().unwrap(), pc)?;

        match operation_type.node {
            OperationType::Query if query.is_none() => query = Some(name),
            OperationType::Mutation if mutation.is_none() => mutation = Some(name),
            OperationType::Subscription if subscription.is_none() => subscription = Some(name),
            _ => {
                return Err(Error::MultipleRoots {
                    root: operation_type.node,
                    schema: pos,
                    pos: operation_type.pos,
                })
            }
        }

        debug_assert_eq!(pairs.next(), None);
    }

    if !extend && query.is_none() {
        return Err(Error::MissingQueryRoot { pos });
    }

    Ok(Positioned::new(
        SchemaDefinition {
            extend,
            directives,
            query,
            mutation,
            subscription,
        },
        pos,
    ))
}

fn parse_type_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<TypeDefinition>> {
    debug_assert_eq!(pair.as_rule(), Rule::type_definition);

    let pos = pc.step(&pair);
    let pair = exactly_one(pair.into_inner());
    let rule = pair.as_rule();
    let mut pairs = pair.into_inner();

    let description = parse_if_rule(&mut pairs, Rule::string, |pair| parse_string(pair, pc))?;
    let extend = next_if_rule(&mut pairs, Rule::extend).is_some();
    let name = parse_name(pairs.next().unwrap(), pc)?;

    let (directives, kind) = match rule {
        Rule::scalar_type => {
            let directives = parse_opt_const_directives(&mut pairs, pc)?;
            (directives, TypeKind::Scalar)
        }
        Rule::object_type => {
            let implements = parse_if_rule(&mut pairs, Rule::implements_interfaces, |pair| {
                debug_assert_eq!(pair.as_rule(), Rule::implements_interfaces);

                pair.into_inner()
                    .map(|pair| parse_name(pair, pc))
                    .collect::<Result<_>>()
            })?;

            let directives = parse_opt_const_directives(&mut pairs, pc)?;

            let fields = parse_if_rule(&mut pairs, Rule::fields_definition, |pair| {
                parse_fields_definition(pair, pc)
            })?
            .unwrap_or_default();

            (
                directives,
                TypeKind::Object(ObjectType {
                    implements: implements.unwrap_or_default(),
                    fields,
                }),
            )
        }
        Rule::interface_type => {
            let implements = parse_if_rule(&mut pairs, Rule::implements_interfaces, |pair| {
                debug_assert_eq!(pair.as_rule(), Rule::implements_interfaces);

                pair.into_inner()
                    .map(|pair| parse_name(pair, pc))
                    .collect::<Result<_>>()
            })?;

            let directives = parse_opt_const_directives(&mut pairs, pc)?;
            let fields = parse_if_rule(&mut pairs, Rule::fields_definition, |pair| {
                parse_fields_definition(pair, pc)
            })?
            .unwrap_or_default();
            (
                directives,
                TypeKind::Interface(InterfaceType {
                    implements: implements.unwrap_or_default(),
                    fields,
                }),
            )
        }
        Rule::union_type => {
            let directives = parse_opt_const_directives(&mut pairs, pc)?;
            let members = parse_if_rule(&mut pairs, Rule::union_member_types, |pair| {
                debug_assert_eq!(pair.as_rule(), Rule::union_member_types);

                pair.into_inner().map(|pair| parse_name(pair, pc)).collect()
            })?
            .unwrap_or_default();
            (directives, TypeKind::Union(UnionType { members }))
        }
        Rule::enum_type => {
            let directives = parse_opt_const_directives(&mut pairs, pc)?;
            let values = parse_if_rule(&mut pairs, Rule::enum_values, |pair| {
                debug_assert_eq!(pair.as_rule(), Rule::enum_values);

                pair.into_inner()
                    .map(|pair| {
                        debug_assert_eq!(pair.as_rule(), Rule::enum_value_definition);

                        let pos = pc.step(&pair);
                        let mut pairs = pair.into_inner();

                        let description =
                            parse_if_rule(&mut pairs, Rule::string, |pair| parse_string(pair, pc))?;
                        let value = parse_enum_value(pairs.next().unwrap(), pc)?;
                        let directives = parse_opt_const_directives(&mut pairs, pc)?;

                        debug_assert_eq!(pairs.next(), None);

                        Ok(Positioned::new(
                            EnumValueDefinition {
                                description,
                                value,
                                directives,
                            },
                            pos,
                        ))
                    })
                    .collect()
            })?
            .unwrap_or_default();
            (directives, TypeKind::Enum(EnumType { values }))
        }
        Rule::input_object_type => {
            let directives = parse_opt_const_directives(&mut pairs, pc)?;
            let fields = parse_if_rule(&mut pairs, Rule::input_fields_definition, |pair| {
                debug_assert_eq!(pair.as_rule(), Rule::input_fields_definition);

                pair.into_inner()
                    .map(|pair| parse_input_value_definition(pair, pc))
                    .collect()
            })?
            .unwrap_or_default();

            (
                directives,
                TypeKind::InputObject(InputObjectType { fields }),
            )
        }
        _ => unreachable!(),
    };

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        TypeDefinition {
            extend,
            description,
            name,
            directives,
            kind,
        },
        pos,
    ))
}

fn parse_fields_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<Positioned<FieldDefinition>>> {
    debug_assert_eq!(pair.as_rule(), Rule::fields_definition);

    pair.into_inner()
        .map(|pair| parse_field_definition(pair, pc))
        .collect()
}

fn parse_field_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<FieldDefinition>> {
    debug_assert_eq!(pair.as_rule(), Rule::field_definition);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let description = parse_if_rule(&mut pairs, Rule::string, |pair| parse_string(pair, pc))?;
    let name = parse_name(pairs.next().unwrap(), pc)?;
    let arguments = parse_if_rule(&mut pairs, Rule::arguments_definition, |pair| {
        parse_arguments_definition(pair, pc)
    })?
    .unwrap_or_default();
    let ty = parse_type(pairs.next().unwrap(), pc)?;
    let directives = parse_opt_const_directives(&mut pairs, pc)?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        FieldDefinition {
            description,
            name,
            arguments,
            ty,
            directives,
        },
        pos,
    ))
}

fn parse_directive_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<DirectiveDefinition>> {
    debug_assert_eq!(pair.as_rule(), Rule::directive_definition);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let description = parse_if_rule(&mut pairs, Rule::string, |pair| parse_string(pair, pc))?;
    let name = parse_name(pairs.next().unwrap(), pc)?;
    let arguments = parse_if_rule(&mut pairs, Rule::arguments_definition, |pair| {
        debug_assert_eq!(pair.as_rule(), Rule::arguments_definition);
        pair.into_inner()
            .map(|pair| parse_input_value_definition(pair, pc))
            .collect()
    })?
    .unwrap_or_default();
    let locations = {
        let pair = pairs.next().unwrap();
        debug_assert_eq!(pair.as_rule(), Rule::directive_locations);
        pair.into_inner()
            .map(|pair| {
                let pos = pc.step(&pair);
                debug_assert_eq!(pair.as_rule(), Rule::directive_location);
                Positioned::new(
                    match pair.as_str() {
                        "QUERY" => DirectiveLocation::Query,
                        "MUTATION" => DirectiveLocation::Mutation,
                        "SUBSCRIPTION" => DirectiveLocation::Subscription,
                        "FIELD" => DirectiveLocation::Field,
                        "FRAGMENT_DEFINITION" => DirectiveLocation::FragmentDefinition,
                        "FRAGMENT_SPREAD" => DirectiveLocation::FragmentSpread,
                        "INLINE_FRAGMENT" => DirectiveLocation::InlineFragment,
                        "VARIABLE_DEFINITION" => DirectiveLocation::VariableDefinition,
                        "SCHEMA" => DirectiveLocation::Schema,
                        "SCALAR" => DirectiveLocation::Scalar,
                        "OBJECT" => DirectiveLocation::Object,
                        "FIELD_DEFINITION" => DirectiveLocation::FieldDefinition,
                        "ARGUMENT_DEFINITION" => DirectiveLocation::ArgumentDefinition,
                        "INTERFACE" => DirectiveLocation::Interface,
                        "UNION" => DirectiveLocation::Union,
                        "ENUM" => DirectiveLocation::Enum,
                        "ENUM_VALUE" => DirectiveLocation::EnumValue,
                        "INPUT_OBJECT" => DirectiveLocation::InputObject,
                        "INPUT_FIELD_DEFINITION" => DirectiveLocation::InputFieldDefinition,
                        _ => unreachable!(),
                    },
                    pos,
                )
            })
            .collect()
    };

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        DirectiveDefinition {
            description,
            name,
            arguments,
            locations,
        },
        pos,
    ))
}

fn parse_arguments_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<Positioned<InputValueDefinition>>> {
    debug_assert_eq!(pair.as_rule(), Rule::arguments_definition);

    pair.into_inner()
        .map(|pair| parse_input_value_definition(pair, pc))
        .collect()
}

fn parse_input_value_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<InputValueDefinition>> {
    debug_assert_eq!(pair.as_rule(), Rule::input_value_definition);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let description = parse_if_rule(&mut pairs, Rule::string, |pair| parse_string(pair, pc))?;
    let name = parse_name(pairs.next().unwrap(), pc)?;
    let ty = parse_type(pairs.next().unwrap(), pc)?;
    let default_value = parse_if_rule(&mut pairs, Rule::default_value, |pair| {
        parse_default_value(pair, pc)
    })?;
    let directives = parse_opt_const_directives(&mut pairs, pc)?;

    Ok(Positioned::new(
        InputValueDefinition {
            description,
            name,
            ty,
            default_value,
            directives,
        },
        pos,
    ))
}

src/parse/executable.rs (line 56)

pub fn parse_query<T: AsRef<str>>(input: T) -> Result<ExecutableDocument> {
    let mut pc = PositionCalculator::new(input.as_ref());

    let pairs = GraphQLParser::parse(Rule::executable_document, input.as_ref())?;
    let items = parse_definition_items(exactly_one(pairs), &mut pc)?;

    let mut operations = None;
    let mut fragments: HashMap<_, Positioned<FragmentDefinition>> = HashMap::new();

    for item in items {
        match item {
            DefinitionItem::Operation(item) => {
                if let Some(name) = item.node.name {
                    let operations = operations
                        .get_or_insert_with(|| DocumentOperations::Multiple(HashMap::new()));
                    let operations = match operations {
                        DocumentOperations::Single(anonymous) => {
                            return Err(Error::MultipleOperations {
                                anonymous: anonymous.pos,
                                operation: item.pos,
                            })
                        }
                        DocumentOperations::Multiple(operations) => operations,
                    };

                    match operations.entry(name.node) {
                        hash_map::Entry::Occupied(entry) => {
                            let (name, first) = entry.remove_entry();
                            return Err(Error::OperationDuplicated {
                                operation: name,
                                first: first.pos,
                                second: item.pos,
                            });
                        }
                        hash_map::Entry::Vacant(entry) => {
                            entry.insert(Positioned::new(item.node.definition, item.pos));
                        }
                    }
                } else {
                    match operations {
                        Some(operations) => {
                            return Err(Error::MultipleOperations {
                                anonymous: item.pos,
                                operation: match operations {
                                    DocumentOperations::Single(single) => single.pos,
                                    DocumentOperations::Multiple(map) => {
                                        map.values().next().unwrap().pos
                                    }
                                },
                            });
                        }
                        None => {
                            operations = Some(DocumentOperations::Single(Positioned::new(
                                item.node.definition,
                                item.pos,
                            )));
                        }
                    }
                }
            }
            DefinitionItem::Fragment(item) => match fragments.entry(item.node.name.node) {
                hash_map::Entry::Occupied(entry) => {
                    let (name, first) = entry.remove_entry();
                    return Err(Error::FragmentDuplicated {
                        fragment: name,
                        first: first.pos,
                        second: item.pos,
                    });
                }
                hash_map::Entry::Vacant(entry) => {
                    entry.insert(Positioned::new(item.node.definition, item.pos));
                }
            },
        }
    }

    Ok(ExecutableDocument {
        operations: operations.ok_or(Error::MissingOperation)?,
        fragments,
    })
}

fn parse_definition_items(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<DefinitionItem>> {
    debug_assert_eq!(pair.as_rule(), Rule::executable_document);

    Ok(pair
        .into_inner()
        .filter(|pair| pair.as_rule() != Rule::EOI)
        .map(|pair| parse_definition_item(pair, pc))
        .collect::<Result<_>>()?)
}

enum DefinitionItem {
    Operation(Positioned<OperationDefinitionItem>),
    Fragment(Positioned<FragmentDefinitionItem>),
}

fn parse_definition_item(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<DefinitionItem> {
    debug_assert_eq!(pair.as_rule(), Rule::executable_definition);

    let pair = exactly_one(pair.into_inner());
    Ok(match pair.as_rule() {
        Rule::operation_definition => {
            DefinitionItem::Operation(parse_operation_definition_item(pair, pc)?)
        }
        Rule::fragment_definition => {
            DefinitionItem::Fragment(parse_fragment_definition_item(pair, pc)?)
        }
        _ => unreachable!(),
    })
}

struct OperationDefinitionItem {
    name: Option<Positioned<Name>>,
    definition: OperationDefinition,
}

fn parse_operation_definition_item(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<OperationDefinitionItem>> {
    debug_assert_eq!(pair.as_rule(), Rule::operation_definition);

    let pos = pc.step(&pair);
    let pair = exactly_one(pair.into_inner());
    Ok(Positioned::new(
        match pair.as_rule() {
            Rule::named_operation_definition => parse_named_operation_definition(pair, pc)?,
            Rule::selection_set => OperationDefinitionItem {
                name: None,
                definition: OperationDefinition {
                    ty: OperationType::Query,
                    variable_definitions: Vec::new(),
                    directives: Vec::new(),
                    selection_set: parse_selection_set(pair, pc, MAX_RECURSION_DEPTH)?,
                },
            },
            _ => unreachable!(),
        },
        pos,
    ))
}

fn parse_named_operation_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<OperationDefinitionItem> {
    debug_assert_eq!(pair.as_rule(), Rule::named_operation_definition);

    let mut pairs = pair.into_inner();

    let ty = parse_operation_type(pairs.next().unwrap(), pc)?;
    let name = parse_if_rule(&mut pairs, Rule::name, |pair| parse_name(pair, pc))?;
    let variable_definitions = parse_if_rule(&mut pairs, Rule::variable_definitions, |pair| {
        parse_variable_definitions(pair, pc)
    })?;
    let directives = parse_opt_directives(&mut pairs, pc)?;
    let selection_set = parse_selection_set(pairs.next().unwrap(), pc, MAX_RECURSION_DEPTH)?;

    debug_assert_eq!(pairs.next(), None);

    Ok(OperationDefinitionItem {
        name,
        definition: OperationDefinition {
            ty: ty.node,
            variable_definitions: variable_definitions.unwrap_or_default(),
            directives,
            selection_set,
        },
    })
}

fn parse_variable_definitions(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Vec<Positioned<VariableDefinition>>> {
    debug_assert_eq!(pair.as_rule(), Rule::variable_definitions);

    pair.into_inner()
        .map(|pair| parse_variable_definition(pair, pc))
        .collect()
}

fn parse_variable_definition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<VariableDefinition>> {
    debug_assert_eq!(pair.as_rule(), Rule::variable_definition);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let variable = parse_variable(pairs.next().unwrap(), pc)?;
    let var_type = parse_type(pairs.next().unwrap(), pc)?;

    let directives = parse_opt_directives(&mut pairs, pc)?;
    let default_value = parse_if_rule(&mut pairs, Rule::default_value, |pair| {
        parse_default_value(pair, pc)
    })?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        VariableDefinition {
            name: variable,
            var_type,
            directives,
            default_value,
        },
        pos,
    ))
}

fn parse_selection_set(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
    remaining_depth: usize,
) -> Result<Positioned<SelectionSet>> {
    debug_assert_eq!(pair.as_rule(), Rule::selection_set);

    let pos = pc.step(&pair);

    Ok(Positioned::new(
        SelectionSet {
            items: pair
                .into_inner()
                .map(|pair| parse_selection(pair, pc, remaining_depth))
                .collect::<Result<_>>()?,
        },
        pos,
    ))
}

fn parse_selection(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
    remaining_depth: usize,
) -> Result<Positioned<Selection>> {
    debug_assert_eq!(pair.as_rule(), Rule::selection);

    let pos = pc.step(&pair);
    let pair = exactly_one(pair.into_inner());

    Ok(Positioned::new(
        match pair.as_rule() {
            Rule::field => Selection::Field(parse_field(pair, pc, remaining_depth)?),
            Rule::fragment_spread => Selection::FragmentSpread(parse_fragment_spread(pair, pc)?),
            Rule::inline_fragment => {
                Selection::InlineFragment(parse_inline_fragment(pair, pc, remaining_depth)?)
            }
            _ => unreachable!(),
        },
        pos,
    ))
}

fn parse_field(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
    remaining_depth: usize,
) -> Result<Positioned<Field>> {
    debug_assert_eq!(pair.as_rule(), Rule::field);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let alias = parse_if_rule(&mut pairs, Rule::alias, |pair| parse_alias(pair, pc))?;
    let name = parse_name(pairs.next().unwrap(), pc)?;
    let arguments = parse_if_rule(&mut pairs, Rule::arguments, |pair| {
        parse_arguments(pair, pc)
    })?;
    let directives = parse_opt_directives(&mut pairs, pc)?;
    let selection_set = parse_if_rule(&mut pairs, Rule::selection_set, |pair| {
        parse_selection_set(pair, pc, recursion_depth!(remaining_depth))
    })?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        Field {
            alias,
            name,
            arguments: arguments.unwrap_or_default(),
            directives,
            selection_set: selection_set.unwrap_or_default(),
        },
        pos,
    ))
}

fn parse_alias(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Positioned<Name>> {
    debug_assert_eq!(pair.as_rule(), Rule::alias);
    parse_name(exactly_one(pair.into_inner()), pc)
}

fn parse_fragment_spread(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<FragmentSpread>> {
    debug_assert_eq!(pair.as_rule(), Rule::fragment_spread);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let fragment_name = parse_name(pairs.next().unwrap(), pc)?;
    let directives = parse_opt_directives(&mut pairs, pc)?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        FragmentSpread {
            fragment_name,
            directives,
        },
        pos,
    ))
}

fn parse_inline_fragment(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
    remaining_depth: usize,
) -> Result<Positioned<InlineFragment>> {
    debug_assert_eq!(pair.as_rule(), Rule::inline_fragment);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let type_condition = parse_if_rule(&mut pairs, Rule::type_condition, |pair| {
        parse_type_condition(pair, pc)
    })?;
    let directives = parse_opt_directives(&mut pairs, pc)?;
    let selection_set =
        parse_selection_set(pairs.next().unwrap(), pc, recursion_depth!(remaining_depth))?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        InlineFragment {
            type_condition,
            directives,
            selection_set,
        },
        pos,
    ))
}

struct FragmentDefinitionItem {
    name: Positioned<Name>,
    definition: FragmentDefinition,
}

fn parse_fragment_definition_item(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<FragmentDefinitionItem>> {
    debug_assert_eq!(pair.as_rule(), Rule::fragment_definition);

    let pos = pc.step(&pair);
    let mut pairs = pair.into_inner();

    let name = parse_name(pairs.next().unwrap(), pc)?;
    let type_condition = parse_type_condition(pairs.next().unwrap(), pc)?;
    let directives = parse_opt_directives(&mut pairs, pc)?;
    let selection_set = parse_selection_set(pairs.next().unwrap(), pc, MAX_RECURSION_DEPTH)?;

    debug_assert_eq!(pairs.next(), None);

    Ok(Positioned::new(
        FragmentDefinitionItem {
            name,
            definition: FragmentDefinition {
                type_condition,
                directives,
                selection_set,
            },
        },
        pos,
    ))
}

fn parse_type_condition(
    pair: Pair<Rule>,
    pc: &mut PositionCalculator,
) -> Result<Positioned<TypeCondition>> {
    debug_assert_eq!(pair.as_rule(), Rule::type_condition);

    let pos = pc.step(&pair);
    Ok(Positioned::new(
        TypeCondition {
            on: parse_name(exactly_one(pair.into_inner()), pc)?,
        },
        pos,
    ))
}

pub fn into_inner(self) -> T

Get the inner node.

This is most useful in callback chains where Positioned::into_inner is easier to read than |positioned| positioned.node.

pub fn position_node<U>(&self, other: U) -> Positioned<U>

Create a new positioned node with the same position as this one.

pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Positioned<U>

Map the inner value of this positioned node.

Examples found in repository

src/types/mod.rs (line 132)

    pub fn into_directive(self) -> Directive {
        Directive {
            name: self.name,
            arguments: self
                .arguments
                .into_iter()
                .map(|(name, value)| (name, value.map(ConstValue::into_value)))
                .collect(),
        }
    }

Trait Implementations

impl Borrow<str> for Positioned<String>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl BorrowMut<str> for Positioned<String>

fn borrow_mut(&mut self) -> &mut str

Mutably borrows from an owned value.

impl<T: Clone + ?Sized> Clone for Positioned<T>

fn clone(&self) -> Positioned<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for Positioned<T>

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

Formats the value using the given formatter.

impl<T: Default + ?Sized> Default for Positioned<T>

fn default() -> Positioned<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Positioned<T>where
    T: Deserialize<'de> + ?Sized,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Display> Display for Positioned<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Positioned<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord> Ord for Positioned<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq<Positioned<T>> for Positioned<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd<Positioned<T>> for Positioned<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for Positioned<T>where
    T: Serialize + ?Sized,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy + ?Sized> Copy for Positioned<T>

impl<T: Eq> Eq for Positioned<T>