Commit 36082b2

Build the binary wherever an exit code matters: `go run` turns any non-zero exit into its own `1`, so under it a check that could not be completed looks the same as one that found something missing.

Switches the current working tree to `backport-batch/<line>-<yyyymmdd>`, created at `origin/<line>`, and picks onto it one original at a time, in the order they merged into `main`, as one unit each on the branch's first-parent line. A pull request merged into `main` with a merge commit `M` goes on as its own commits, `git rev-list --reverse --topo-order --no-merges M^1..M^2`, each picked with `git cherry-pick -x --signoff`, so each keeps its author, message and sign-offs and gains the `(cherry picked from commit …)` line; the merges that brought `main` into its branch are left out, since `main` already has what they brought. A merge commit then joins the picks to the batch: its first parent is the batch before the original, its second the last pick, and its message is `M`'s with a paragraph of its own, `Backported-from: M`. A pull request squash-merged into `main` goes on as one pick. When any commit of an original conflicts, the pick is aborted, the branch goes back to where it was before that original, and the original is recorded with the commit that failed and its files; the run goes on with the next one. A commit the branch already carries is skipped as empty, and an original none of whose commits changes anything is reported as carried. The tree has to be clean. A local branch of that name is reset to where the run starts; when that drops commits only it has, the run first prints its tip and the `git branch` command that restores them, and so does `--defer`. Signing follows your git configuration; hooks are off for the picks and the merge, so each commit carries its message as git writes it.

if err != nil {

return nil, err

}

for name, blob := range paths {

file := filepath.Join(dir, filepath.FromSlash(name))

if err := os.MkdirAll(filepath.Dir(file), 0o700); err != nil {

}

// The scheduled job has half an hour for every line; this says where it

// goes.

if drops != nil {

return a.redrop(b, drops, reason, *undropArg != "", *push)

}

continue

}

}

omitted, diag, err := b.omittedEffects(v, base, head)

v.addDiag(diag...)

return omitted, err

}

body, left := r.body(template)

p.body = body

skipped := 0

for _, items := range r.skipped {

skipped += len(items)

}

for _, rule := range left {

for _, v := range r.skipped[rule] {

}

}

for _, p := range r.waiting {

}

branch, head, len(r.onBranch), len(r.deferred)+len(r.held), len(r.waiting), skipped, p.title, doc.ID)

if !push {

return 0

// Picking nothing is not a failure of the run; check still reports

// whatever the line lacks. Merged and closed batches are never

// written, so there is nowhere to keep what the run found.

return 0

}

if err := a.publish(b, p, rebuilt); err != nil {

func (a *app) warnReset(branch, start string) error {

old, err := lookup("refs/heads/" + branch)

if err != nil || old == "" || old == start {

return err

if err != nil || kept {

return err

}

return nil

}

}

}

if pushed != p.head {

if _, err := git(pushArgs(p.branch, p.head, lease)...); err != nil {

return err

}

if err != nil {

return err

}

if b.pr == nil {

n, url, err := a.gh.createPull(b.line.branch(), p.branch, p.title, name)

if err != nil {

return err

}

if err := a.postReport(n, p.report); err != nil {

return fmt.Errorf("posting report %.12s on #%d: %w; the body keeps it, and the next run --push posts it", p.report.doc.ID, n, err)

}

if err := a.gh.editPull(b.pr.Number, p.title, name); err != nil {

return err

}

return nil

}

if err != nil {

return err

}

if err := a.stillOpen(c.PR); err != nil {

return err

}

if err := a.deleteBranch(l, c); err != nil {

return err

}

return nil

}

case h != c.Head:

return movedBranch(c, h)

}

if _, err := git(deleteArgs(c.Branch, c.Head)...); err != nil {

return fmt.Errorf("deleting %s, left by the close of #%d: %w; backport-batch run --line %s --push deletes it", c.Branch, c.PR, err, l.branch())

}

if err := a.deleteBranch(b.line, c); err != nil {

return false, a.fail(err)

}

return false, a.finished(c, changing)

}

case d.kind == outcomeWarning:

a.warn("%s", d.text)

case d.kind == outcomeNote:

}

}

if len(missing)+len(failing) == 0 {

if *cut {

} else {

}

return 0

}