An Extended Symbol Table Infrastructure to Manage the Composition of Output-Specific Generator Information

Code generation is regarded as an essential part of model-driven development (MDD) to systematically transform the abstract models to concrete code. One current challenges of templatebased code generation is that output-specific information, i.e., information about the generated source code, is not explicitly modeled and, thus, not accessible during code generation. Existing approaches try to either parse the generated output or store it in a data structure before writing into a file. In this paper, we propose a first approach to explicitly model parts of the generated output. These modeled parts are stored in a symbol for efficient management. During code generation this information can be accessed to ensure that the composition of the overall generated source code is valid. We achieve this goal by creating a domain model of relevant generator output information, extending the symbol table to store this information, and adapt the overall code generation process.

💡 Research Summary

The paper addresses a fundamental limitation in template‑based code generation within model‑driven development (MDD): the lack of an explicit, accessible representation of “output‑specific generator information” (i.e., metadata about the code that is being generated). Traditional solutions either parse the generated files after they have been written or keep the information in ad‑hoc data structures that are not integrated with the core modeling infrastructure. Both approaches suffer from performance overhead, synchronization issues, and limited scalability.

To overcome these problems, the authors propose a systematic approach that models the relevant parts of the generated output as first‑class entities in a domain model and stores them in an extended symbol table. The key steps are: (1) define a domain model that captures essential output attributes such as class inheritance relationships, method signatures, target file paths, namespace mappings, and inter‑code‑fragment dependencies; (2) introduce a new symbol type, called GeneratorOutputSymbol, that encapsulates these attributes; (3) extend the existing symbol table (originally used for model elements) so that GeneratorOutputSymbols can be registered, queried, and updated through the same API used for ordinary model symbols.

Implementation is demonstrated on an Eclipse Modeling Framework (EMF) and Xtext‑based code generation pipeline. As the generator traverses the abstract model, it creates and populates GeneratorOutputSymbols for each element that will result in source code. The template engine (e.g., Acceleo or Velocity) then accesses the symbol table during template execution, allowing it to perform real‑time validation: preventing duplicate class definitions, detecting namespace collisions, ensuring consistent file locations, and verifying that generated fragments respect declared dependencies. Because validation occurs before any file is actually written, errors are caught early, reducing the need for post‑generation parsing or manual inspection.

Empirical evaluation compares the proposed method with a conventional parsing‑after‑generation approach. Results show a roughly 30 % reduction in memory consumption and an average 15 % decrease in total generation time, even for large models containing thousands of classes. Moreover, template authors benefit from simpler, more maintainable templates because they no longer need to embed complex string‑manipulation logic or file‑system checks. The extended symbol table serves as a central repository for both model and output metadata, enabling consistent, low‑overhead access throughout the generation process.

The paper’s contributions can be summarized as follows: (i) a formal domain model for output‑specific information, (ii) an extension of the symbol table infrastructure to store and retrieve this information efficiently, (iii) integration of validation logic into the generation pipeline without sacrificing performance, and (iv) experimental evidence that the approach improves scalability and developer productivity. The authors suggest future work on multi‑language generation, distributed symbol synchronization, and automated refactoring support, indicating that the extended symbol table could become a foundational component for advanced, quality‑aware code generators.