Method parse_starred_expression

parser/src/parser/parser.rs:2873–2910

https://docs.python.org/3/reference/expressions.html#expression-lists

(
        &mut self,
        node: Node,
        first_elm: Expression,
    )

    // https://docs.python.org/3/reference/expressions.html#expression-lists
    fn parse_starred_expression(
        &mut self,
        node: Node,
        first_elm: Expression,
    ) -> Result<Expression, ParsingError> {
        let mut elements = vec![];
        // if tuple has one element but there's a comma after
        // it, it's a tuple
        let mut seen_comma = false;
        elements.push(first_elm);
        while !self.at(Kind::Eof) && !self.at(Kind::RightParen) {
            self.expect(Kind::Comma)?;
            seen_comma = true;
            if self.at(Kind::RightParen) {
                break;
            }
            let expr = self.parse_starred_item()?;
            elements.push(expr);
        }
        if elements.len() == 1 && !seen_comma {
            self.bump(Kind::RightParen);
            let expr = elements.pop().unwrap();
            if let Expression::Name(name) = expr {
                return Ok(Expression::Name(Box::new(Name {
                    node: name.node,
                    id: name.id,
                    parenthesized: true,
                })));
            } else {
                return Ok(expr);
            }
        }
        self.expect(Kind::RightParen)?;
        Ok(Expression::Tuple(Box::new(Tuple {
            node: self.finish_node(node),
            elements,
        })))
    }

    // https://docs.python.org/3/reference/expressions.html#slicings
    // Closing will be consumed by this function