awesome-repositories.com
博客
MCP
awesome-repositories.com

通过 AI 驱动的搜索,发现最优秀的开源仓库。

探索精选搜索开源替代品自托管软件博客网站地图
项目MCP 服务器关于排名机制媒体报道
法律隐私政策服务条款
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

107 个仓库

Awesome GitHub RepositoriesSyntax Tree Construction

Processes for building and maintaining hierarchical syntax representations from source code.

Distinct from Trees: Distinct from Trees: focuses specifically on the construction of syntax trees from source code rather than general tree data structures.

Explore 107 awesome GitHub repositories matching software engineering & architecture · Syntax Tree Construction. Refine with filters or upvote what's useful.

Awesome Syntax Tree Construction GitHub Repositories

用 AI 发现最棒的仓库。我们将通过 AI 为您搜索最匹配的仓库。
  • aykutsarac/jsoncrack.comAykutSarac 的头像

    AykutSarac/jsoncrack.com

    44,142在 GitHub 上查看↗

    jsoncrack.com is a JSON data visualization tool and interactive graph viewer that transforms JSON and other structured data formats into visual tree diagrams. It functions as a data syntax validator and a structured data converter for transforming information between JSON, YAML, XML, and CSV formats. The project includes a JSON schema generator that produces schema definitions and language-specific type definitions based on provided structured data. These capabilities automate type safety and ensure data integrity through schema generation. The tool provides broader capabilities for structur

    Implements processes to build hierarchical syntax representations from source data for visualization.

    TypeScriptcsvdiagramsgraph
    在 GitHub 上查看↗44,142
  • babel/babelbabel 的头像

    babel/babel

    44,009在 GitHub 上查看↗

    Babel is a pluggable JavaScript compiler and transpiler that converts modern ECMAScript syntax into backwards-compatible versions of the language. It functions as an abstract syntax tree manipulator, parsing source code into a hierarchical structure to traverse and modify nodes for custom code transformations. The system utilizes a plugin-driven architecture to apply specific transformation rules and supports presets that bundle multiple plugins into named configuration groups. This enables the transformation of experimental syntax and the injection of non-global polyfills to ensure consisten

    Implements a visitor-based system for navigating and triggering callbacks on specific nodes within a syntax tree.

    TypeScriptastbabelcompiler
    在 GitHub 上查看↗44,009
  • tree-sitter/tree-sittertree-sitter 的头像

    tree-sitter/tree-sitter

    23,848在 GitHub 上查看↗

    Tree-sitter is a parsing system and incremental parsing framework designed to generate high-performance syntax trees from source code. It functions as a language parsing engine that compiles formal grammar definitions into portable code, which can then be integrated into text editors and development tools to facilitate structural analysis, code navigation, and syntax highlighting. The project distinguishes itself through its ability to maintain valid, usable syntax tree structures even when source code contains syntax errors or incomplete fragments. It utilizes a generalized parsing algorithm

    Constructs valid and usable syntax tree structures even when source code contains syntax errors or incomplete fragments.

    Rustcincrementalparser
    在 GitHub 上查看↗23,848
  • rome/toolsrome 的头像

    rome/tools

    23,417在 GitHub 上查看↗

    This project is a unified toolchain for JavaScript and TypeScript development, providing a suite of specialized tools for bundling, parsing, linting, and formatting source code. The toolchain is implemented in Rust and utilizes a shared internal representation to allow multiple tools to operate on the same parsed source code. It employs a parallelized analysis pipeline and single-pass parsing with error recovery to process files across CPU cores. The suite covers several core capability areas, including static analysis for identifying programmatic errors, automated style standardization, and

    Implements tools for modifying and rewriting syntax trees to perform linting and formatting tasks.

    Rustformatterjavascriptlinter
    在 GitHub 上查看↗23,417
  • facebook/flowfacebook 的头像

    facebook/flow

    22,232在 GitHub 上查看↗

    Flow is a JavaScript static type checker and AST parser that identifies type errors and prevents runtime failures through static annotations. It functions as a code intelligence engine and a static analysis linter to identify unsafe coding patterns and enforce consistency across a codebase. The project includes a type annotation stripper that removes static type signatures from source code, ensuring the resulting JavaScript is compatible with any runtime environment. It also provides a parser that converts typed JavaScript into an abstract syntax tree conforming to the ESTree specification.

    Generates a syntax tree from typed JavaScript to facilitate analysis by external tools.

    Rust
    在 GitHub 上查看↗22,232
  • web-infra-dev/oxcweb-infra-dev 的头像

    web-infra-dev/oxc

    21,721在 GitHub 上查看↗

    oxc is a high-performance JavaScript toolchain developed in Rust for parsing, transforming, and analyzing JavaScript and TypeScript source code. It provides a set of core utilities including a parser that converts code into an abstract syntax tree, a linter for identifying problematic patterns, a formatter for standardizing visual style, and a minifier for reducing production file sizes. The project focuses on high-performance execution through a system design that utilizes single-pass parsing, zero-copy string slicing, and parallel worker processing to handle large codebases. It further opti

    Implements a biphasic system that separates syntax tree analysis from code generation to optimize transformation speed.

    Rust
    在 GitHub 上查看↗21,721
  • dotnet/roslyndotnet 的头像

    dotnet/roslyn

    20,241在 GitHub 上查看↗

    The .NET Compiler Platform is a collection of open-source APIs for C# and Visual Basic that provides deep code analysis, refactoring, and automated source code generation. It serves as the core infrastructure for building development tools, offering a platform to inspect, modify, and understand source code through immutable syntax trees and semantic models. The platform distinguishes itself by providing full-fidelity syntax trees that preserve every character of source code, including whitespace and comments, alongside an incremental compilation pipeline that enables near-instant feedback dur

    Parses source code into full-fidelity, immutable syntax trees that preserve every character including whitespace and comments.

    C#csharphacktoberfestroslyn
    在 GitHub 上查看↗20,241
  • wenyan-lang/wenyanwenyan-lang 的头像

    wenyan-lang/wenyan

    20,251在 GitHub 上查看↗

    Wenyan is an esoteric programming language that enables the composition of functional logic using the grammar and vocabulary of classical Chinese literature. It functions as a source-to-source compiler, translating literary scripts into standard high-level programming languages such as JavaScript, Python, and Ruby to facilitate execution across diverse computing environments. The project distinguishes itself by bridging the gap between ancient linguistic structures and modern computational tasks. It utilizes a specialized transpilation process that maps classical grammatical particles and voc

    Translates classical linguistic structures into abstract syntax trees for further processing.

    TypeScriptclassical-chineseesoteric-languageprogramming-language
    在 GitHub 上查看↗20,251
  • realm/swiftlintrealm 的头像

    realm/SwiftLint

    19,456在 GitHub 上查看↗

    SwiftLint is a static analysis tool and code formatter designed to enforce consistent coding styles and identify semantic issues within Swift source code. It functions as a command-line utility that evaluates code against established conventions to ensure uniform structure and architectural standards across a project. The tool distinguishes itself through a custom linting engine that leverages compiler-integrated syntax analysis to perform deep inspections of code structure. Beyond simple pattern matching, it supports automated source code transformation to correct formatting violations and r

    Navigates source code syntax trees to perform deep structural inspections and logical checks.

    Swiftcode-qualityhacktoberfestlinter
    在 GitHub 上查看↗19,456
  • antlr/antlr4antlr 的头像

    antlr/antlr4

    18,928在 GitHub 上查看↗

    ANTLR 是一个基于语法的代码生成器和多语言解析器生成器,用于设计和实现自定义语言。它作为一个工具包,用于将形式语言定义转换为可执行的源代码,以处理结构化文本或二进制文件,同时提供了一个用于自动构建和遍历层级解析树的框架。 该项目以其能够从单个共享语法定义生成多种目标编程语言的词法分析器和解析器的能力而著称。它支持包含直接左递归的语法,并利用自适应预测来优化解析速度,同时保持灵活性。 该系统涵盖了广泛的能力,包括词法分析、通过谓词评估进行的语义检查以及层级数据管理。它通过基于路径的查询和访问者-监听器遍历模式提供了解析树分析工具,以将语法逻辑与应用程序操作解耦。 命令行实用程序可用于测试语法定义和调试逻辑,并且该工具可以在 Docker 容器中执行以避免本地安装。

    Provides a formal grammar parser generator that creates parsers capable of handling various grammar types.

    Java
    在 GitHub 上查看↗18,928
  • react/yogareact 的头像

    react/yoga

    18,790在 GitHub 上查看↗

    Yoga is a cross-platform layout engine and embeddable core that determines the dimensions and offsets of hierarchical element trees. It provides a C++ implementation of the Flexbox layout model to calculate element positions and sizes based on web standards, ensuring a uniform appearance across diverse devices and operating systems. The engine is designed for portability via a C API, allowing the layout logic to be integrated into various host languages and platforms. It utilizes an incremental layout system that identifies modified subtrees and recalculates positions only for changed nodes a

    Allows the creation and linking of nodes to establish a hierarchical structure for UI elements and styling.

    C++
    在 GitHub 上查看↗18,790
  • jashkenas/coffeescriptJ

    jashkenas/coffeescript

    16,601在 GitHub 上查看↗

    CoffeeScript is a source-to-source transpiler that transforms a concise high-level syntax into standard JavaScript. It enables the development of logic for web applications and server-side environments by converting source code into a format compatible with browsers and server runtimes. The project provides a workflow for rapid prototyping and script execution automation, allowing users to run source files through a compiler and execute the resulting code immediately without a manual build step. The tooling leverages lexical analysis and abstract syntax tree transformations to manipulate cod

    Implements syntax tree transformers to rewrite language constructs into JavaScript.

    CoffeeScript
    在 GitHub 上查看↗16,601
  • rust-lang/rust-analyzerrust-lang 的头像

    rust-lang/rust-analyzer

    16,590在 GitHub 上查看↗

    Rust-analyzer is a language server implementation that provides real-time code intelligence, static analysis, and development productivity tools for the Rust programming language. It functions as a backend engine that communicates with text editors to deliver deep structural understanding of source code, enabling features like semantic analysis, symbol navigation, and automated refactoring. The project distinguishes itself through a core engine designed for high-performance responsiveness, utilizing incremental query-based compilation and lazy demand-driven evaluation to minimize resource con

    Constructs lossless syntax trees to preserve formatting and comments while enabling deep structural code analysis.

    Rusthacktoberfestlsp-serverrust
    在 GitHub 上查看↗16,590
  • typescript-eslint/typescript-eslinttypescript-eslint 的头像

    typescript-eslint/typescript-eslint

    16,103在 GitHub 上查看↗

    This project is a static analysis framework and linting engine designed to inspect TypeScript codebases. It functions as a plugin suite that enables standard linting workflows to parse source code into abstract syntax trees, allowing for the automated enforcement of coding standards and the identification of potential bugs through a modular, rule-based visitor pattern. The engine distinguishes itself by integrating directly with the TypeScript compiler to perform type-aware analysis. By accessing compiler type information, it can identify complex errors and unsafe patterns that standard synta

    Uses recursive tree-walking mechanisms to execute analysis logic at every node of the syntax tree.

    TypeScripteslinteslint-plugineslintplugin
    在 GitHub 上查看↗16,103
  • chentsulin/awesome-graphqlchentsulin 的头像

    chentsulin/awesome-graphql

    14,975在 GitHub 上查看↗

    Awesome GraphQL is a curated directory and resource collection for the GraphQL ecosystem. It serves as a central index for developers to discover libraries, tools, and specifications required for building, testing, and managing data layer implementations across various programming languages. The repository provides access to a comprehensive range of utilities that support the entire GraphQL lifecycle. This includes resources for server-side API development, client-side integration, and schema management. It also highlights tools for security enforcement, such as rate limiting and input valida

    Includes utilities for parsing and constructing syntax trees from GraphQL query strings.

    awesomeawesome-listgraphql
    在 GitHub 上查看↗14,975
  • nltk/nltknltk 的头像

    nltk/nltk

    14,649在 GitHub 上查看↗

    This project is a comprehensive Python toolkit designed for natural language processing, research, and education. It functions as a linguistic data processor that provides a standardized framework for managing, cleaning, and analyzing large collections of annotated text corpora and lexical resources. The library distinguishes itself through its integration of both symbolic and statistical methods, allowing users to perform complex tasks ranging from rule-based grammar parsing to machine learning-driven classification. It offers a modular pipeline for text processing, enabling the transformati

    Uses formal logic and syntactic constraints to map the hierarchical structure and grammatical relationships within complex sentences.

    Pythonmachine-learningnatural-language-processingnlp
    在 GitHub 上查看↗14,649
  • facebookarchive/prepackfacebookarchive 的头像

    facebookarchive/prepack

    14,118在 GitHub 上查看↗

    Prepack is a build-time code evaluator and JavaScript bundle optimizer. It functions as a static analysis compiler that pre-evaluates static code and precalculates function results and global assignments during the build phase to accelerate startup times and reduce bundle size. The project specifically targets JSX optimization by processing syntax and node serialization to improve user interface rendering efficiency. It utilizes a partial evaluation engine and static execution analysis to replace runtime computations with precalculated constants. The tool covers a range of capabilities inclu

    Implements syntax tree transformations to inline expressions and strip type annotations during the build process.

    JavaScriptjavascriptoptimization
    在 GitHub 上查看↗14,118
  • google/yapfgoogle 的头像

    google/yapf

    13,978在 GitHub 上查看↗

    YAPF 是一个 Python 代码格式化程序和样式合规工具。它作为一个基于 AST 的重格式化程序运行,使用具体语法树来确保源文件之间的结构一致性和统一的视觉呈现。 该引擎利用基于惩罚的布局优化器,通过计算不同格式化选择的数值成本来确定最佳换行符。它采用多进程代码处理器将多个文件的格式化分布到多个 CPU 核心上。 该工具涵盖了通过就地文件修改、差异分析和处理部分代码片段进行的源代码重格式化。它包括一个用于管理样式预设、布局规则和项目级设置的基于规则的配置系统。 集成能力包括用于持续集成流水线的样式合规验证、Git 钩子自动化以及基于编辑器的保存时格式化功能。

    Reconstructs source code by modifying concrete syntax tree representations while preserving the original structural integrity.

    Python
    在 GitHub 上查看↗13,978
  • nvim-treesitter/nvim-treesitternvim-treesitter 的头像

    nvim-treesitter/nvim-treesitter

    13,970在 GitHub 上查看↗

    This project provides an integration of Tree-sitter into the Neovim editor to enable structural code analysis. It serves as a framework for structural code navigation, context-aware syntax highlighting, and the management of language-specific parsers. The system distinguishes itself through a multi-language injection handler that identifies and parses embedded languages within a single document. It uses a dedicated parser manager to install, update, and remove grammar definitions and their associated query files. The tool covers several capability areas including incremental text selection,

    Traverses the hierarchical structure of parsed source code to derive structural boundaries for indentation and folding.

    Tree-sitter Query
    在 GitHub 上查看↗13,970
  • seaswalker/spring-analysisseaswalker 的头像

    seaswalker/spring-analysis

    13,739在 GitHub 上查看↗

    Spring-analysis is a diagnostic utility designed to visualize the internal architecture and execution logic of Java applications built on the Spring Framework. It functions as a static analysis tool that parses source code to map structural relationships and component interactions without requiring the program to execute. The tool distinguishes itself by automatically extracting configuration and annotation data to identify beans and service definitions, which it then translates into visual representations of the system. By reconstructing method call hierarchies and event propagation paths, i

    Navigates source code nodes to extract structural information and logic flow details without execution.

    Javanotessource-code-analysisspring
    在 GitHub 上查看↗13,739
上一个12345…6下一个
  1. Home
  2. Software Engineering & Architecture
  3. Trees
  4. Syntax Tree Construction

探索子标签

  • Custom BuildersCustomizable builder patterns that control how abstract syntax tree nodes are instantiated and structured during parsing. **Distinct from Syntax Tree Construction:** Distinct from Syntax Tree Construction: focuses specifically on user-supplied builder objects for customizing node instantiation rather than default tree building.
  • DOM Tree Construction2 个子标签The process of transforming a token stream into a hierarchical Document Object Model. **Distinct from Syntax Tree Construction:** Distinct from general syntax tree construction by specifically managing the dynamic nature of the HTML DOM.
  • ESTree AST Parsing3 个子标签Parsing of JavaScript source code into abstract syntax trees that follow the ESTree specification. **Distinct from Typed JavaScript Parsing:** Distinct from Typed JavaScript Parsing: focuses on conforming to the standard ESTree specification for general JavaScript, not just typed syntax.
  • Formal Grammar Parser Generators8 个子标签Tools that generate parsers based on formal grammar specifications to extract structured data from text. **Distinct from Grammar-Based Parsers:** Unlike Grammar-Based Parsers [f6_mt2] which are the resulting parsers, this refers to the generator tool itself.
  • Grammar-Based Parsers11 个子标签Parsers that construct syntax trees based on specialized linguistic or literary grammar rules. **Distinct from Syntax Tree Construction:** Distinct from general syntax tree construction: focuses on parsing non-standard or literary grammars into ASTs.
  • Markdown AST Manipulation1 个子标签Programmatic structural modification of a markdown abstract syntax tree while preserving hierarchy. **Distinct from Syntax Tree Construction:** Focuses on modifying the tree for document analysis/transformation rather than JIT optimization or shell commands.
  • Multicast Tree ConstructionThe process of organizing distributed nodes into a tree structure for efficient media streaming. **Distinct from Syntax Tree Construction:** Focuses on network topology trees for data distribution rather than compiler syntax trees or DOM structures.
  • Pair Matching LogicLogic for identifying and navigating between corresponding code delimiters using syntax trees. **Distinct from Syntax Tree Construction:** Distinct from Syntax Tree Construction: focuses on the application of tree data for pair navigation rather than the construction of the tree itself.
  • Processing EnginesIntegrated systems for parsing, transforming, and serializing text via syntax trees. **Distinct from Syntax Tree Transformers:** Distinct from Syntax Tree Transformers: covers the full end-to-end lifecycle of parsing, transforming, and serializing, rather than just mutation.
  • Regex Syntax Tree CompilersParsing a builder chain into an abstract syntax tree and compiling it to a standard RegExp literal at build time. **Distinct from Syntax Tree Construction:** Distinct from Syntax Tree Construction: focuses on compiling a regex-specific AST into a RegExp literal, not general source code syntax tree building.
  • SerializationProcesses for converting a syntax tree back into a plain text string. **Distinct from Syntax Tree Construction:** Distinct from Construction: focuses on the output of a string from a tree, not the creation of the tree from text.
  • Syntax Traversal3 个子标签Tools for navigating nodes, tokens, and trivia within a syntax tree. **Distinct from Syntax Tree Construction:** Distinct from syntax tree construction: focuses on the traversal and inspection of existing trees.
  • Syntax Tree Printing1 个子标签The process of converting a structured syntax tree back into a stream of tokens. **Distinct from Syntax Tree Construction:** Distinct from Syntax Tree Construction: focuses on the output (printing) phase rather than the input (parsing) phase.
  • Syntax Tree Transformers5 个子标签Tools for modifying and rewriting syntax trees to generate new code structures. **Distinct from Syntax Tree Construction:** Focuses on the mutation and transformation of the tree nodes rather than the initial construction of the tree.
  • Tree MutationsProcesses for modifying or replacing nodes within a syntax tree to generate transformed code. **Distinct from Syntax Tree Construction:** Distinct from Syntax Tree Construction: focuses on modifying existing trees rather than building them from scratch.
  • Typed JavaScript ParsingConstruction of syntax trees from source code that includes non-standard type annotations. **Distinct from Syntax Tree Construction:** Specifically handles the parsing of typed syntax rather than general syntax tree construction.