Code model hidden states reveal and enable program edits using static analysis
Program Bindings Inside Code Models
Software Engineering
Summary
Code language models can understand and fix programs, but it’s unclear how they represent a program’s structure inside their memory. The authors checked if information from standard program analysis tools, like how a program’s pieces relate, can describe and even change this hidden memory without retraining the model. They found that using this program structure helps keep the model’s answers correct better than simple position-based descriptions in most tested code models. They also showed they can edit parts of a program inside the model’s memory to make it behave as if the program itself changed.
What this means in practice
- •For software engineering teams: Enable debugging tools that can inspect and modify how code models internally represent programs to improve code suggestions and fixes.
- •For integrated development environment developers: Develop IDE features that let users interactively edit program bindings within code model completions, enhancing programming assistance accuracy.$Commercial implications: This paper enables creation of smarter coding assistants that can dynamically edit code logic, appealing to IDE vendors seeking advanced AI features.
Authors
Prateek Kumar Rajput, Yewei Song, Jacques Klein, Tegawendé F. Bissyandé
Abstract
Code language models complete, review, and repair programs without exposing the program structure encoded in their hidden states. In this paper, we test whether the hidden states of a code model can be described and edited using the information a compiler front end computes. For each token of a Python program, standard analyzers provide its position in the abstract syntax tree, its scope, its definition-use links, and its syntactic category. We fit a decomposition that expresses every hidden state of a frozen model as a sum of one term per token, each combining the token with this structural label, and we replace the model's own states with the decomposition at every layer while it predicts the output of a small program. If the model still answers correctly, the decomposition preserves the information the model uses. We apply this test to 14 open models, seven of them trained for code, and compare against a baseline decomposition of the same size built from token positions. The static-analysis decomposition preserves the model's answers better than the positional one in 10 of the 14 models, including six of the seven code models, and deleting the definition-use links from it removes most of that advantage on the two models tested. Editing the decomposition, for instance rebinding the argument of a call, makes StarCoder2-15B produce the answer of the edited program in 90 of 100 cases, compared with 19 for the positional baseline. The Qwen2.5 family is the exception on several measures. For most of the models tested, standard static analysis therefore provides both a description of what the hidden states encode about a program and a way to change it without retraining.