This article explains how abstract syntax trees (AST) provide a structured representation of source code, how the Language Server Protocol (LSP) standardizes semantic queries, and why AI coding tools like Cursor, Claude Code, and OpenCode rely on LSP instead of simple text search, offering faster, more accurate, and lower‑cost code intelligence.
Graphify is a Python tool that parses codebases into a searchable knowledge graph, eliminating the need for costly vector retrieval by traversing explicit entity‑relationship graphs, achieving up to 71.5× token reduction, supporting AST extraction, optional local audio transcription, and AI‑driven semantic extraction with confidence labeling.
The article describes how an AST‑based code‑context service, wrapped by an MCP middleware and built with Spring AI and Eclipse JDT, supplies structured Java code information to large models, addressing the context gaps of diff‑only AI code review and improving accuracy through concrete examples and evaluation.
This article explains the motivations, techniques, and practical implementations of code indexing—covering semantic vector‑based RAG pipelines and AST‑based structural analysis—to improve code navigation, AI‑assisted queries, security scanning, and development efficiency.
This guide explains how to create a lightweight Vite plugin and a Tampermonkey script that embed absolute file paths into Vue components, enabling developers to click any element in the browser and instantly locate its source file in the project.
This article introduces the open‑source Spoon library for Java source‑code analysis and transformation, demonstrates how to integrate it with Spring Boot 3, and provides step‑by‑step examples—including visual AST inspection, empty‑catch detection, architecture rule validation, field usage checks, reflection replacement, and automatic code modifications such as adding fields, constructors, logging, and null‑checks.
The article chronicles the author's deep technical journey of adapting Tailwind‑Merge to work within WeChat mini‑programs, detailing the obstacles posed by illegal class‑name characters, failed compile‑time workarounds, a complete rewrite of the escape utility, and the final release of a robust, configurable merge plugin.
This article details a real‑world migration of a Southeast Asian tech group’s data warehouse from Google BigQuery to Alibaba Cloud MaxCompute, describing the challenges of converting 100,000 SQL scripts, the AST‑driven and LLM‑assisted automation pipeline, rule‑engine iteration, quality control, and the measurable performance and cost benefits achieved.
This article explores how abstract syntax trees (AST) can enrich large language model (LLM) based code question‑answering by providing precise structural context, detailing LLM strengths and limits, describing AST‑LLM collaboration, RAG integration, cutting‑edge models, practical tooling, challenges, standardisation efforts, and future research avenues.
With software systems growing ever more complex, traditional text‑based code search falls short; this article explains how abstract syntax trees (AST) provide deeper structural understanding, improve query precision, enable advanced features like control‑flow analysis and knowledge‑graph construction, and outlines a full architecture for building AI‑enhanced code question‑answering systems.
This article explains how to replace inefficient global searches for third‑party APIs with a TypeScript‑based solution that parses source files into an AST, traverses import declarations, distinguishes import styles, records call counts and line numbers, and overcomes symbol resolution challenges using the TypeScript compiler API.
FixrLeak combines AST analysis with generative AI to detect and automatically repair Java resource leaks, dramatically reducing manual effort, improving code quality, and demonstrating the transformative potential of AI‑driven solutions in large‑scale software engineering.
CodeRAG leverages AST‑centric parsing and a hierarchical knowledge graph to overcome text‑only retrieval limits in large code repositories, offering multi‑language analysis, incremental parsing, hybrid indexing, and intelligent context selection for tasks such as code completion, Q&A, documentation generation, and impact analysis.
The article explains how AutoDev’s Context Worker pre‑generates semantic code context to improve RAG performance, outlines the limitations of vector‑based retrieval, describes the tool’s multi‑language AST analysis, knowledge‑graph construction, and provides command‑line usage examples for integrating the generated context into AI‑driven development workflows.
This article explains how to analyse the impact range of code changes in large frontend projects, describes the architecture and core techniques—including project dependency‑tree building, AST parsing, GitLab diff extraction, and change propagation—provides concrete JavaScript/TypeScript examples, and discusses visualization of the results.
This article introduces JavaParser, an open‑source library for parsing Java source code into an AST, and walks through practical cases covering dependency setup, basic parsing, class and method extraction, code modification, class generation, and comprehensive analysis with code snippets and output screenshots.
This article explains cyclomatic complexity concepts, industry standards, calculation methods, and how a custom ESLint rule can be used to assess both single‑function and nested‑function complexity in front‑end projects, including scoring thresholds and practical implementation details.
The Precise Testing Platform combines a recommendation engine—featuring a link analyzer, diff analyzer, and knowledge base—to automatically construct detailed method‑call graphs from source code, extract HTTP and Dubbo APIs, handle reflections and inheritance, and store billions of nodes in Nebula Graph, thereby eliminating blind, missed, and redundant tests while boosting coverage and reducing testing costs.
By binding a Vue single‑file component’s AST to a visual UI, this project parses templates with node‑html‑parser, transforms scripts via Babel, and processes styles with standard loaders, allowing developers to edit component properties visually, automatically regenerate synchronized source code, and preview changes, with a prototype demo and planned drag‑and‑drop, styling, state, AI, and CI/CD extensions.
To simplify large‑scale Vue upgrades such as Vue 2→Vue 3, Webpack 4→Webpack 5, or migration to Vite, the author presents an automated AST‑based migration scaffold that parses JavaScript, Vue, and style files, applies transformation rules with GoGoCode and PostCSS, and rewrites code, reducing manual effort and error risk.
A compiler transforms source code into executable machine instructions by first tokenizing the text into keywords, identifiers and literals, then parsing these tokens into an abstract syntax tree, generating and optimizing intermediate code, and finally assembling and linking the output for the target architecture or LLVM IR.
This article explains how JavaScript parsers transform source code strings into abstract syntax trees through lexical analysis and syntax parsing, covering language types, V8’s execution flow, token generation, AST construction, and practical examples, while also linking to tools like AST Explorer for further exploration.
This article introduces Python's Abstract Syntax Tree (AST), explains its purpose for code analysis and transformation, and provides ten detailed examples that demonstrate building, inspecting, modifying, and generating code using the ast module in a standard Python environment.
This article walks through how a compiler turns human‑readable source code into binary machine instructions, covering tokenization, parsing, abstract syntax tree construction, code generation, optimization, and linking, while highlighting the role of LLVM as a portable backend.
This article explains how a programmer's source code is transformed into CPU‑executable machine instructions through lexical analysis, parsing into an abstract syntax tree, optimization, target‑specific code generation, and linking, highlighting the role of compilers and tools like LLVM.
This article introduces nine powerful Python standard library modules that enhance code efficiency and readability, covering context management, iterators, concurrency, file operations, functional programming, AST parsing, type hints, data classes, and async programming.
This article explains how to use the LiteFlow rule‑engine framework to define reusable Java components, express execution flows with EL expressions, design a visual canvas that converts JSON into an abstract syntax tree, generate valid EL code via DFS, and manage workflow updates through push‑pull refresh mechanisms, while also outlining benefits and future plans.
This article explains how to create a custom insertable annotation processor in Java that automatically injects the jar version into component constants during the Gradle build, eliminating manual updates and enabling version monitoring via Prometheus.
Facing the trade‑off between flexibility and speed in low‑code development, NetEase’s cloud music team built Tango—a source‑code‑based low‑code engine that leverages AST manipulation and the TangoBoot framework to standardize front‑end programming, halve view logic, and unify low‑code with traditional development.
This article presents a design and implementation of both static AST‑based scanning and runtime JaCoCo coverage analysis to automatically detect unused (zombie) Java methods, describing the workflow, required dependencies, code snippets, and how to visualize active versus dead code in the IDE.
This article walks through the design and implementation of a compiler that automatically transforms Rax components into Taro components, covering the background, Babel‑based AST processing, import rewriting, component attribute mapping, project structure, automated end‑to‑end testing, and future enhancements.
PHP‑Parser 5.0.0 introduces a host of new classes, methods, and parser improvements—including a PhpVersion class, PHP 8 support, enhanced pretty‑printing, and updated node handling—while also deprecating older APIs; the article provides a detailed changelog and a concise usage example for parsing PHP code.
The article describes an AST‑driven command‑line tool that automatically upgrades a Taro 1.x mini‑program to 3.x by updating dependencies, converting imports, restructuring files, consolidating styles, replacing deprecated APIs, and adjusting build settings, offering faster, more reliable migration than the labor‑intensive manual approach.
A precise testing platform built on AST analysis and a recommendation engine was deployed across four core applications, enabling automated test execution with 100% pass rates, at least 75% service coverage, around 80% precision, early defect interception, and up to one hour per‑iteration time savings while planning further expansion and precision improvements.
Baidu’s white‑box code understanding platform combines static, dynamic, non‑code and LLM‑based analyses in a three‑layer architecture that accelerates C/C++ processing ninefold, supports multiple languages, and powers applications such as intelligent unit testing, orphan‑function cleanup and AI‑driven risk detection, while future integration with models like GPT‑4 aims to enable multi‑turn code Q&A, automated refactoring and predictive testing.
This article examines the design and implementation of Tango, an open‑source low‑code engine that leverages ESTree AST standards to enable bidirectional code‑to‑visual‑schema conversion, offering a progressive, source‑code‑driven visual development experience integrated with modern front‑end tooling.
This article introduces Lombok, explains how it leverages Java's annotation‑processing (JSR‑269) and abstract syntax tree (AST) modifications to generate boilerplate code at compile time, and provides a step‑by‑step guide to manually implement a @Getter annotation processor with full Maven project examples.
This article explains the concept of codemod, outlines typical migration scenarios, details a step‑by‑step AST‑based workflow, and compares popular JavaScript code‑mod libraries such as Recast, jscodeshift, gogocode, and ast‑grep, helping developers choose the right tool for automated code upgrades.
Baidu reduced the iOS app package by over 350 MB by discarding dead code, replacing unreliable Mach‑O analysis with a source‑level AST approach built on LLVM libtooling and the Swift compiler, and implementing a multi‑layer static‑analysis pipeline that extracts, transforms, stores, and filters method usage data.
To accurately trim iOS app binaries, the article discards low‑precision Mach‑O/LinkMap methods and instead builds a custom compilation pipeline using libtooling and the Swift compiler to analyze full abstract syntax trees, enabling reliable detection of unused methods across complex language features and inheritance hierarchies.
The author builds an internal code knowledge base for the TDesign Vue‑Next library by scraping documentation, chunking and embedding texts with OpenAI’s ada model into a vector store, then retrieving relevant chunks for LLM answers, and enhances context continuity using a JavaScript AST interpreter, achieving up to 90 % query accuracy and a 20 % productivity boost.
This article explains how to convert TypeScript source code into an AST, traverse it to collect import statements, distinguish various import forms, and use the TypeScript compiler API to locate identifier symbols, enabling accurate counting of API calls and line numbers for a given dependency.
This article explains how to use a custom Babel plugin to automatically inject standardized logging statements into JavaScript code, addressing common debugging challenges such as sparse logs, inconsistent log formats, and missing error handling in async/await constructs.
This article explains Polish (prefix) notation, defines its syntax and lexical rules, and walks through implementing a full parser and evaluator in C using the MPC library, complete with code examples, compilation instructions, and sample interactive sessions.
This article provides a detailed overview of Babel, covering its definition, history, installation, configuration, core compilation phases, plugin and preset mechanisms, polyfill handling, and a step‑by‑step example of creating a custom try‑catch plugin for JavaScript code transformation.
This article explains the fundamentals of ESLint, including its purpose, configuration files, AST-based analysis, the SourceCode abstraction, rule template creation, key functions, and the overall linting and fixing workflow, enabling developers to build custom linting plugins for consistent code style.
This article explains how to use the open‑source mammoth.js library to convert Word (.docx) documents into clean HTML, customize the AST to fix layout issues, and automatically generate Vue component files, dramatically streamlining documentation integration in frontend projects.
This article explores the fundamentals of ESLint, explaining how it leverages abstract syntax trees (AST) to enforce code style, detect errors, and enable custom rule creation, while providing practical configuration examples, code snippets, and insights into the underlying processing pipeline.
This article surveys modern front-end engineering topics, covering plugin-based design, AST-driven compilation, sandbox performance tricks, techniques to reduce complex if‑else structures, a single‑div CSS football field demo, and essential insights into automated testing for developers.
This article explains the fundamentals of abstract syntax trees (AST) in frontend development, covering their generation, role in code transformation, and practical use of Babel plugins to instrument and modify JavaScript code, with detailed examples and code snippets.
This article presents a comprehensive overview of using abstract syntax tree (AST) based static analysis for Lua code, detailing the motivation, dynamic and static approaches, variable type handling, analysis loops, built‑in functions, closures, metatables, and potential applications in precise testing for game development.
Data lineage in big‑data environments tracks how data moves and transforms—from source tables through SQL processing to final storage—enabling management tasks such as domain segmentation, performance tuning, anomaly detection, and dependency verification, with implementations ranging from simple regex extraction to robust AST parsing and optimization, as used by tools like Alibaba DataWorks and Apache Atlas.
This article explains how to upgrade Taro 2.x projects to Taro 3.x by converting source code into an AST using Babel, programmatically editing imports, configs, routers, and styles, and then generating the updated code, complete with practical code examples and migration tips.
This article explores the inner workings of SQL engines, detailing the end‑to‑end process from query submission through lexical analysis, parsing, abstract syntax tree generation with ANTLR4, and subsequent logical and physical plan optimization, while also demonstrating practical Java examples for SQL parsing and rewriting.
This tutorial explains why and how to create a custom ESLint rule that automatically replaces specified import paths, using AST traversal, rule configuration, and fixers, with a complete example including project scaffolding, implementation details, and unit testing.
This article explores the concept of Single Source of Truth in SwiftUI, explains the nature of computer programs, compares compiled and interpreted languages, discusses Turing completeness and formal language history, demonstrates a simple Lisp interpreter, and examines how Xcode leverages ASTs for live SwiftUI previews, highlighting the benefits of a code‑out approach.
This article explores how to eliminate repetitive monitoring code in Java services by building a compile‑time instrumentation component that leverages JSR‑269 annotation processing and AST manipulation, detailing the component design, technical selection, compiler internals, implementation steps, and lessons learned.
Subtoken‑TranX, a joint effort by Alibaba’s DaTaobao team and Peking University, converts natural‑language requirements into JavaScript by training on a curated 2,489‑pair dataset, using subtoken‑level AST generation and task‑augmented variable semantics, achieving superior accuracy over standard TranX and Transformer models and now powering Alibaba’s BizCook front‑end production platform.
This article explains how to create a Node‑based CLI utility that automatically scans Vue and JavaScript files in a large front‑end codebase, extracts i18n calls via AST parsing, validates translation keys, and outputs consolidated results to improve internationalization efficiency and accuracy.
This article explains how a Java compiler‑time AST injection component replaces manual monitoring instrumentation with a simple @UMP annotation, detailing the technology selection, implementation using JSR‑269 annotation processors, and the trade‑offs of compile‑time versus runtime weaving.
This article explains Python's compilation process, introduces the AST module, and demonstrates how to parse, pretty‑print, traverse, and transform abstract syntax trees to automatically rename ambiguous variables and inject logging statements, ending with a discussion of broader AST applications.
The SASA model, a structure‑aware sparse‑attention Transformer developed by Alibaba Cloud PAI and Prof. Gao Ming’s team, improves long‑code sequence processing by sparsifying self‑attention using top‑k frequency and AST pattern matrices, achieving higher performance and lower memory/computation costs on CodeXGLUE benchmarks.
This article explains how to automatically extract data lineage and code dependencies from large collections of Python scripts by leveraging the language's compilation stages, abstract syntax trees, and the Pyflakes static‑analysis library, providing practical code examples and custom parsers for SQL extraction.
This article explains why ESLint is essential for frontend development, details how its rule configuration works, walks through the CLI execution flow, and reveals the internal call stack that parses code into an AST, applies custom rules, and performs auto‑fixes.
This article walks through the core concepts and implementation steps of a minimal JavaScript compiler, covering tokenization, parsing into an AST, traversing with a visitor, transforming the tree, and generating target code, while also explaining the visitor pattern and polyfills.
The article walks readers through designing and implementing TinyLanguage—a minimal interpreted language with 4‑byte integers, constants, if/else, for loops, and print—by using Flex for lexical analysis, Bison for parsing into an AST, and an execution engine, even showing a Fibonacci example and future LLVM compilation possibilities.
The article proposes a GCC‑plugin‑based tool called TU that automatically extracts AST information from C/C++ source files to generate boundary unit tests, custom cases, and mocks without modifying business code, dramatically reducing the manual effort required for comprehensive test development.
This article details Baidu's large‑scale intelligent testing framework, describing how AST‑based unit test generation, automated API test creation, visual UI interaction case synthesis, GUI traversal action set generation, and front‑end assertion automation work together to achieve high‑coverage, low‑cost automated testing across multiple languages and platforms.
This article reveals Baidu's end‑to‑end intelligent testing pipeline, detailing AST‑driven unit test creation, automated interface test generation, visual UI interaction case synthesis, smart GUI action set production, and front‑end assertion automation, along with the techniques and results achieved.
This article walks through creating a minimal JavaScript compiler—starting from tokenizing Lisp‑style input, building an abstract syntax tree, traversing and transforming it, and finally generating equivalent C‑style code, illustrating the core parse‑transform‑generate workflow used by tools like Babel.
This article provides an in‑depth tutorial on Abstract Syntax Trees (AST) and the Babel toolchain, covering AST fundamentals, its role in compilation, and practical examples of parsing, traversing, modifying, and generating JavaScript code using @babel/core, @babel/parser, @babel/traverse, @babel/generator, and @babel/types.
This article examines whether Go can achieve aspect‑oriented programming by comparing Java's AOP mechanisms, introducing the gohook library for runtime method interception, and demonstrating how to modify Go source code through AST transformations with concrete code examples.
This article provides a comprehensive beginner-friendly guide to Babel, covering its definition as a JavaScript compiler, the parse‑transform‑generate workflow, AST concepts, core packages, plugin and preset classifications, configuration details, and step‑by‑step usage examples with code snippets.
This article explains the fundamentals of compilation, compares compiled and interpreted languages, outlines the full compiler pipeline, and uses Babel as a concrete example to show how JavaScript code is parsed, transformed, and generated for broader browser compatibility.
This article explains what an Abstract Syntax Tree (AST) is, how the ESTree specification standardizes JavaScript syntax, and how Babel parses, traverses, and transforms code using AST nodes, providing practical examples, core packages, plugin creation, and real‑world application scenarios for developers.
The article analyzes NetEase Cloud Music's front‑end team's challenges with repetitive, mode‑driven development and explains how they designed a source‑code‑based low‑code system—Tango—that unifies LowCode and ProCode, integrates with existing GitLab and deployment tools, and dramatically speeds up business‑focused delivery.
This article explains how to master regular expressions by visualizing their abstract syntax trees (AST), covering basic patterns, character classes, repetitions, greedy vs. non‑greedy matching, groups, and look‑ahead/look‑behind assertions with clear examples and diagrams.
This article explores how understanding and visualizing JavaScript’s control and data flow—through abstract syntax trees, data flow graphs, and control flow graphs—can guide effective code optimization, illustrated with hardware-inspired examples and practical Arduino code, while also introducing SSA and Node Sea concepts.
This article explores how digital circuit concepts inspired by Claude Shannon relate to program control and data flow, demonstrating JavaScript optimization through abstract syntax trees, data flow graphs, control flow graphs, and the Node Sea technique with practical Arduino and code examples.
This article explores Shopify's remote‑rendering UI framework, demystifies abstract syntax trees for JavaScript tooling, provides a step‑by‑step guide to frontend internationalization, dives into the mathematics of Bézier curves, and shares a two‑year product case study on scaling to tens of millions in revenue.
This article introduces the Unified text‑processing ecosystem, explains its AST‑based core, surveys major plugins such as remark, rehype, retext, and demonstrates practical usage examples—including Node.js documentation, dumi, and react‑markdown—to help developers understand its capabilities, workflow, and integration patterns.
This article explains the inner workings of the TypeScript compiler, detailing each stage—from scanning source code into tokens, parsing tokens into an AST, binding symbols, performing type checking, to emitting JavaScript and declaration files—while providing code examples and diagrams of the process.
This article explains how to design a lightweight rule engine in Go by first using JSON‑defined rules, then leveraging Go's token scanner and AST parser to evaluate boolean expressions such as header and cookie checks, and finally discusses extending the engine with custom primitives and GoYACC for more complex grammars.
This article explains Gradle's fundamentals, compares it with Maven, introduces Groovy's abstract syntax tree (AST) concepts, and provides a step‑by‑step demo that parses a Gradle script into an AST, modifies it to inject a dependency, and attempts to write the changes back to the original build file.
This article explains how to use the GoGoCode AST‑based tool to automate the migration of large Vue 2 codebases to Vue 3, covering installation, command‑line usage, sample transformation rules, supported API changes, and where to find documentation and source code.
This article explains what an Abstract Syntax Tree (AST) is, demonstrates how to generate and inspect Python ASTs using the ast module, visualizes them with astpretty, and shows how to compile, evaluate, and transform AST nodes with custom visitors and transformers.
This article explains how the GoGoCode AST‑based tool can automatically transform large Vue2 codebases to Vue3 by applying a set of around thirty migration rules, covering async components, custom directives, router and Vuex changes, and provides installation, usage examples, and a comprehensive rule table.
This article explains how to use the GoGoCode AST‑based tool to automatically convert Vue 2 projects to Vue 3 by following the official migration guide, installing the CLI, running conversion commands, and applying a comprehensive set of transformation rules covering common break‑changes.
This article explains TypeScript’s compilation pipeline, AST and symbol system, its integration with VSCode via the Language Server Protocol, how Babel can strip types for bundling, and how to enforce type safety with the tsc command, providing code examples throughout.
This article walks you through the fundamentals of abstract syntax trees, Babel, and Webpack's build process, then shows how to implement a simple mini‑webpack from scratch, install dependencies, configure the project, run the build, and verify the bundled output.
This article explains how the Fair 2.0 framework parses Dart source code into an AST, transforms the AST into a domain‑specific layout DSL, and handles variables, expressions, and method caching to enable dynamic UI updates in Flutter applications.
This article explains Babel's role as a JavaScript compiler, details its three‑step architecture (parse, transform, generate), introduces plugin creation using the visitor pattern with practical code examples, and demonstrates how to debug and configure Babel plugins in a front‑end development workflow.
This article introduces the concept of Abstract Syntax Trees (AST) in JavaScript, explains their purpose and generation process, and demonstrates practical examples such as removing debugger statements and enhancing console.log calls using Babel’s parser, traverse, and generator tools.
This article explains how Cobar’s SQL parser converts SQL statements into an abstract syntax tree (AST), details the parser’s implementation options, demonstrates AST node definitions and visitor‑based traversal in Java, and explores practical applications such as sharding, feature extraction, and dangerous‑SQL interception.
This article explains what an Abstract Syntax Tree (AST) is, demonstrates how JavaScript code is transformed into an AST, describes the tokenization and parsing steps used by PostCSS to generate a CSS AST, and shows how plugin mechanisms like AutoPrefixer can extend the toolchain.
The article explains how to design and implement ESLint and StyleLint plugins for the San‑Native framework, detailing AST generation, processor creation, rule definitions for JavaScript and CSS, configuration sharing, and how these tools provide real‑time linting feedback for developers.
The article presents an automated tool that parses Vue single‑file components using vue‑template‑compiler and Babel to extract props, methods, events, slots, and developer annotations, then generates up‑to‑date documentation in Markdown or JSON, reducing manual effort and errors.
This article explains Rollup’s core principles, compares it with Webpack, introduces prerequisite concepts such as magic‑string, AST and scope chains, and walks through the complete build workflow—including parsing, dependency analysis, statement expansion, and final code generation—using concrete code examples and diagrams.
This article explains the fundamentals of abstract syntax trees, Java AST analysis with Spoon, the principles of static application security testing and taint analysis, and demonstrates how to use CodeQL to detect unsafe Fastjson usage and Spring web path bindings in a CI/CD pipeline.
This article explains what an Abstract Syntax Tree (AST) is, how it’s generated during lexical and syntax analysis, outlines its core structure, and demonstrates practical applications such as code transformation, linting, formatting, and custom Babel plugins with detailed code examples.
