fn write_literal()

in src/bindgen/language_backend/clike.rs [840:953]
106 lines of code
18 McCabe index (conditional complexity)

    fn write_literal<W: Write>(&mut self, out: &mut SourceWriter<W>, l: &Literal) {
        match l {
            Literal::Expr(v) => write!(out, "{}", v),
            Literal::Path {
                ref associated_to,
                ref name,
            } => {
                if let Some((ref path, ref export_name)) = associated_to {
                    if let Some(known) = to_known_assoc_constant(path, name) {
                        return write!(out, "{}", known);
                    }
                    let path_separator = if self.config.language == Language::C {
                        "_"
                    } else if self.config.structure.associated_constants_in_body {
                        "::"
                    } else {
                        "_"
                    };
                    write!(out, "{}{}", export_name, path_separator)
                }
                write!(out, "{}", name)
            }
            Literal::FieldAccess {
                ref base,
                ref field,
            } => {
                write!(out, "(");
                self.write_literal(out, base);
                write!(out, ").{}", field);
            }
            Literal::PostfixUnaryOp { op, ref value } => {
                write!(out, "{}", op);
                self.write_literal(out, value);
            }
            Literal::BinOp {
                ref left,
                op,
                ref right,
            } => {
                write!(out, "(");
                self.write_literal(out, left);
                write!(out, " {} ", op);
                self.write_literal(out, right);
                write!(out, ")");
            }
            Literal::Cast { ref ty, ref value } => {
                out.write("(");
                self.write_type(out, ty);
                out.write(")");
                self.write_literal(out, value);
            }
            Literal::Struct {
                export_name,
                fields,
                path,
            } => {
                let allow_constexpr = self.config.constant.allow_constexpr && l.can_be_constexpr();
                let is_constexpr = self.config.language == Language::Cxx
                    && (self.config.constant.allow_static_const || allow_constexpr);
                if self.config.language == Language::C {
                    write!(out, "({})", export_name);
                } else {
                    write!(out, "{}", export_name);
                }

                write!(out, "{{");
                if is_constexpr {
                    out.push_tab();
                } else {
                    write!(out, " ");
                }
                // In C++, same order as defined is required.
                let ordered_fields = out.bindings().struct_field_names(path);
                for (i, ordered_key) in ordered_fields.iter().enumerate() {
                    if let Some(lit) = fields.get(ordered_key) {
                        if is_constexpr {
                            out.new_line();

                            // TODO: Some C++ versions (c++20?) now support designated
                            // initializers, consider generating them.
                            write!(out, "/* .{} = */ ", ordered_key);
                            self.write_literal(out, lit);
                            if i + 1 != ordered_fields.len() {
                                write!(out, ",");
                                if !is_constexpr {
                                    write!(out, " ");
                                }
                            }
                        } else {
                            if i > 0 {
                                write!(out, ", ");
                            }

                            if self.config.language == Language::Cxx {
                                // TODO: Some C++ versions (c++20?) now support designated
                                // initializers, consider generating them.
                                write!(out, "/* .{} = */ ", ordered_key);
                            } else {
                                write!(out, ".{} = ", ordered_key);
                            }
                            self.write_literal(out, lit);
                        }
                    }
                }
                if is_constexpr {
                    out.pop_tab();
                    out.new_line();
                } else {
                    write!(out, " ");
                }
                write!(out, "}}");
            }
        }
    }