Method field_initializer_list

cel/src/parser/parser.rs:250–297

(
        &mut self,
        ctx: &Field_initializer_listContext<'_>,
    )

    }

    fn field_initializer_list(
        &mut self,
        ctx: &Field_initializer_listContext<'_>,
    ) -> Vec<IdedEntryExpr> {
        let mut fields = Vec::with_capacity(ctx.fields.len());
        for (i, field) in ctx.fields.iter().enumerate() {
            if i >= ctx.cols.len() || i >= ctx.values.len() {
                return vec![];
            }
            let id = self.helper.next_id(&ctx.cols[i]);

            match field.escapeIdent() {
                None => {
                    self.report_error::<ParseError, _>(
                        field.start().deref(),
                        None,
                        "unsupported ident type",
                    );
                    continue;
                }
                Some(ident) => {
                    let field_name = ident.get_text().to_string();
                    let value = self.visit(ctx.values[i].as_ref());
                    let is_optional = match (&field.opt, self.enable_optional_syntax) {
                        (Some(opt), false) => {
                            self.report_error::<ParseError, _>(
                                opt.as_ref(),
                                None,
                                "unsupported syntax '?'",
                            );
                            continue;
                        }
                        (Some(_), true) => true,
                        (None, _) => false,
                    };
                    fields.push(IdedEntryExpr {
                        id,
                        expr: EntryExpr::StructField(StructFieldExpr {
                            field: field_name,
                            value,
                            optional: is_optional,
                        }),
                    });
                }
            }
        }
        fields
    }

    fn map_initializer_list(&mut self, ctx: &MapInitializerListContextAll) -> Vec<IdedEntryExpr> {
        if ctx.keys.is_empty() {