Rust: rest of #2614 — derive(Default), outside builder and outside writer calls link to a same-named project method #3252

pub struct Builder {
    on: bool,
}

impl Builder {
    pub fn new() -> Self {
        Builder { on: false }
    }

    pub fn enable(mut self) -> Self {
        self.on = true;
        self
    }

    pub fn build(self) -> bool {
        self.on
    }
}

pub struct GzBuilder {
    m: u32,
}

impl GzBuilder {
    pub fn new() -> Self {
        GzBuilder { m: 0 }
    }

    pub fn mtime(mut self, m: u32) -> Self {
        self.m = m;
        self
    }

    pub fn write(self, sink: Vec<u8>, level: u32) -> Encoder {
        Encoder { sink, level: level + self.m }
    }
}

pub struct Encoder {
    sink: Vec<u8>,
    level: u32,
}

impl Encoder {
    pub fn finish(self) -> Result<Sink, ()> {
        Ok(Sink { data: self.sink, level: self.level })
    }
}

pub struct Sink {
    data: Vec<u8>,
    level: u32,
}

impl Sink {
    pub fn flush(&mut self) -> Result<(), ()> {
        self.data.clear();
        Ok(())
    }
}

pub fn stdout() -> Sink {
    Sink { data: vec![], level: 0 }
}

use std::io::Write;

// 1. derive(Default) type called through its own path
#[derive(Default)]
pub struct Rules {
    n: u32,
}

pub struct Tokens {
    n: u32,
}

impl Default for Tokens {
    fn default() -> Self {
        Tokens { n: 1 }
    }
}

fn rules() -> Rules {
    Rules::default()
}

// 2. builder chain from an outside crate; the project has an associated fn `build` without self
pub struct Graph {
    n: u32,
}

impl Graph {
    pub fn build(n: u32) -> Graph {
        Graph { n }
    }
}

fn runtime() -> bool {
    ext::Builder::new().enable().build()
}

// the project implements io::Write for its own type
pub struct Log {
    buf: Vec<u8>,
}

impl Write for Log {
    fn write(&mut self, b: &[u8]) -> std::io::Result<usize> {
        self.buf.extend_from_slice(b);
        Ok(b.len())
    }

    fn flush(&mut self) -> std::io::Result<()> {
        Ok(())
    }
}

// control: std `OpenOptions::write` on one line and std `flush` — no false edge
fn open(p: &str) -> std::io::Result<std::fs::File> {
    std::fs::OpenOptions::new().write(true).create(true).open(p)
}

fn out() -> std::io::Result<()> {
    std::io::stdout().flush()
}

// 3. multi-line std builder chain inside a closure (`.write(true)` is OpenOptions::write)
fn take_lock(p: &str) -> std::io::Result<std::fs::File> {
    let open = move || -> std::io::Result<std::fs::File> {
        std::fs::OpenOptions::new()
            .create(true)
            .truncate(false)
            .write(true)
            .open(p)
    };
    open()
}

// 4. builder method `write` of an outside crate and `flush` on what its chain returns
fn write_single(data: Vec<u8>) -> Result<(), ()> {
    let enc = ext::GzBuilder::new().mtime(0).write(data, 6);
    enc.finish()?.flush()?;
    Ok(())
}

// 5. local of an outside type, then `flush`
fn to_stdout() -> Result<(), ()> {
    let mut stdout = ext::stdout();
    stdout.flush()
}

fn main() {
    let r = rules();
    let t = Tokens::default();
    let g = Graph::build(r.n + t.n);
    let mut l = Log { buf: vec![] };
    let _ = l.write(b"x");
    let _ = l.flush();
    let _ = (runtime(), open("/dev/null"), out(), g.n, take_lock("/dev/null").is_ok(), write_single(vec![]), to_stdout());
}