parser-development
This skill teaches you how to add parsing support for new languages to Biome by authoring grammars in ungrammar format, implementing lexers and token sources, and writing parse rules with robust error recovery. It covers list parsing patterns, conditional syntax handling, and testing workflows for the Biome codebase.
parser-development guides implementing parsers with error recovery for new languages in Biome using ungrammar grammar definitions.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-27
parser-development guides implementing parsers with error recovery for new languages in Biome using ungrammar grammar definitions. This skill teaches you how to add parsing support for new languages to Biome by authoring grammars in ungrammar format, implementing lexers and token sources, and writing parse rules with robust error recovery. It covers list parsing patterns, conditional syntax handling, and testing workflows for the Biome codebase.
Use it when
- parser-development covers error recovery strategies in Biome parsers through techniques like bogus node handling, checkpoint backtracking.
- parser-development shows how to create ungram grammar definitions by writing syntax rules in ungrammar format.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Similar skills
Install
biomejs/biome/parser-development · repository language: Rust
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How do I implement a parser for a new language in Biome?
parser-development teaches you to implement a parser for a new language in Biome by starting with an ungram grammar definition, building a lexer and token source, then writing parse rules with error recovery. The process involves defining syntax rules in ungrammar format, implementing token handling, and adding bogus node patterns to gracefully recover from parse errors.
What are error recovery strategies in Biome parsers?
parser-development covers error recovery strategies in Biome parsers through techniques like bogus node handling, checkpoint backtracking, and recovery token sets. These strategies allow the parser to continue parsing after encountering syntax errors, maintaining a usable syntax tree and enabling better error diagnostics without stopping at the first mistake.
How do you create ungram grammar definitions and generate parser skeletons?
parser-development shows how to create ungram grammar definitions by writing syntax rules in ungrammar format, then generating parser skeletons from those definitions. The ungrammar format provides a declarative way to specify language syntax, which can be used to scaffold the initial parser structure before implementing the actual parsing logic.
How do I build a lexer and token source for Biome parsing?
parser-development teaches lexer and token source construction for Biome by covering buffered lexer implementation and token handling patterns. You'll learn to create token sources that feed the parser, manage token buffering for lookahead, and integrate lexical analysis with the parser's error recovery mechanisms.
What patterns does parser-development cover for parsing lists with separators?
parser-development covers list parsing patterns including separated list handling, which is essential for parsing comma-separated arguments, array elements, and similar constructs. These patterns integrate with error recovery to handle missing or malformed separators gracefully while maintaining parser resilience.
How do you test and validate Biome parser implementations?
parser-development includes testing workflows for validating parser implementations by checking recovery patterns, verifying syntax tree structure, and ensuring error diagnostics are accurate. The skill covers debugging techniques specific to the Biome codebase and validation strategies for confirming parsers handle both valid and malformed input correctly.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Purpose
Use this skill when creating or modifying Biome's parsers. Covers grammar authoring with ungrammar, lexer implementation, error recovery strategies, and list parsing patterns.
Prerequisites
- Install required tools:
just install-tools - Understand the language syntax you're implementing
- Read
crates/biome_parser/CONTRIBUTING.mdfor detailed concepts
Common Workflows
Create Grammar for New Language
Create a .ungram file in xtask/codegen/ (e.g., html.ungram):
``` // html.ungram // Legend: // Name = -- non-terminal definition // 'ident' -- token (terminal) // A B -- sequence // A | B -- alternation // A* -- zero or more
(truncated - see the full file via the links below)
File tree — 1 file
.claude/skills/parser-development/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Implement a parser for a new language in Biome with grammar and error recovery”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
This skill covers seven Rust design patterns applied to RTK's CLI filter architecture, from type-safe wrappers and configuration builders to stateful parsers and resource management. Each pattern includes practical examples showing when to use it, when to skip it, and how it fits RTK's single-threaded, zero-overhead design philosophy.
This skill guides you through building new lint rules and assist actions for Biome. It covers rule scaffolding across multiple languages, implementation patterns with semantic analysis, code action setup, and the three-pillar diagnostic framework required for all rules. Use it when adding custom rules like noVar or useConst to Biome's codebase.
This skill teaches you how to work with Biome's type inference engine and module graph architecture for building type-aware lint rules. It covers the three-phase type resolution process—local inference, module-level resolution, and cross-module full inference—plus the TypeReference pattern that prevents stale data in an IDE environment. Use it when implementing new type-aware rules, understanding type resolution, or working on type inference features.
Build effective error messages, warnings, and hints for Biome lint rules using the Diagnostic trait and advice system. Learn to craft messages that explain what went wrong, why it matters, and how to fix it—with rich markup, code frames, and actionable guidance.
Learn to implement and modify Biome's formatters using its trait-based IR system. This skill covers generating formatter boilerplate, writing FormatNodeRule implementations, managing comments in formatted output, and validating your work against Prettier using snapshot tests and idempotency checks.
testing-codegen guides you through snapshot testing with insta and code generation for the Biome codebase. It covers running tests for specific crates, fast iteration with quick-test workflows, and safely managing snapshots—including pruning orphaned files and reviewing changes interactively. Use this skill when testing lint rules, inspecting AST structure, or regenerating parser and analyzer code.
More skills biome-developer (Apache-2.0)