现代编译器解析器技术问询：TypeScript、C#、Rust采用何种解析器？

Great question—modern compilers have moved past strict LL(k)/LR(k) in a lot of cases, so let’s break down each language you’re curious about:

TypeScript #

TypeScript uses a hand-written recursive descent parser—this is a flavor of LL parsing, specifically leaning on LL(1) with custom lookahead logic to handle edge cases. The parser lives right in tsc, the TypeScript compiler, and it’s built to tackle the language’s trickier features: think type annotations, generics, and module syntax. Pure LL(1) can’t handle all of TypeScript’s ambiguities, so the team added custom resolution logic to make it work smoothly.

C# #

For C#, the Roslyn compiler (which powers csc and all modern C# tooling) also uses a hand-written recursive descent parser. While it has LL-like characteristics, it’s far from a strict LL(k) implementation. It needs extra smarts to resolve ambiguous cases—like distinguishing between an expression statement and a declaration, which can’t be done with fixed k-lookahead. Error tolerance was a huge priority here too, since Roslyn is built to support real-time IDE features like code completion and refactoring.

Rust #

Rust’s rustc takes a hybrid approach: most of its parsing is done via hand-written recursive descent, but it uses a GLR (Generalized LR) parser for specific parts of the grammar. GLR comes in handy for handling macro expansions and certain ambiguous syntax constructs that recursive descent alone can’t tackle cleanly. This mix lets Rust support its complex pattern matching, trait bounds, and other unique syntax while keeping parsing performance snappy.

Aggregated Resources for Compiler Parsers #

• There are community-curated lists that track parsing strategies across hundreds of languages. These are often maintained in developer wikis or GitHub repositories, where you can look up specific languages or compare parsing techniques side-by-side.
• Since all the compilers you mentioned are open-source, diving directly into their source code is a great way to learn—each project has documentation or inline comments explaining their parser design choices.
• Many compiler teams publish blog posts breaking down their parsing decisions. For example, the TypeScript team has written about their parser’s evolution, the Roslyn team has covered how their parser supports IDE features, and the Rust team has discussed their hybrid approach in technical deep dives.

内容的提问来源于stack exchange，提问作者nikeee