Don't execute an inline expression that is being displayed

[gordonwoodhull]

Wrapping executable code in a longer fence is how an author writes about it — a {r} cell inside a ````markdown block is shown to the reader rather than run. That held for cells and not for inline expressions. In a document with any live R cell, this:

````markdown
Inline: `r v`
````

rendered as Inline: EVALUATED. The reader got the value where the author had written the example, and there was no way to show anyone what an inline expression looks like.

Inline expressions are found by scanning text, not by walking the AST. knitr's all_patterns$md$inline.code and q2's own resolve_inline_r_expressions both run over the whole serialized document, and neither tells a fenced code block from prose. The nested-cell mask already closed that gap for fence openers — it rewrites {r} to {.r q2-nested-executable} before the engine sees the document and restores it afterwards — but it matched whole opener lines, so an expression sitting mid-line went straight through.

mask now rewrites inline expression markers alongside openers, inserting its marker directly after the opening backtick; unmask deletes it again.

What the engine actually receives

For a document with a live cell, a markdown block, and a r block, the masked intermediate looks like this:

---
title: Displayed inline
engine: knitr
---

```{r}
#| echo: false
v <- "EVALUATED"
```

```markdown
Inline: `q2-nested-executable r v`
```

```markdown
Inline: `q2-nested-executable {r} v`
```

```r
Inline: `r v`
```

The live cell at the top is untouched — it is a real cell, not a display block. The two markdown blocks carry the marker. The r block does not, which is the scope decision below.

Running that through resolve_inline_r_expressions, the pass that actually wraps expressions for knitr, shows why the rewrite is the right one:

```markdown
Inline: `q2-nested-executable r v`     ← declined
```

```r
Inline: `r .QuartoInlineRender(v)`     ← claimed, and this one executes
```

The scanner needs a backtick immediately followed by r and a separator. The marker breaks that adjacency and nothing else about the author's text moves.

Both rewrites in one block, including through a blockquote — which only unmask ever sees, since mask works on a CodeBlock's text after the reader has stripped the > :

````markdown
Set it up:

```{.r q2-nested-executable}
#| echo: false
v <- 1
```

Then write `q2-nested-executable r v` or `q2-nested-executable {r} v` in prose.
````

> ```markdown
> Quoted: `q2-nested-executable r v`
> ```

Note the two forms differ. The opener rewrite has to neutralize the info string, so it becomes {.r q2-nested-executable} — the leading . is what stops the chunk scanner. The inline rewrite only prefixes, leaving {r} and r literally intact. Because it only ever inserts a fixed string, the restore is byte-exact by construction — which reconcile depends on, since a byte of drift makes it treat the display block as changed, replace it, and attribute the author's example to knitr's intermediate file.

Coverage

Both spellings: knitr's native `r x` and the cross-engine `{lang} x`. The brace form matches any language rather than only r, mirroring the opener mask's language class, so {python} is covered the day it starts evaluating. The separator class is the union of knitr's [ #] and q2's [ \t] — the mask has to be a superset of every scanner that could claim the expression, or it leaves a hole.

The display-class predicate is deliberately unchanged: a display block is one whose info string is empty or markdown. An author who writes ````r to get syntax highlighting on the example still gets no protection, for inline expressions or for nested cells. That matches Quarto 1, which executes there too, and widening it is a change to the cell escape as much as to this one — filed separately as bd-tiidc899.

The brace spelling is not evaluated by q2 yet (bd-inline-r-brace-spelling-not-evaluated-lk9s3iwe), so that half of this is latent today. It is handled here rather than deferred because the mask and the evaluator are independent seams, and the one deciding not to execute should not wait on the one deciding how.

Tests

16 added, in their own tier so the frozen T1–T24 seam spec is untouched. Two run through the real render path with real knitr; the rest exercise mask/unmask directly — round-trip byte-exactness across nine inline shapes, a live cell's backtick-quoted R name left alone, the fence-backtick guard, and a row binding the masked text to resolve_inline_r_expressions itself, so the rewrite is proved against the production scanner rather than against its own regex.

Closes bd-0gwekaem.

[posit-snyk-bot]

✅ Snyk checks have passed. No issues have been found so far.

Status	Scan Engine	Critical	High	Medium	Low	Total (0)
✅	Open Source Security	0	0	0	0	0 issues
✅	Licenses	0	0	0	0	0 issues

💻 Catch issues earlier using the plugins for VS Code, JetBrains IDEs, Visual Studio, and Eclipse.