Method parse_primary

parser/src/parser/parser.rs:2242–2355

https://docs.python.org/3/reference/expressions.html#primaries primaries can be chained together, when they are chained the base is the previous primary

(&mut self, base: Option<Expression>)

    // primaries can be chained together, when they are chained the base is the
    // previous primary
    fn parse_primary(&mut self, base: Option<Expression>) -> Result<Expression, ParsingError> {
        let next = self.peek_token();
        let node = self.start_node();
        let call_node = self.start_node();
        let mut atom_or_primary = if let Some(base) = base {
            base
        } else if self.cur_kind().is_atom() {
            self.parse_atom()?
        } else {
            panic!("not a primary {:?}", self.cur_token());
        };

        let mut primary = if self.at(Kind::Dot) {
            self.parse_attribute_ref(node, atom_or_primary)
        } else if self.at(Kind::LeftBrace) {
            // https://docs.python.org/3/reference/expressions.html#slicings
            self.parse_subscript(atom_or_primary.get_node(), atom_or_primary)
        } else if self.eat(Kind::LeftParen) {
            // parse call
            // https://docs.python.org/3/reference/expressions.html#calls
            let mut positional_args = vec![];
            let mut keyword_args = vec![];
            let mut seen_keyword = false;

            loop {
                if self.at(Kind::RightParen) {
                    break;
                }
                if self.at(Kind::Identifier) && matches!(self.peek_kind(), Ok(Kind::Assign)) {
                    seen_keyword = true;
                    let keyword_arg = self.parse_keyword_item()?;
                    keyword_args.push(keyword_arg);
                } else if self.at(Kind::Mul) {
                    let star_arg_node = self.start_node();
                    self.bump(Kind::Mul);
                    let expr = self.parse_expression()?;
                    let star_arg = Expression::Starred(Box::new(Starred {
                        node: self.finish_node(star_arg_node),
                        value: expr,
                    }));
                    positional_args.push(star_arg);
                } else if self.at(Kind::Pow) {
                    let kwarg_node = self.start_node();
                    self.bump(Kind::Pow);
                    seen_keyword = true;
                    let expr = self.parse_expression()?;
                    let kwarg = Keyword {
                        node: self.finish_node(kwarg_node),
                        arg: None,
                        value: expr,
                    };
                    keyword_args.push(kwarg);
                } else {
                    if seen_keyword {
                        let node_end = self.finish_node(node);
                        panic!("Positional arguments cannot come after keyword arguments.");
                    }
                    let arg = self.parse_named_expression()?;