Summary

Adds foundational support for "hybrid tags" — tags that can function in both self-closing form ({% section 'name' %}) and block form ({% section 'name' %}...{% endsection %}).

Changes

• Liquid::HybridTag — New base class extending Liquid::Block that supports two rendering modes:

  • Self-closing: tag has no body, renders via render_self_closing_to_output_buffer
  • Block form: tag captures sibling nodes via end-tag-triggered reparenting, renders via render_block_form_to_output_buffer
  • Subclasses register which end tag triggers reparenting (e.g., endsection)

• BlockBody#parse reparenting — When the parser encounters an end tag for a registered hybrid tag (e.g., {% endsection %}), it looks back through @nodelist, finds the matching hybrid tag, splices intervening nodes into its body, and flips it to block form. No tokenizer changes needed.

• Parse-time nesting prevention — Hybrid tags of the same type cannot be nested (raises SyntaxError). Sequential hybrid tags and different types are allowed.

• @blank recomputation — After reparenting, the parent BlockBody recomputes its @blank flag based on remaining nodes.

Design

Uses end-tag-triggered reparenting rather than tokenizer lookahead. When BlockBody#parse encounters {% endsection %}:

1. Walks @nodelist backwards to find the matching section tag
2. Splices all nodes between the hybrid tag and end tag
3. Calls reparent_as_block(spliced_nodes) on the hybrid tag
4. Recomputes @blank for the parent body

This approach requires zero tokenizer modifications.

Why nesting is prohibited for hybrid tags

Hybrid tags support an optional end tag — the same tag can appear in self-closing form ({% render 'a' %}) or block form ({% render 'a' %}...{% endrender %}). This creates a fundamental parser ambiguity when nesting is allowed, because the parser cannot determine which opening tag an end tag belongs to.

Consider this template:

{% render 'a' %}
{% render 'b' %}
{% endrender %}
{% render 'c' %}
{% endrender %}

Without indentation (which Liquid does not use for parsing), this is ambiguous. It could mean any of:

1. a contains b and c — a contains b (not self closing) and c (self closing)
2. All three are sequential — a is self-closing, b is a block, c is a block
3. a contains b, then c is sequential — a contains b (selfclosing),c is block

More concretely:

{% render 'header' %}
{% render 'main' %}{% endrender %}
{% render 'footer' %}{% endrender %}

vs.

{% render 'header' %}
  {% render 'nav' %}
{% endrender %}
{% render 'footer' %}{% endrender %}

These are visually different but structurally identical to the parser — whitespace/indentation is not significant in Liquid.

The root cause: when you can omit end$tag, the parser cannot tell whether an opening tag is self-closing or is the start of a block that hasn't been closed yet. With mandatory end tags (like {% block %}...{% endblock %}), there is no ambiguity — every opening tag must have a matching close.

This is why Liquid::Block subclasses (like the block tag) can nest — their end tags are mandatory. HybridTag's optional end tag makes nesting fundamentally ambiguous, so we prevent it at parse time.

Test plan

• Unit tests for HybridTag self-closing form (no end tag → stays self-closing)
• Unit tests for HybridTag block form (end tag → reparents siblings)
• @blank recomputation after reparenting
• Nesting prevention (same-type hybrid tags raise SyntaxError)
• Sequential hybrid tags (allowed)
• Mixed self-closing + block in same template
• Full existing Liquid test suite passes — zero regressions

🤖 Generated with Claude Code