К основному содержанию
скилл CX Codex

compiler-frontend — скилл для Claude Code: разбор и установка

Скилл compiler-frontend для Claude Code помогает проектировать лексер, парсер и проверку типов, а затем генерировать LLVM IR. Описывает фронтенд компилятора, интерпретатора или собственного языка.

MIT 390 установок ★ 298 обновлён 2026-06-27

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add mohitmishra786/low-level-dev-skills --skill compiler-frontend -a claude-code
Открыть на GitHub

Что делает compiler-frontend

Скилл ведёт по этапам компиляторного фронтенда: от токенизации исходного кода к AST, проверке типов и генерации LLVM IR. Для выражений рассматривается Pratt-парсер, для операторов — рекурсивный спуск; таблица символов устроена как цепочка областей видимости с поиском в родительской области.

Есть примеры на C для лексера, узлов AST, таблицы символов и генерации IR через LLVM C API. Разобраны восстановление после ошибок и базовая проверка типов; для полного вывода типов Hindley–Milner нужно объединять типовые ограничения. В Rust названы inkwell и llvm-sys.

Для генерации IR проекту понадобится LLVM: в примерах используются его C API и проверка модуля.

Какие задачи решает

  • разбить исходный код на токены
  • разобрать выражения с учётом приоритета операторов
  • связать переменные с областями видимости
  • проверить типы выражений и найти несовпадения
  • сгенерировать и проверить LLVM IR

Примеры запросов агенту

  • Помоги написать лексер и Pratt-парсер для моего языка.
  • Спроектируй AST и таблицу символов с вложенными областями видимости.
  • Покажи, как проверить типы AST и сгенерировать LLVM IR на Rust.

Как установить compiler-frontend

1Через Skills CLI (Vercel)

npx skills add mohitmishra786/low-level-dev-skills --skill compiler-frontend -a claude-code

2Вручную: положить файлы

~/.claude/skills/compiler-frontend/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/compiler-frontend/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о compiler-frontend

Как установить compiler-frontend в Claude Code?

Выполните npx skills add mohitmishra786/low-level-dev-skills --skill compiler-frontend -a claude-code. Файл скилла появится по пути ~/.claude/skills/compiler-frontend/SKILL.md.

Что делает compiler-frontend?

Он помогает разрабатывать лексер, парсер, AST, таблицу символов и проверку типов. Также разбирает восстановление после ошибок и генерацию LLVM IR.

Как скилл предлагает генерировать LLVM IR в Rust?

В качестве Rust-библиотек названы inkwell и llvm-sys; в примерах на C используется LLVM C API.

Исходный текст

SKILL.md · MIT
---
name: compiler-frontend
description: Compiler frontend skill for lexing, parsing, and type checking. Use when building a lexer/parser, designing AST nodes, implementing symbol tables, type checking, error recovery, or emitting LLVM IR. Activates on queries about lexer, Pratt parser, recursive descent, AST, symbol table, Hindley-Milner, or llvm-sys.
---

# Compiler Frontend

## Purpose

Guide agents through building a compiler frontend: lexers (hand-written DFA vs flex), Pratt parsing for expressions, recursive-descent for statements, AST design, symbol tables with scoped hash maps, type checking basics, error recovery strategies, and LLVM IR generation via the C API or `llvm-sys`.

## When to Use

- Implementing a new programming language or DSL
- Adding expression parsing to an interpreter or config language
- Designing AST node hierarchies in C or Rust
- Building scoped symbol tables for variables and functions
- Implementing basic type inference or checking
- Emitting LLVM IR from a typed AST

## Workflow

### 1. Pipeline overview

```
Source → Lexer (tokens) → Parser (AST) → Type checker → IR generator → LLVM IR
```

### 2. Lexer — hand-written DFA

```c
typedef enum {
    TOK_EOF, TOK_INT, TOK_IDENT, TOK_PLUS, TOK_MINUS,
    TOK_LPAREN, TOK_RPAREN, TOK_SEMI, TOK_EQ,
} TokenKind;

typedef struct {
    TokenKind kind;
    const char *start;
    int length;
    int64_t int_val;
} Token;

typedef struct {
    const char *src;
    int pos;
    int line;
} Lexer;

static void skip_whitespace(Lexer *l) {
    while (l->src[l->pos] == ' ' || l->src[l->pos] == '\n') l->pos++;
}

Token lexer_next(Lexer *l) {
    skip_whitespace(l);
    const char *start = &l->src[l->pos];

    if (isdigit(l->src[l->pos])) {
        int64_t val = 0;
        while (isdigit(l->src[l->pos]))
            val = val * 10 + (l->src[l->pos++] - '0');
        return (Token){ TOK_INT, start, l->pos - (start - l->src), val };
    }
    if (isalpha(l->src[l->pos])) {
        while (isalnum(l->src[l->pos])) l->pos++;
        return (Token){ TOK_IDENT, start, l->pos - (start - l->src), 0 };
    }
    char c = l->src[l->pos++];
    switch (c) {
        case '+': return (Token){ TOK_PLUS, start, 1, 0 };
        case '(': return (Token){ TOK_LPAREN, start, 1, 0 };
        case ')': return (Token){ TOK_RPAREN, start, 1, 0 };
        case ';': return (Token){ TOK_SEMI, start, 1, 0 };
        default:  return (Token){ TOK_EOF, start, 0, 0 };
    }
}
```

```bash
# flex alternative
flex lexer.l && gcc -o lexer lexer.tab.c -lfl
```

### 3. Pratt parser for expressions

```c
typedef enum { AST_INT, AST_BINOP, AST_VAR } AstKind;

typedef struct AstNode {
    AstKind kind;
    union {
        int64_t int_val;
        struct { int op; struct AstNode *lhs, *rhs; } binop;
        char *name;
    };
} AstNode;

// Binding powers: higher = tighter precedence
enum { BP_NONE = 0, BP_SUM = 10, BP_PRODUCT = 20 };

AstNode *parse_expression(Parser *p, int min_bp) {
    AstNode *left = parse_prefix(p);
    for (;;) {
        int lbp, rbp;
        if (!infix_binding_power(p->cur.kind, &lbp, &rbp) || lbp < min_bp)
            break;
        advance(p);
        AstNode *right = parse_expression(p, rbp);
        left = make_binop(p->cur.kind, left, right);
    }
    return left;
}
```

Pratt handles operator precedence cleanly without massive grammar tables.

### 4. Recursive descent for statements

```c
AstNode *parse_statement(Parser *p) {
    if (match(p, TOK_IDENT) && peek(p) == TOK_EQ) {
        char *name = p->prev.text;
        advance(p);  // =
        AstNode *expr = parse_expression(p, BP_NONE);
        expect(p, TOK_SEMI);
        return make_assign(name, expr);
    }
    if (match(p, TOK_RETURN)) {
        AstNode *expr = parse_expression(p, BP_NONE);
        expect(p, TOK_SEMI);
        return make_return(expr);
    }
    return parse_expression_statement(p);
}
```

### 5. AST and symbol table

```c
typedef struct Symbol {
    char *name;
    Type *type;
    LLVMValueRef llvm_val;  // after codegen
    struct Symbol *next;
} Symbol;

typedef struct Scope {
    Symbol *symbols;       // hash map bucket chain
    struct Scope *parent;
} Scope;

Symbol *scope_lookup(Scope *s, const char *name) {
    for (Scope *cur = s; cur; cur = cur->parent) {
        for (Symbol *sym = cur->symbols; sym; sym = sym->next)
            if (strcmp(sym->name, name) == 0)
                return sym;
    }
    return NULL;
}

void scope_define(Scope *s, const char *name, Type *type) {
    Symbol *sym = malloc(sizeof(Symbol));
    sym->name = strdup(name);
    sym->type = type;
    sym->next = s->symbols;
    s->symbols = sym;
}
```

### 6. Type checker (basics)

```c
typedef enum { TY_INT, TY_BOOL, TY_FUNC, TY_VOID } TypeKind;

Type *check_expr(Scope *s, AstNode *node) {
    switch (node->kind) {
    case AST_INT: return type_int();
    case AST_VAR: {
        Symbol *sym = scope_lookup(s, node->name);
        if (!sym) error("undefined variable %s", node->name);
        return sym->type;
    }
    case AST_BINOP: {
        Type *lt = check_expr(s, node->binop.lhs);
        Type *rt = check_expr(s, node->binop.rhs);
        if (!type_equal(lt, rt))
            error("type mismatch in binary op");
        return lt;
    }
    }
    return type_void();
}
```

Hindley-Milner (full inference): assign type variables, unify on constraints — use for ML-like languages.

### 7. Error recovery

| Strategy | When |
|----------|------|
| Panic mode | Skip tokens until synchronizing token (`;`, `}`) |
| Synchronization sets | Define recovery tokens per nonterminal |
| Error productions | Grammar rules for common mistakes |
| Single-token insertion/deletion | IDE-friendly recovery |

```c
void synchronize(Parser *p) {
    advance(p);
    while (p->cur.kind != TOK_EOF) {
        if (p->prev.kind == TOK_SEMI) return;
        if (p->cur.kind == TOK_RETURN || p->cur.kind == TOK_IDENT) return;
        advance(p);
    }
}
```

### 8. LLVM IR generation

```c
#include <llvm-c/Core.h>
#include <llvm-c/ExecutionEngine.h>

LLVMModuleRef module;
LLVMBuilderRef builder;

LLVMValueRef codegen_expr(Scope *s, AstNode *node) {
    switch (node->kind) {
    case AST_INT:
        return LLVMConstInt(LLVMInt32Type(), node->int_val, 1);
    case AST_BINOP: {
        LLVMValueRef l = codegen_expr(s, node->binop.lhs);
        LLVMValueRef r = codegen_expr(s, node->binop.rhs);
        if (node->binop.op == TOK_PLUS)
            return LLVMBuildAdd(builder, l, r, "add");
        break;
    }
    case AST_VAR: {
        Symbol *sym = scope_lookup(s, node->name);
        return LLVMBuildLoad(builder, sym->llvm_val, node->name);
    }
    }
    return NULL;
}
```

```bash
# Dump IR
LLVMDumpModule(module);
# Verify
char *err = NULL;
LLVMVerifyModule(module, LLVMReturnStatusAction, &err);
```

Rust: use `inkwell` or `llvm-sys` crates for safer bindings.

## Common Problems

| Symptom | Cause | Fix |
|---------|-------|-----|
| Parser infinite loop | Missing advance on error | Audit all branches advance token |
| Wrong operator precedence | Incorrect binding powers | Table-test expressions |
| Duplicate symbol in scope | No shadowing check | Lookup parent only for read; define in current |
| LLVM verify fails | Type mismatch in IR | Check signedness, pointer levels |
| flex token clash | Overlapping patterns | Longest match; order rules |
| Error cascade | No synchronization | Implement panic mode recovery |

## Related Skills

- `skills/compiler-internals/llvm-passes` — optimize generated IR
- `skills/compiler-internals/jit-compilation` — execute generated IR
- `skills/compiler-internals/mlir` — higher-level IR for DSLs
- `skills/compilers/llvm` — LLVM as a user (opt, llc)
- `skills/low-level-programming/interpreters` — bytecode VM alternative
- `skills/languages/carbon-lang` — modern language frontend example

© mohitmishra786 · MIT · mohitmishra786/low-level-dev-skills

Похожие скиллы

Все скиллы по теме «Языки программирования» →
llvm sanjeed5 Настраивает Cursor на стандарты кодовой базы LLVM. Заставляет агента использовать структуры ADT, макросы LLVM_DEBUG и тесты LIT. CX Codex +1 ★ 3 589звёзд репо Compiler Explorer compiler-explorer MCP-сервер Compiler Explorer для Claude Code и других AI-агентов. Компилирует код через godbolt.org, показывает ассемблер и создаёт ссылки для обмена результатами. CX Codex +1 ★ 19 201звёзд репо Sounio Compiler Sounio-lang Локальный MCP-сервер Sounio Compiler компилятора Sounio для проверки типов и сборки файлов .sio прямо через агента. Позволяет закрывать цикл отладки кода без выхода из консоли. CX Codex +1 ★ 12звёзд репо check-compiler-errors cursor Скилл check-compiler-errors для Claude Code запускает компиляцию и проверку типов, группирует ошибки по файлам и категориям и исправляет их по приоритету. Разбирает блокировки локальной проверки и CI из-за типов. CX Codex +1 2 400установок reference-compiler-cli angular Скилл reference-compiler-cli объясняет внутреннее устройство Angular Compiler (ngtsc) — как работает компиляция декораторов, система traits и трансформация кода. Подключайте его перед работой с packages/compiler-cli. CX Codex +1 914установок typescript-expert sickn33 Скилл typescript-expert для Claude Code разбирает типы TypeScript, ускоряет проверку и помогает с миграциями; запускается на каждом PR и диагностирует медленную компиляцию. CX Codex +1 12 900установок

Из того же набора140

Весь набор →
bus-drivers-i2c-spi Скилл bus-drivers-i2c-spi помогает писать клиентские драйверы Linux для датчиков и PMIC на шинах I2C и SPI: регистрация, regmap, привязка к device tree. CX Codex +1 392установок uart-serial-baremetal Скилл uart-serial-baremetal помогает настроить bare-metal UART и USART на микроконтроллерах для вывода логов, расчёта битрейта и отладки. CX Codex +1 391установок kernel-concurrency Скилл kernel-concurrency помогает выбрать правильный примитив синхронизации в ядре Linux: spinlock, mutex, RCU, seqlock или completion. CX Codex +1 391установок gpu-memory-model Скилл gpu-memory-model объясняет модели памяти GPU, расхождения варпов и конфликты банков памяти. Помогает находить узкие места в ядрах CUDA и HIP. CX Codex +1 391установок qemu-embedded-simulation Скилл qemu-embedded-simulation для Claude Code помогает запускать bare-metal прошивки ARM и RISC-V в QEMU и подключать GDB. Проверяет прошивку без платы. CX Codex +1 389установок kernel-memory-management Скилл kernel-memory-management по памяти ядра Linux: помогает выбрать между kmalloc, vmalloc и страничным аллокатором и понять, почему драйвер упирается в OOM. CX Codex +1 388установок cuda-debugging Скилл cuda-debugging для Claude Code и Codex: ведёт агента по отладке CUDA через cuda-gdb, Compute Sanitizer, дампы GPU и разбор ошибок 700/702. Покрывает падения ядра и неверный результат. CX Codex +1 386установок llvm-ir-and-passes Скилл llvm-ir-and-passes для Claude Code учит агента читать LLVM IR, понимать SSA и пайплайн оптимизаций. Помогает проследить изменения от -O2 и подготовиться к написанию пасса. CX Codex +1 384установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой