Step 308: All 8 generators produce language-appropriate output for 9 new AST node types (8/8 tests)

Phase 11c complete (80/80 tests). Added visitor implementations for
ClassDeclaration, InterfaceDeclaration, MethodDeclaration, GenericType,
TypeParameter, AsyncFunction, AwaitExpression, LambdaExpression, and
DecoratorAnnotation to Rust, Go, Java, JavaScript/TypeScript, and Elisp
generators. Each generator emits idiomatic syntax: Rust struct+impl/trait/async fn/.await/|closure|,
Go type struct/interface/func receiver/<-channel/func(), Java class extends/interface/CompletableFuture/(x)->/@annotation,
JS class extends/async function/await/(x)=>/class, Elisp cl-defstruct/cl-defgeneric/cl-defmethod/(lambda).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

editor/CMakeLists.txt

@@ -1847,4 +1847,9 @@ target_link_libraries(step307_test PRIVATE
     tree_sitter_cpp
     tree_sitter_elisp)
 
+# Step 308: Generator Updates + Phase 11c Integration Tests
+add_executable(step308_test tests/step308_test.cpp)
+target_include_directories(step308_test PRIVATE src)
+target_link_libraries(step308_test PRIVATE nlohmann_json::nlohmann_json)
+
 # Step 12: Dear ImGui shell scaffolding created (main.cpp exists but not built due to dependencies)

editor/src/ast/ElispGenerator.h

@@ -1,5 +1,8 @@
 #pragma once
 #include "ProjectionGenerator.h"
+#include "ClassDeclaration.h"
+#include "GenericType.h"
+#include "AsyncNodes.h"
 #include "../SemannoAnnotationImpl.h"
 
 class ElispGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<ElispGenerator> {
@@ -489,6 +492,123 @@ public:
         return type->typeName;
     }
 
+    // --- New AST node visitors (Step 308) ---
+
+    std::string visitClassDeclaration(const ASTNode* node) override {
+        auto* cls = static_cast<const ClassDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = cls->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "(cl-defstruct " << cls->name;
+        if (!cls->superClass.empty()) oss << "\n  (:include " << cls->superClass << ")";
+        auto fields = cls->getChildren("fields");
+        for (const auto* f : fields) {
+            auto* var = static_cast<const Variable*>(f);
+            oss << "\n  (" << var->name << " nil)";
+        }
+        oss << ")\n";
+        auto methods = cls->getChildren("methods");
+        for (const auto* m : methods) oss << "\n" << generate(m);
+        return oss.str();
+    }
+
+    std::string visitInterfaceDeclaration(const ASTNode* node) override {
+        auto* iface = static_cast<const InterfaceDeclaration*>(node);
+        std::ostringstream oss;
+        oss << "; Interface: " << iface->name << "\n";
+        auto methods = iface->getChildren("methods");
+        for (const auto* m : methods) {
+            auto* meth = static_cast<const MethodDeclaration*>(m);
+            oss << "(cl-defgeneric " << meth->name << " (self))\n";
+        }
+        return oss.str();
+    }
+
+    std::string visitMethodDeclaration(const ASTNode* node) override {
+        auto* meth = static_cast<const MethodDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = meth->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "(cl-defmethod " << meth->name << " ((self";
+        if (!meth->className.empty()) oss << " " << meth->className;
+        oss << ")";
+        auto params = meth->getChildren("parameters");
+        for (const auto* p : params) oss << " " << visitParameter(static_cast<const Parameter*>(p));
+        oss << ")\n";
+        auto body = meth->getChildren("body");
+        if (body.empty()) {
+            oss << "  nil)\n";
+        } else {
+            for (const auto* s : body) oss << "  " << generate(s) << "\n";
+            oss << ")\n";
+        }
+        return oss.str();
+    }
+
+    std::string visitGenericType(const ASTNode* node) override {
+        auto* gen = static_cast<const GenericType*>(node);
+        return gen->baseName;
+    }
+
+    std::string visitTypeParameter(const ASTNode* node) override {
+        auto* tp = static_cast<const TypeParameter*>(node);
+        return tp->name;
+    }
+
+    std::string visitAsyncFunction(const ASTNode* node) override {
+        auto* af = static_cast<const AsyncFunction*>(node);
+        std::ostringstream oss;
+        auto annotations = af->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "(defun " << af->name << " (";
+        auto params = af->getChildren("parameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << " ";
+            oss << visitParameter(static_cast<const Parameter*>(params[i]));
+        }
+        oss << ")\n";
+        oss << "  ;; async\n";
+        auto body = af->getChildren("body");
+        if (body.empty()) {
+            oss << "  nil)\n";
+        } else {
+            for (const auto* s : body) oss << "  " << generate(s) << "\n";
+            oss << ")\n";
+        }
+        return oss.str();
+    }
+
+    std::string visitAwaitExpression(const ASTNode* node) override {
+        auto* aw = static_cast<const AwaitExpression*>(node);
+        auto* expr = aw->getChild("expression");
+        return "(async-get " + (expr ? generate(expr) : "nil") + ")";
+    }
+
+    std::string visitLambdaExpression(const ASTNode* node) override {
+        auto* lam = static_cast<const LambdaExpression*>(node);
+        std::ostringstream oss;
+        oss << "(lambda (";
+        auto params = lam->getChildren("parameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << " ";
+            oss << static_cast<const Parameter*>(params[i])->name;
+        }
+        oss << ")";
+        auto body = lam->getChildren("body");
+        if (body.empty()) {
+            oss << " nil";
+        } else {
+            for (const auto* s : body) oss << "\n  " << generate(s);
+        }
+        oss << ")";
+        return oss.str();
+    }
+
+    std::string visitDecoratorAnnotation(const ASTNode* node) override {
+        auto* dec = static_cast<const DecoratorAnnotation*>(node);
+        return "; @" + dec->name;
+    }
+
     std::string visitDerefStrategy(const DerefStrategy* annotation) override {
         // Convert deref strategy to Elisp annotation/comment
         if (annotation->strategy == "batched") {

editor/src/ast/GoGenerator.h

@@ -1,6 +1,9 @@
 #pragma once
 #include "ProjectionGenerator.h"
 #include "Import.h"
+#include "ClassDeclaration.h"
+#include "GenericType.h"
+#include "AsyncNodes.h"
 #include "../SemannoAnnotationImpl.h"
 
 class GoGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<GoGenerator> {
@@ -404,6 +407,118 @@ public:
         return type->typeName;
     }
 
+    // --- New AST node visitors (Step 308) ---
+
+    std::string visitClassDeclaration(const ASTNode* node) override {
+        auto* cls = static_cast<const ClassDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = cls->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "type " << cls->name << " struct {\n";
+        auto fields = cls->getChildren("fields");
+        for (const auto* f : fields)
+            oss << "    " << generate(f) << "\n";
+        oss << "}\n";
+        auto methods = cls->getChildren("methods");
+        for (const auto* m : methods) oss << "\n" << generate(m);
+        return oss.str();
+    }
+
+    std::string visitInterfaceDeclaration(const ASTNode* node) override {
+        auto* iface = static_cast<const InterfaceDeclaration*>(node);
+        std::ostringstream oss;
+        oss << "type " << iface->name << " interface {\n";
+        auto methods = iface->getChildren("methods");
+        for (const auto* m : methods) {
+            auto* meth = static_cast<const MethodDeclaration*>(m);
+            oss << "    " << meth->name << "()\n";
+        }
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitMethodDeclaration(const ASTNode* node) override {
+        auto* meth = static_cast<const MethodDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = meth->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "func ";
+        if (!meth->isStatic && !meth->className.empty()) {
+            oss << "(" << receiverVar(meth->className) << " *" << meth->className << ") ";
+        }
+        oss << meth->name << "(";
+        emitParameters(oss, meth->getChildren("parameters"));
+        oss << ")";
+        auto retType = meth->getChild("returnType");
+        if (retType) oss << " " << generate(retType);
+        oss << " {\n";
+        emitBody(oss, meth->getChildren("body"), "    ");
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitGenericType(const ASTNode* node) override {
+        auto* gen = static_cast<const GenericType*>(node);
+        std::ostringstream oss;
+        oss << gen->baseName << "[";
+        auto params = gen->getChildren("typeParameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << generate(params[i]);
+        }
+        oss << "]";
+        return oss.str();
+    }
+
+    std::string visitTypeParameter(const ASTNode* node) override {
+        auto* tp = static_cast<const TypeParameter*>(node);
+        if (!tp->constraint.empty()) return tp->name + " " + tp->constraint;
+        return tp->name;
+    }
+
+    std::string visitAsyncFunction(const ASTNode* node) override {
+        auto* af = static_cast<const AsyncFunction*>(node);
+        std::ostringstream oss;
+        auto annotations = af->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "func " << af->name << "(";
+        emitParameters(oss, af->getChildren("parameters"));
+        oss << ")";
+        auto retType = af->getChild("returnType");
+        if (retType) oss << " " << generate(retType);
+        oss << " {\n";
+        oss << "    // async: use goroutine\n";
+        emitBody(oss, af->getChildren("body"), "    ");
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitAwaitExpression(const ASTNode* node) override {
+        auto* aw = static_cast<const AwaitExpression*>(node);
+        auto* expr = aw->getChild("expression");
+        return "<-" + (expr ? generate(expr) : "/* missing */");
+    }
+
+    std::string visitLambdaExpression(const ASTNode* node) override {
+        auto* lam = static_cast<const LambdaExpression*>(node);
+        std::ostringstream oss;
+        oss << "func(";
+        auto params = lam->getChildren("parameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << visitParameter(static_cast<const Parameter*>(params[i]));
+        }
+        oss << ") {\n";
+        emitBody(oss, lam->getChildren("body"), "    ");
+        oss << "}";
+        return oss.str();
+    }
+
+    std::string visitDecoratorAnnotation(const ASTNode* node) override {
+        auto* dec = static_cast<const DecoratorAnnotation*>(node);
+        return "// @" + dec->name;
+    }
+
     std::string visitDerefStrategy(const DerefStrategy* annotation) override {
         return "// @deref(" + annotation->strategy + ")";
     }

editor/src/ast/JavaGenerator.h

@@ -1,6 +1,9 @@
 #pragma once
 #include "ProjectionGenerator.h"
 #include "Import.h"
+#include "ClassDeclaration.h"
+#include "GenericType.h"
+#include "AsyncNodes.h"
 #include "../SemannoAnnotationImpl.h"
 #include <map>
 #include <unordered_map>
@@ -439,6 +442,151 @@ public:
         return type->typeName;
     }
 
+    // --- New AST node visitors (Step 308) ---
+
+    std::string visitClassDeclaration(const ASTNode* node) override {
+        auto* cls = static_cast<const ClassDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = cls->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        if (cls->isAbstract) oss << "abstract ";
+        oss << "class " << cls->name;
+        if (!cls->superClass.empty()) oss << " extends " << cls->superClass;
+        auto interfaces = cls->getChildren("interfaces");
+        if (!interfaces.empty()) {
+            oss << " implements ";
+            for (size_t i = 0; i < interfaces.size(); ++i) {
+                if (i > 0) oss << ", ";
+                oss << generate(interfaces[i]);
+            }
+        }
+        oss << " {\n";
+        auto fields = cls->getChildren("fields");
+        for (const auto* f : fields)
+            oss << "    " << generate(f) << "\n";
+        if (!fields.empty() && !cls->getChildren("methods").empty()) oss << "\n";
+        auto methods = cls->getChildren("methods");
+        for (const auto* m : methods) oss << generate(m) << "\n";
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitInterfaceDeclaration(const ASTNode* node) override {
+        auto* iface = static_cast<const InterfaceDeclaration*>(node);
+        std::ostringstream oss;
+        oss << "interface " << iface->name << " {\n";
+        auto methods = iface->getChildren("methods");
+        for (const auto* m : methods) {
+            auto* meth = static_cast<const MethodDeclaration*>(m);
+            oss << "    void " << meth->name << "();\n";
+        }
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitMethodDeclaration(const ASTNode* node) override {
+        auto* meth = static_cast<const MethodDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = meth->getChildren("annotations");
+        for (const auto* a : annotations) oss << "    " << generate(a) << "\n";
+        oss << "    ";
+        if (!meth->visibility.empty()) oss << meth->visibility << " ";
+        if (meth->isStatic) oss << "static ";
+        std::string returnType = "void";
+        auto retType = meth->getChild("returnType");
+        if (retType) returnType = generate(retType);
+        oss << returnType << " " << meth->name << "(";
+        emitParameters(oss, meth->getChildren("parameters"));
+        oss << ")";
+        if (meth->isOverride) oss << " /* @Override */";
+        auto body = meth->getChildren("body");
+        if (body.empty()) {
+            oss << " {}\n";
+        } else {
+            oss << " {\n";
+            emitBody(oss, body, "        ");
+            oss << "    }\n";
+        }
+        return oss.str();
+    }
+
+    std::string visitGenericType(const ASTNode* node) override {
+        auto* gen = static_cast<const GenericType*>(node);
+        std::ostringstream oss;
+        oss << gen->baseName << "<";
+        auto params = gen->getChildren("typeParameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << generate(params[i]);
+        }
+        oss << ">";
+        return oss.str();
+    }
+
+    std::string visitTypeParameter(const ASTNode* node) override {
+        auto* tp = static_cast<const TypeParameter*>(node);
+        if (!tp->constraint.empty()) return tp->name + " extends " + tp->constraint;
+        return tp->name;
+    }
+
+    std::string visitAsyncFunction(const ASTNode* node) override {
+        auto* af = static_cast<const AsyncFunction*>(node);
+        std::ostringstream oss;
+        auto annotations = af->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "CompletableFuture<Void> " << af->name << "(";
+        emitParameters(oss, af->getChildren("parameters"));
+        oss << ") {\n";
+        emitBody(oss, af->getChildren("body"), "    ");
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitAwaitExpression(const ASTNode* node) override {
+        auto* aw = static_cast<const AwaitExpression*>(node);
+        auto* expr = aw->getChild("expression");
+        return (expr ? generate(expr) : "/* missing */") + ".get()";
+    }
+
+    std::string visitLambdaExpression(const ASTNode* node) override {
+        auto* lam = static_cast<const LambdaExpression*>(node);
+        std::ostringstream oss;
+        oss << "(";
+        auto params = lam->getChildren("parameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << static_cast<const Parameter*>(params[i])->name;
+        }
+        oss << ") -> ";
+        auto body = lam->getChildren("body");
+        if (body.size() == 1) {
+            oss << generate(body[0]);
+        } else if (body.empty()) {
+            oss << "{}";
+        } else {
+            oss << "{ ";
+            for (const auto* s : body) oss << generate(s) << "; ";
+            oss << "}";
+        }
+        return oss.str();
+    }
+
+    std::string visitDecoratorAnnotation(const ASTNode* node) override {
+        auto* dec = static_cast<const DecoratorAnnotation*>(node);
+        std::ostringstream oss;
+        oss << "@" << dec->name;
+        auto args = dec->getChildren("arguments");
+        if (!args.empty()) {
+            oss << "(";
+            for (size_t i = 0; i < args.size(); ++i) {
+                if (i > 0) oss << ", ";
+                oss << generate(args[i]);
+            }
+            oss << ")";
+        }
+        return oss.str();
+    }
+
     std::string visitDerefStrategy(const DerefStrategy* annotation) override {
         return "// @deref(" + annotation->strategy + ")";
     }

editor/src/ast/JavaScriptGenerator.h

@@ -1,6 +1,9 @@
 #pragma once
 #include "ProjectionGenerator.h"
 #include "Import.h"
+#include "ClassDeclaration.h"
+#include "GenericType.h"
+#include "AsyncNodes.h"
 #include "../SemannoAnnotationImpl.h"
 #include <unordered_map>
 #include <unordered_set>
@@ -446,6 +449,133 @@ public:
         return type->typeName;
     }
 
+    // --- New AST node visitors (Step 308) ---
+
+    std::string visitClassDeclaration(const ASTNode* node) override {
+        auto* cls = static_cast<const ClassDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = cls->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "class " << cls->name;
+        if (!cls->superClass.empty()) oss << " extends " << cls->superClass;
+        oss << " {\n";
+        auto fields = cls->getChildren("fields");
+        for (const auto* f : fields)
+            oss << "    " << generate(f) << "\n";
+        auto methods = cls->getChildren("methods");
+        for (const auto* m : methods) oss << generate(m);
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitInterfaceDeclaration(const ASTNode* node) override {
+        auto* iface = static_cast<const InterfaceDeclaration*>(node);
+        std::ostringstream oss;
+        oss << "class " << iface->name << " {\n";
+        auto methods = iface->getChildren("methods");
+        for (const auto* m : methods) {
+            auto* meth = static_cast<const MethodDeclaration*>(m);
+            oss << "    " << meth->name << "() { throw new Error('not implemented'); }\n";
+        }
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitMethodDeclaration(const ASTNode* node) override {
+        auto* meth = static_cast<const MethodDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = meth->getChildren("annotations");
+        for (const auto* a : annotations) oss << "    " << generate(a) << "\n";
+        oss << "    ";
+        if (meth->isStatic) oss << "static ";
+        oss << meth->name << "(";
+        emitParameters(oss, meth->getChildren("parameters"));
+        oss << ")";
+        if (includeTypes_) {
+            auto retType = meth->getChild("returnType");
+            if (retType) oss << ": " << generate(retType);
+        }
+        auto body = meth->getChildren("body");
+        if (body.empty()) {
+            oss << " {}\n";
+        } else {
+            oss << " {\n";
+            emitBody(oss, body, "        ");
+            oss << "    }\n";
+        }
+        return oss.str();
+    }
+
+    std::string visitGenericType(const ASTNode* node) override {
+        auto* gen = static_cast<const GenericType*>(node);
+        std::ostringstream oss;
+        oss << gen->baseName << "<";
+        auto params = gen->getChildren("typeParameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << generate(params[i]);
+        }
+        oss << ">";
+        return oss.str();
+    }
+
+    std::string visitTypeParameter(const ASTNode* node) override {
+        auto* tp = static_cast<const TypeParameter*>(node);
+        return tp->name;
+    }
+
+    std::string visitAsyncFunction(const ASTNode* node) override {
+        auto* af = static_cast<const AsyncFunction*>(node);
+        std::ostringstream oss;
+        auto annotations = af->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "async function " << af->name << "(";
+        emitParameters(oss, af->getChildren("parameters"));
+        oss << ")";
+        if (includeTypes_) {
+            auto retType = af->getChild("returnType");
+            if (retType) oss << ": Promise<" << generate(retType) << ">";
+        }
+        oss << " {\n";
+        emitBody(oss, af->getChildren("body"), "    ");
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitAwaitExpression(const ASTNode* node) override {
+        auto* aw = static_cast<const AwaitExpression*>(node);
+        auto* expr = aw->getChild("expression");
+        return "await " + (expr ? generate(expr) : "undefined");
+    }
+
+    std::string visitLambdaExpression(const ASTNode* node) override {
+        auto* lam = static_cast<const LambdaExpression*>(node);
+        std::ostringstream oss;
+        oss << "(";
+        auto params = lam->getChildren("parameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << static_cast<const Parameter*>(params[i])->name;
+        }
+        oss << ") => ";
+        auto body = lam->getChildren("body");
+        if (body.size() == 1) {
+            oss << generate(body[0]);
+        } else if (body.empty()) {
+            oss << "{}";
+        } else {
+            oss << "{ ";
+            for (const auto* s : body) oss << generate(s) << "; ";
+            oss << "}";
+        }
+        return oss.str();
+    }
+
+    std::string visitDecoratorAnnotation(const ASTNode* node) override {
+        auto* dec = static_cast<const DecoratorAnnotation*>(node);
+        return "// @" + dec->name;
+    }
+
     std::string visitDerefStrategy(const DerefStrategy* annotation) override {
         return "// @deref(" + annotation->strategy + ")";
     }

editor/src/ast/RustGenerator.h

@@ -1,6 +1,9 @@
 #pragma once
 #include "ProjectionGenerator.h"
 #include "Import.h"
+#include "ClassDeclaration.h"
+#include "GenericType.h"
+#include "AsyncNodes.h"
 #include "../SemannoAnnotationImpl.h"
 
 class RustGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<RustGenerator> {
@@ -419,6 +422,134 @@ public:
         return type->typeName;
     }
 
+    // --- New AST node visitors (Step 308) ---
+
+    std::string visitClassDeclaration(const ASTNode* node) override {
+        auto* cls = static_cast<const ClassDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = cls->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "struct " << cls->name << " {\n";
+        auto fields = cls->getChildren("fields");
+        for (const auto* f : fields)
+            oss << "    " << generate(f) << "\n";
+        oss << "}\n";
+        auto methods = cls->getChildren("methods");
+        if (!methods.empty()) {
+            oss << "\nimpl " << cls->name << " {\n";
+            for (const auto* m : methods) oss << generate(m);
+            oss << "}\n";
+        }
+        return oss.str();
+    }
+
+    std::string visitInterfaceDeclaration(const ASTNode* node) override {
+        auto* iface = static_cast<const InterfaceDeclaration*>(node);
+        std::ostringstream oss;
+        oss << "trait " << iface->name << " {\n";
+        auto methods = iface->getChildren("methods");
+        for (const auto* m : methods) {
+            auto* meth = static_cast<const MethodDeclaration*>(m);
+            oss << "    fn " << meth->name << "(&self);\n";
+        }
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitMethodDeclaration(const ASTNode* node) override {
+        auto* meth = static_cast<const MethodDeclaration*>(node);
+        std::ostringstream oss;
+        auto annotations = meth->getChildren("annotations");
+        for (const auto* a : annotations) oss << "    " << generate(a) << "\n";
+        oss << "    fn " << meth->name << "(";
+        if (!meth->isStatic) oss << "&self";
+        auto params = meth->getChildren("parameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (!meth->isStatic || i > 0) oss << ", ";
+            oss << visitParameter(static_cast<const Parameter*>(params[i]));
+        }
+        oss << ")";
+        auto retType = meth->getChild("returnType");
+        if (retType) oss << " -> " << generate(retType);
+        auto body = meth->getChildren("body");
+        if (body.empty()) {
+            oss << " {}\n";
+        } else {
+            oss << " {\n";
+            emitBody(oss, body, "        ");
+            oss << "    }\n";
+        }
+        return oss.str();
+    }
+
+    std::string visitGenericType(const ASTNode* node) override {
+        auto* gen = static_cast<const GenericType*>(node);
+        std::ostringstream oss;
+        oss << gen->baseName << "<";
+        auto params = gen->getChildren("typeParameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << generate(params[i]);
+        }
+        oss << ">";
+        return oss.str();
+    }
+
+    std::string visitTypeParameter(const ASTNode* node) override {
+        auto* tp = static_cast<const TypeParameter*>(node);
+        return tp->name;
+    }
+
+    std::string visitAsyncFunction(const ASTNode* node) override {
+        auto* af = static_cast<const AsyncFunction*>(node);
+        std::ostringstream oss;
+        auto annotations = af->getChildren("annotations");
+        for (const auto* a : annotations) oss << generate(a) << "\n";
+        oss << "async fn " << af->name << "(";
+        emitParameters(oss, af->getChildren("parameters"));
+        oss << ")";
+        auto retType = af->getChild("returnType");
+        if (retType) oss << " -> " << generate(retType);
+        oss << " {\n";
+        emitBody(oss, af->getChildren("body"), "    ");
+        oss << "}\n";
+        return oss.str();
+    }
+
+    std::string visitAwaitExpression(const ASTNode* node) override {
+        auto* aw = static_cast<const AwaitExpression*>(node);
+        auto* expr = aw->getChild("expression");
+        return (expr ? generate(expr) : "/* missing */") + ".await";
+    }
+
+    std::string visitLambdaExpression(const ASTNode* node) override {
+        auto* lam = static_cast<const LambdaExpression*>(node);
+        std::ostringstream oss;
+        oss << "|";
+        auto params = lam->getChildren("parameters");
+        for (size_t i = 0; i < params.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << static_cast<const Parameter*>(params[i])->name;
+        }
+        oss << "| ";
+        auto body = lam->getChildren("body");
+        if (body.size() == 1) {
+            oss << generate(body[0]);
+        } else if (body.empty()) {
+            oss << "()";
+        } else {
+            oss << "{ ";
+            for (const auto* s : body) oss << generate(s) << " ";
+            oss << "}";
+        }
+        return oss.str();
+    }
+
+    std::string visitDecoratorAnnotation(const ASTNode* node) override {
+        auto* dec = static_cast<const DecoratorAnnotation*>(node);
+        return "// @" + dec->name;
+    }
+
     std::string visitDerefStrategy(const DerefStrategy* annotation) override {
         return "// @deref(" + annotation->strategy + ")";
     }

editor/tests/step308_test.cpp

@@ -0,0 +1,422 @@
+// Step 308: Generator Updates + Phase 11c Integration Tests (8 tests)
+// Verifies all 8 generators produce language-appropriate output for 9 new
+// AST node types: ClassDeclaration, InterfaceDeclaration, MethodDeclaration,
+// GenericType, TypeParameter, AsyncFunction, AwaitExpression, LambdaExpression,
+// DecoratorAnnotation.
+
+#include "ast/ClassDeclaration.h"
+#include "ast/GenericType.h"
+#include "ast/AsyncNodes.h"
+#include "ast/Serialization.h"
+#include "ast/PythonGenerator.h"
+#include "ast/CppGenerator.h"
+#include "ast/RustGenerator.h"
+#include "ast/GoGenerator.h"
+#include "ast/JavaGenerator.h"
+#include "ast/JavaScriptGenerator.h"
+#include "ast/ElispGenerator.h"
+#include "ast/Module.h"
+#include "ast/Function.h"
+#include "ast/Variable.h"
+#include "ast/Statement.h"
+#include "ast/Expression.h"
+#include <nlohmann/json.hpp>
+#include <iostream>
+#include <string>
+#include <memory>
+
+using json = nlohmann::json;
+
+static int passed = 0, failed = 0;
+#define TEST(name) { std::cout << "  " << #name << "... "; }
+#define PASS() { std::cout << "PASS\n"; ++passed; }
+#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; }
+#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {}
+
+// Helper: build a class with one method and one field
+static std::unique_ptr<ClassDeclaration> makeTestClass() {
+    auto cls = std::make_unique<ClassDeclaration>("cls1", "Animal");
+    cls->superClass = "LivingThing";
+
+    auto field = std::make_unique<Variable>("f1", "name");
+    cls->addChild("fields", field.release());
+
+    auto meth = std::make_unique<MethodDeclaration>("m1", "speak");
+    meth->className = "Animal";
+    meth->isVirtual = true;
+    auto retStmt = std::make_unique<Return>();
+    retStmt->id = "r1";
+    auto retVal = std::make_unique<StringLiteral>("s1", "hello");
+    retStmt->addChild("value", retVal.release());
+    meth->addChild("body", retStmt.release());
+    cls->addChild("methods", meth.release());
+
+    return cls;
+}
+
+// Helper: build an async function with await
+static std::unique_ptr<AsyncFunction> makeTestAsync() {
+    auto af = std::make_unique<AsyncFunction>("af1", "fetchData");
+    auto await = std::make_unique<AwaitExpression>("aw1");
+    auto call = std::make_unique<FunctionCall>();
+    call->id = "fc1";
+    call->functionName = "getData";
+    await->addChild("expression", call.release());
+    auto stmt = std::make_unique<ExpressionStatement>();
+    stmt->id = "es1";
+    stmt->addChild("expression", await.release());
+    af->addChild("body", stmt.release());
+    return af;
+}
+
+// Helper: build a lambda expression
+static std::unique_ptr<LambdaExpression> makeTestLambda() {
+    auto lam = std::make_unique<LambdaExpression>("lam1");
+    lam->captureList = {"x", "y"};
+    auto paramA = std::make_unique<Parameter>("p1", "a");
+    auto paramB = std::make_unique<Parameter>("p2", "b");
+    lam->addChild("parameters", paramA.release());
+    lam->addChild("parameters", paramB.release());
+    auto body = std::make_unique<BinaryOperation>("bo1", "+");
+    body->addChild("left", new VariableReference("vr1", "a"));
+    body->addChild("right", new VariableReference("vr2", "b"));
+    lam->addChild("body", body.release());
+    return lam;
+}
+
+// 1. Parse class → generate → language-appropriate class syntax for all generators
+void test_class_all_generators() {
+    TEST(class_all_generators);
+    auto cls = makeTestClass();
+
+    PythonGenerator pyGen;
+    CppGenerator cppGen;
+    RustGenerator rustGen;
+    GoGenerator goGen;
+    JavaGenerator javaGen;
+    JavaScriptGenerator jsGen;
+    ElispGenerator elGen;
+    TypeScriptGenerator tsGen;
+
+    std::string py = pyGen.generate(cls.get());
+    std::string cpp = cppGen.generate(cls.get());
+    std::string rs = rustGen.generate(cls.get());
+    std::string go = goGen.generate(cls.get());
+    std::string java = javaGen.generate(cls.get());
+    std::string js = jsGen.generate(cls.get());
+    std::string el = elGen.generate(cls.get());
+    std::string ts = tsGen.generate(cls.get());
+
+    CHECK(py.find("class Animal") != std::string::npos, "Python: missing 'class Animal'");
+    CHECK(cpp.find("class Animal") != std::string::npos, "C++: missing 'class Animal'");
+    CHECK(rs.find("struct Animal") != std::string::npos, "Rust: missing 'struct Animal'");
+    CHECK(go.find("type Animal struct") != std::string::npos, "Go: missing 'type Animal struct'");
+    CHECK(java.find("class Animal") != std::string::npos, "Java: missing 'class Animal'");
+    CHECK(js.find("class Animal") != std::string::npos, "JS: missing 'class Animal'");
+    CHECK(el.find("cl-defstruct Animal") != std::string::npos, "Elisp: missing 'cl-defstruct Animal'");
+    CHECK(ts.find("class Animal") != std::string::npos, "TS: missing 'class Animal'");
+
+    // Verify superclass/inheritance in each
+    CHECK(py.find("LivingThing") != std::string::npos, "Python: missing superclass");
+    CHECK(cpp.find("public LivingThing") != std::string::npos, "C++: missing superclass");
+    CHECK(java.find("extends LivingThing") != std::string::npos, "Java: missing extends");
+    CHECK(js.find("extends LivingThing") != std::string::npos, "JS: missing extends");
+    PASS();
+}
+
+// 2. Async roundtrip: async function + await in all generators
+void test_async_all_generators() {
+    TEST(async_all_generators);
+    auto af = makeTestAsync();
+
+    PythonGenerator pyGen;
+    CppGenerator cppGen;
+    RustGenerator rustGen;
+    GoGenerator goGen;
+    JavaGenerator javaGen;
+    JavaScriptGenerator jsGen;
+    ElispGenerator elGen;
+
+    std::string py = pyGen.generate(af.get());
+    std::string cpp = cppGen.generate(af.get());
+    std::string rs = rustGen.generate(af.get());
+    std::string go = goGen.generate(af.get());
+    std::string java = javaGen.generate(af.get());
+    std::string js = jsGen.generate(af.get());
+    std::string el = elGen.generate(af.get());
+
+    CHECK(py.find("async def") != std::string::npos, "Python: missing 'async def'");
+    CHECK(py.find("await") != std::string::npos, "Python: missing 'await'");
+    CHECK(cpp.find("std::future") != std::string::npos, "C++: missing 'std::future'");
+    CHECK(cpp.find("co_await") != std::string::npos, "C++: missing 'co_await'");
+    CHECK(rs.find("async fn") != std::string::npos, "Rust: missing 'async fn'");
+    CHECK(rs.find(".await") != std::string::npos, "Rust: missing '.await'");
+    CHECK(go.find("func fetchData") != std::string::npos, "Go: missing 'func fetchData'");
+    CHECK(java.find("CompletableFuture") != std::string::npos, "Java: missing 'CompletableFuture'");
+    CHECK(js.find("async function") != std::string::npos, "JS: missing 'async function'");
+    CHECK(js.find("await") != std::string::npos, "JS: missing 'await'");
+    CHECK(el.find("async") != std::string::npos, "Elisp: missing 'async' comment");
+    PASS();
+}
+
+// 3. Generic type roundtrip
+void test_generic_type_all_generators() {
+    TEST(generic_type_all_generators);
+    auto gen = std::make_unique<GenericType>("g1", "List");
+    auto tp = std::make_unique<TypeParameter>("tp1", "T");
+    gen->addChild("typeParameters", tp.release());
+
+    PythonGenerator pyGen;
+    CppGenerator cppGen;
+    RustGenerator rustGen;
+    GoGenerator goGen;
+    JavaGenerator javaGen;
+    JavaScriptGenerator jsGen;
+
+    std::string py = pyGen.generate(gen.get());
+    std::string cpp = cppGen.generate(gen.get());
+    std::string rs = rustGen.generate(gen.get());
+    std::string go = goGen.generate(gen.get());
+    std::string java = javaGen.generate(gen.get());
+    std::string js = jsGen.generate(gen.get());
+
+    CHECK(py.find("List[T]") != std::string::npos, "Python: missing 'List[T]'");
+    CHECK(cpp.find("List<T>") != std::string::npos, "C++: missing 'List<T>'");
+    CHECK(rs.find("List<T>") != std::string::npos, "Rust: missing 'List<T>'");
+    CHECK(go.find("List[T]") != std::string::npos, "Go: missing 'List[T]'");
+    CHECK(java.find("List<T>") != std::string::npos, "Java: missing 'List<T>'");
+    CHECK(js.find("List<T>") != std::string::npos, "JS: missing 'List<T>'");
+    PASS();
+}
+
+// 4. Lambda/closure roundtrip
+void test_lambda_all_generators() {
+    TEST(lambda_all_generators);
+    auto lam = makeTestLambda();
+
+    PythonGenerator pyGen;
+    CppGenerator cppGen;
+    RustGenerator rustGen;
+    GoGenerator goGen;
+    JavaGenerator javaGen;
+    JavaScriptGenerator jsGen;
+    ElispGenerator elGen;
+
+    std::string py = pyGen.generate(lam.get());
+    std::string cpp = cppGen.generate(lam.get());
+    std::string rs = rustGen.generate(lam.get());
+    std::string go = goGen.generate(lam.get());
+    std::string java = javaGen.generate(lam.get());
+    std::string js = jsGen.generate(lam.get());
+    std::string el = elGen.generate(lam.get());
+
+    CHECK(py.find("lambda") != std::string::npos, "Python: missing 'lambda'");
+    CHECK(cpp.find("[x, y]") != std::string::npos, "C++: missing '[x, y]' capture");
+    CHECK(rs.find("|a, b|") != std::string::npos, "Rust: missing '|a, b|' closure");
+    CHECK(go.find("func(") != std::string::npos, "Go: missing 'func(' lambda");
+    CHECK(java.find("->") != std::string::npos, "Java: missing '->' lambda");
+    CHECK(js.find("=>") != std::string::npos, "JS: missing '=>' arrow");
+    CHECK(el.find("(lambda") != std::string::npos, "Elisp: missing '(lambda'");
+    PASS();
+}
+
+// 5. Decorator roundtrip (Python → Python, Java @annotation)
+void test_decorator_roundtrip() {
+    TEST(decorator_roundtrip);
+    auto dec = std::make_unique<DecoratorAnnotation>("dec1", "Override");
+
+    PythonGenerator pyGen;
+    JavaGenerator javaGen;
+    CppGenerator cppGen;
+    ElispGenerator elGen;
+
+    std::string py = pyGen.generate(dec.get());
+    std::string java = javaGen.generate(dec.get());
+    std::string cpp = cppGen.generate(dec.get());
+    std::string el = elGen.generate(dec.get());
+
+    CHECK(py.find("@Override") != std::string::npos, "Python: missing '@Override'");
+    CHECK(java.find("@Override") != std::string::npos, "Java: missing '@Override'");
+    CHECK(cpp.find("@Override") != std::string::npos, "C++: missing '@Override' comment");
+    CHECK(el.find("@Override") != std::string::npos, "Elisp: missing '@Override' comment");
+    PASS();
+}
+
+// 6. Class with methods and fields — verify structure
+void test_class_with_methods_and_fields() {
+    TEST(class_with_methods_and_fields);
+    auto cls = makeTestClass();
+
+    RustGenerator rustGen;
+    JavaGenerator javaGen;
+    GoGenerator goGen;
+
+    std::string rs = rustGen.generate(cls.get());
+    std::string java = javaGen.generate(cls.get());
+    std::string go = goGen.generate(cls.get());
+
+    // Rust: struct + impl block
+    CHECK(rs.find("struct Animal") != std::string::npos, "Rust: missing struct");
+    CHECK(rs.find("impl Animal") != std::string::npos, "Rust: missing impl block");
+    CHECK(rs.find("fn speak") != std::string::npos, "Rust: missing method");
+
+    // Java: class + extends + method
+    CHECK(java.find("extends LivingThing") != std::string::npos, "Java: missing extends");
+    CHECK(java.find("speak") != std::string::npos, "Java: missing method name");
+
+    // Go: type struct + func method
+    CHECK(go.find("type Animal struct") != std::string::npos, "Go: missing type struct");
+    CHECK(go.find("func") != std::string::npos, "Go: missing func keyword");
+    CHECK(go.find("speak") != std::string::npos, "Go: missing method name");
+    PASS();
+}
+
+// 7. Interface with abstract methods
+void test_interface_all_generators() {
+    TEST(interface_all_generators);
+    auto iface = std::make_unique<InterfaceDeclaration>("if1", "Drawable");
+    auto m1 = std::make_unique<MethodDeclaration>("m1", "draw");
+    auto m2 = std::make_unique<MethodDeclaration>("m2", "resize");
+    iface->addChild("methods", m1.release());
+    iface->addChild("methods", m2.release());
+
+    PythonGenerator pyGen;
+    CppGenerator cppGen;
+    RustGenerator rustGen;
+    GoGenerator goGen;
+    JavaGenerator javaGen;
+    JavaScriptGenerator jsGen;
+    ElispGenerator elGen;
+
+    std::string py = pyGen.generate(iface.get());
+    std::string cpp = cppGen.generate(iface.get());
+    std::string rs = rustGen.generate(iface.get());
+    std::string go = goGen.generate(iface.get());
+    std::string java = javaGen.generate(iface.get());
+    std::string js = jsGen.generate(iface.get());
+    std::string el = elGen.generate(iface.get());
+
+    CHECK(py.find("ABC") != std::string::npos, "Python: missing ABC base");
+    CHECK(cpp.find("class Drawable") != std::string::npos, "C++: missing class");
+    CHECK(rs.find("trait Drawable") != std::string::npos, "Rust: missing trait");
+    CHECK(go.find("type Drawable interface") != std::string::npos, "Go: missing interface");
+    CHECK(java.find("interface Drawable") != std::string::npos, "Java: missing interface");
+    CHECK(js.find("class Drawable") != std::string::npos, "JS: missing class (no native interface)");
+    CHECK(el.find("Interface: Drawable") != std::string::npos, "Elisp: missing Interface comment");
+
+    // Verify both methods present
+    CHECK(rs.find("draw") != std::string::npos && rs.find("resize") != std::string::npos,
+          "Rust: missing methods in trait");
+    CHECK(java.find("draw") != std::string::npos && java.find("resize") != std::string::npos,
+          "Java: missing methods in interface");
+    PASS();
+}
+
+// 8. Mixed: class + async + lambda in single module
+void test_mixed_module_all_generators() {
+    TEST(mixed_module_all_generators);
+    auto mod = std::make_unique<Module>("mod1", "mixed_test", "python");
+
+    // Add class
+    auto cls = std::make_unique<ClassDeclaration>("cls1", "Worker");
+    auto meth = std::make_unique<MethodDeclaration>("m1", "run");
+    meth->className = "Worker";
+    cls->addChild("methods", meth.release());
+
+    // Add async function
+    auto af = std::make_unique<AsyncFunction>("af1", "process");
+    auto awaitExpr = std::make_unique<AwaitExpression>("aw1");
+    auto fetchCall = new FunctionCall();
+    fetchCall->id = "fc1";
+    fetchCall->functionName = "fetch";
+    awaitExpr->addChild("expression", fetchCall);
+    auto exprStmt = std::make_unique<ExpressionStatement>();
+    exprStmt->id = "es1";
+    exprStmt->addChild("expression", awaitExpr.release());
+    af->addChild("body", exprStmt.release());
+
+    // Add regular function containing a lambda
+    auto fn = std::make_unique<Function>("fn1", "makeCallback");
+    auto retStmt = std::make_unique<Return>();
+    retStmt->id = "r1";
+    auto lam = std::make_unique<LambdaExpression>("lam1");
+    auto lamParam = std::make_unique<Parameter>("p1", "x");
+    lam->addChild("parameters", lamParam.release());
+    auto lamBody = std::make_unique<VariableReference>("vr1", "x");
+    lam->addChild("body", lamBody.release());
+    retStmt->addChild("value", lam.release());
+    fn->addChild("body", retStmt.release());
+
+    // Serialize class to JSON and reconstruct — proves full pipeline works
+    json clsJson = toJson(cls.get());
+    auto* clsRebuilt = fromJson(clsJson);
+    CHECK(clsRebuilt != nullptr, "class JSON roundtrip failed");
+    CHECK(clsRebuilt->conceptType == "ClassDeclaration", "wrong type after roundtrip");
+
+    // Verify all 8 generators produce non-empty output for class
+    PythonGenerator pyGen;
+    CppGenerator cppGen;
+    RustGenerator rustGen;
+    GoGenerator goGen;
+    JavaGenerator javaGen;
+    JavaScriptGenerator jsGen;
+    ElispGenerator elGen;
+    TypeScriptGenerator tsGen;
+
+    struct GenResult {
+        std::string name;
+        std::string classOut;
+        std::string asyncOut;
+        std::string fnOut;
+    };
+
+    std::vector<GenResult> results;
+
+    auto testGen = [&](const std::string& name, auto& gen) {
+        GenResult r;
+        r.name = name;
+        r.classOut = gen.generate(cls.get());
+        r.asyncOut = gen.generate(af.get());
+        r.fnOut = gen.generate(fn.get());
+        results.push_back(r);
+    };
+
+    testGen("Python", pyGen);
+    testGen("C++", cppGen);
+    testGen("Rust", rustGen);
+    testGen("Go", goGen);
+    testGen("Java", javaGen);
+    testGen("JavaScript", jsGen);
+    testGen("Elisp", elGen);
+    testGen("TypeScript", tsGen);
+
+    for (const auto& r : results) {
+        CHECK(!r.classOut.empty(), (r.name + ": class output empty").c_str());
+        CHECK(!r.asyncOut.empty(), (r.name + ": async output empty").c_str());
+        CHECK(!r.fnOut.empty(), (r.name + ": function output empty").c_str());
+        CHECK(r.classOut.find("Worker") != std::string::npos,
+              (r.name + ": class missing 'Worker'").c_str());
+        CHECK(r.asyncOut.find("process") != std::string::npos,
+              (r.name + ": async missing 'process'").c_str());
+    }
+
+    delete clsRebuilt;
+    PASS();
+}
+
+int main() {
+    std::cout << "Step 308: Generator Updates + Phase 11c Integration Tests\n";
+
+    test_class_all_generators();        // 1
+    test_async_all_generators();        // 2
+    test_generic_type_all_generators(); // 3
+    test_lambda_all_generators();       // 4
+    test_decorator_roundtrip();         // 5
+    test_class_with_methods_and_fields(); // 6
+    test_interface_all_generators();    // 7
+    test_mixed_module_all_generators(); // 8
+
+    std::cout << "\nResults: " << passed << "/" << (passed + failed)
+              << " passed\n";
+    return failed == 0 ? 0 : 1;
+}

progress.md

@@ -1084,6 +1084,55 @@ language-appropriate output. JSON roundtrip preserves dispatch output identity.
   nested class-with-methods dispatch, async-with-await nested dispatch,
   all-9-types JSON roundtrip→dispatch identity check
 
+### Step 305: Python + Java Parser Deepening (12 tests)
+**Status:** PASS (12/12 tests)
+
+Python: class, async def, await, lambda, @decorator.
+Java: class, interface, generics.
+
+### Step 306: JS/TS + Rust Parser Deepening (12 tests)
+**Status:** PASS (12/12 tests)
+
+JS/TS: class, async/await, arrow functions.
+Rust: struct, impl, trait, async fn, closures.
+
+### Step 307: Go + C++ + Elisp Parser Deepening (12 tests)
+**Status:** PASS (12/12 tests)
+
+Go: struct/interface, method receivers.
+C++: class/struct, templates, virtual methods, lambdas.
+Elisp: lambda forms.
+
+### Step 308: Generator Updates + Phase 11c Integration (8 tests)
+**Status:** PASS (8/8 tests)
+
+All 8 generators now produce language-appropriate output for all 9 new AST
+node types (ClassDeclaration, InterfaceDeclaration, MethodDeclaration,
+GenericType, TypeParameter, AsyncFunction, AwaitExpression, LambdaExpression,
+DecoratorAnnotation).
+
+**Files modified:**
+- `editor/src/ast/RustGenerator.h` — 9 new visitor methods: struct/impl, trait,
+  fn(&self), async fn, .await, |closures|, // @decorator
+- `editor/src/ast/GoGenerator.h` — 9 new visitor methods: type struct, type interface,
+  func receiver, func (goroutine async), <-channel await, func() lambda
+- `editor/src/ast/JavaGenerator.h` — 9 new visitor methods: class extends, interface,
+  public void method, List<T>, CompletableFuture async, .get() await, (x) -> lambda, @annotation
+- `editor/src/ast/JavaScriptGenerator.h` — 9 new visitor methods: class extends,
+  class (interface fallback), method(), Name<T>, async function, await, (x) => arrow, // @decorator
+- `editor/src/ast/ElispGenerator.h` — 9 new visitor methods: cl-defstruct, cl-defgeneric,
+  cl-defmethod, baseName (dynamic types), defun ;; async, (async-get), (lambda), ; @decorator
+- `editor/tests/step308_test.cpp` — 8 integration tests
+- `editor/CMakeLists.txt` — step308_test target
+
+**Key results:**
+- Phase 11c complete: all 7 steps pass (80/80 tests across steps 302-308)
+- All 8 generators produce non-empty, language-appropriate output for all 9 new AST types
+- Language idioms verified: Rust struct+impl, Go type struct, Java extends/implements,
+  JS extends/arrow, Python ABC/async def/lambda, C++ virtual/co_await/captures, Elisp defstruct/lambda
+- JSON roundtrip → generate identity verified for ClassDeclaration
+- TypeScript inherits JavaScript generator implementations
+
 ---
 
 # Roadmap Planning — Sprints 12-25+