Method parse_match_pattern_mapping

crates/ruff_python_parser/src/parser/pattern.rs:183–265

Parses a mapping pattern. # Panics If the parser isn't positioned at a `{` token. See:

(&mut self)

    ///
    /// See: <https://docs.python.org/3/reference/compound_stmts.html#mapping-patterns>
    fn parse_match_pattern_mapping(&mut self) -> ast::PatternMatchMapping {
        let start = self.node_start();
        self.bump(TokenKind::Lbrace);

        let mut keys = PatternKeys::new();
        let mut patterns = Patterns::new();
        let mut rest = None;

        self.parse_comma_separated_list(RecoveryContextKind::MatchPatternMapping, |parser| {
            let mapping_item_start = parser.node_start();

            if parser.eat(TokenKind::DoubleStar) {
                let identifier = parser.parse_match_pattern_target();
                if rest.is_some() {
                    parser.add_error(
                        ParseErrorType::OtherError(
                            "Only one double star pattern is allowed".to_string(),
                        ),
                        parser.node_range(mapping_item_start),
                    );
                }
                // TODO(dhruvmanila): It's not possible to retain multiple double starred
                // patterns because of the way the mapping node is represented in the grammar.
                // The last value will always win. Update the AST representation.
                // See: https://github.com/astral-sh/ruff/pull/10477#discussion_r1535143536
                rest = Some(identifier);
            } else {
                let key = match parser.parse_match_pattern_lhs(AllowStarPattern::No) {
                    Pattern::MatchValue(ast::PatternMatchValue { value, .. }) => *value,
                    Pattern::MatchSingleton(ast::PatternMatchSingleton {
                        value,
                        range,
                        node_index,
                    }) => match value {
                        Singleton::None => {
                            Expr::NoneLiteral(ast::ExprNoneLiteral { range, node_index })
                        }
                        Singleton::True => Expr::BooleanLiteral(ast::ExprBooleanLiteral {
                            value: true,
                            range,
                            node_index,
                        }),
                        Singleton::False => Expr::BooleanLiteral(ast::ExprBooleanLiteral {
                            value: false,
                            range,
                            node_index,
                        }),
                    },
                    pattern => {
                        parser.add_error(
                            ParseErrorType::OtherError("Invalid mapping pattern key".to_string()),
                            &pattern,
                        );
                        recovery::pattern_to_expr(pattern)
                    }
                };
                keys.push(key);