Mixin default argument change in Pug affecting template inheritance

Short answer to all three questions

No — omitting a default argument does not make the enclosing if render its alternative branch, because a mixin call never participates in the condition at all. No — the parent's conditional does not "take precedence" over the mixin's resolved value, because the two evaluations are independent. And a default of false versus no default only differs inside the mixin body, not in any surrounding unless block.

The core misconception

Pug mixins are not functions that return a value to the template engine. A mixin call produces HTML output as a side effect; it yields nothing that an if or unless expression can observe. So this structure:

if someCondition
  +card(title)
else
  p fallback

renders fallback whenever someCondition is falsy — regardless of what defaults the card mixin declares. The mixin's parameter resolution happens only after the condition has already chosen the branch containing the call.

What defaults actually change

Default arguments are evaluated at the call site, at invocation time. Inside the mixin body:

• mixin card(title = false) called as +card() gives title === false.
• mixin card(title) called as +card() gives title === undefined.

Both are falsy, so an if title inside the mixin behaves identically in either case. The difference only matters if the mixin body distinguishes them (e.g., title === undefined checks, or passing the value onward). This behavior is stable across Pug 2.x and 3.x for ordinary falsy handling; only very old Jade-era releases had edge cases worth re-testing if you maintain legacy templates.

How inheritance fits in

extends/block changes which content gets emitted, not how expressions are scoped. When a child template overrides a block, the child's block content replaces the parent's entirely — the parent's conditional inside that block never runs. Conversely, a conditional in the parent outside the overridden block still runs with the parent's own expression, unaffected by anything the child's mixin call resolved. There is no precedence contest because there is no shared evaluation:

1. The parent template's if/unless evaluates its own expression.
2. Block resolution picks parent or child content.
3. Mixin defaults resolve at the mixin call site, inside whichever content won.

Mixin parameters are local to the mixin body; they do not leak into the calling template's scope, so a conditional cannot reference "mixin-injected data" unless you explicitly assign a variable before the call.

Verify it yourself

A five-minute test settles any version doubt:

//- layout.pug
block content
  if showCard
    +card()
  else
    p no card

//- mixin
mixin card(title = false)
  if title
    h2= title
  else
    h2 default branch

Render with a child that sets showCard true/false and calls the mixin with and without arguments. Check the HTML: the outer branch follows showCard only; the inner branch follows the parameter. Repeat under your installed Pug version (npm ls pug) — if you are pinned to a pre-2.0 Jade release, treat the undefined/null edge behavior as needing review.

One caveat

If your real template assigns a variable from data the mixin also uses (e.g., - var t = title before the call), then the conditional and the mixin share that variable, and it can look like the mixin "influences" the condition. If that's your situation, the variable's own definition — not the mixin default — is what to debug.