Static Analysis of Lua Code Using AST: Methods, Challenges, and Solutions

In daily testing, developers often encounter situations where fixing issue A introduces issue B, and the relationship between the two is not obvious; the article explores whether automation can reveal the functional impact of code changes to aid regression testing.

01 Solution Analysis and Selection – Full regression is unrealistic for frequently updated products, and manual code review is inefficient; the key is to extract the call chain from code changes and map it to high‑level functionality.

The first idea is instrumentation , which records runtime paths and links them to automated test cases, but it suffers from high overhead, especially in game projects, and depends heavily on test coverage.

The alternative is static analysis using Lua's abstract syntax tree (AST). AST represents code as a tree structure, enabling systematic analysis without executing the program.

02 Static Analysis Basic Idea

The analysis proceeds in two stages:

L1 – file‑level analysis: collect all variables and functions defined in each Lua file, forming the initial variable/function list.

L2 – function‑level analysis: traverse each function to gather deeper information, updating variable types and discovering new functions.

Because information discovered in one stage may affect the other, the process iterates (loops) until no new variables, functions, or type changes appear.

Key components of the static analysis include:

Variable type identification : Recognize six basic Lua types (Nil, Boolean, Number, String, Table, Function) and an additional UnKnown type for unresolved cases.

Variable scope and level : Track the hierarchical Level of variables (file = 1, function = 2, block = 3, …) and respect scope when searching for existing definitions.

Function parameter and return analysis : Perform “pseudo‑runtime” analysis by considering actual arguments passed to a function, allowing the type of the return value to be inferred from concrete calls.

Built‑in handling : Initialize analysis of Lua built‑in functions (e.g., rawset) and the global table _G to correctly model their effects.

Closures and upvalues : Detect closure functions, bind upvalues to the enclosing environment, and analyze calls by first restoring the parent function’s context.

Metatable processing : Support __index and __call metamethods, enabling analysis of table‑based object‑oriented patterns and callable tables.

03 Difficulties and Solutions

The article discusses challenges such as handling table sub‑variables, variable passing between scopes, recursive analysis loops, and the complexity of metatable‑driven behavior, and proposes concrete rules for each case.

04 Summary and Outlook

The Lua AST static analysis framework can not only link code changes to functional test cases but also support other scenarios such as configuration‑table validation, multi‑language global variable tracking, and art‑resource path reconstruction, providing a solid foundation for precise testing in game development.