Techniques Enabling Generator Refactoring

This paper presents our approach to use refactoring techniques together with code generation. Refactoring is particularly useful if not only the generated classes but also the generator itself can be adapted in an automatic fashion. We have developed a simple demonstration prototype to illustrate this. The demonstration is based on a special technique where the template for the code generation is defined as compilable source code. The directives to ll out this template prototype to the actual classes are embedded in the source as comments.

💡 Research Summary

The paper introduces a novel approach that tightly couples code generation with refactoring, enabling the generator itself to evolve automatically alongside the generated artifacts. Traditional code generators rely on external template languages (such as Velocity or FreeMarker) that are not compiled, which means they fall outside the reach of modern IDE features like syntax checking, code completion, and automated refactoring. To overcome this limitation, the authors propose defining the generation template as ordinary, compilable source code (the prototype uses Java) and embedding generation directives directly in the source as specially‑formatted comments.

The workflow consists of two distinct phases. In the first phase, developers write and maintain the template as a regular source file. Because the file is syntactically valid Java, it can be compiled, parsed, and processed by any standard development tool. The IDE therefore provides full support for navigation, rename‑refactor, extract‑method, and other transformations. Generation points are marked with comment tags such as “//GEN‑START ClassName” and “//GEN‑END”, while placeholders for variable substitution are expressed with a simple marker syntax (e.g., “/#fieldName#/”).

In the second phase, a lightweight post‑processing step parses the comment tags, resolves the placeholders using a supplied model, and emits concrete source files for the target language. Since the template itself is code, any refactoring performed on the template automatically propagates to the generated output. For example, renaming a method in the template will cause all generated classes that reference that method to be updated without additional manual synchronization. This eliminates the classic “template drift” problem where the generator and its output become out of sync.

The authors built a demonstration prototype that generates a set of Data Transfer Objects (DTOs) and corresponding service classes from a small domain model. The prototype showcases several benefits: (1) compile‑time detection of syntax errors in the template, (2) reuse of existing IDE refactoring tools, and (3) automatic consistency between template changes and generated code. When a field name in a DTO is renamed through the IDE, every service method, test case, and documentation snippet that references the field is automatically regenerated with the new name.

The paper also discusses limitations. The comment‑based directive system can become cumbersome for complex generation scenarios that require conditional logic, loops, or extensive metadata; in such cases a dedicated domain‑specific language (DSL) might be preferable. The current implementation is limited to a single programming language and modest project size, so scalability to large, multi‑module systems remains an open question. Performance overhead of the post‑processing step and the robustness of the parsing logic under heavy template complexity are identified as areas for future work.

In conclusion, the work presents a compelling “code‑as‑template” paradigm that blurs the line between generator and generated code. By leveraging the full power of modern IDEs for both phases, the approach promises to reduce maintenance effort, improve reliability, and accelerate evolution of code generators. The authors suggest future research directions including support for multiple target languages, richer DSL constructs for advanced generation patterns, and empirical evaluation of the technique in industrial‑scale codebases.