@typecad/cuttlefish 0.1.0-alpha.1

package/dist/emit/cpp-emitter.js

@@ -0,0 +1,48 @@
+import { buildEmitterContext } from "./emitters/setup.js";
+import { emitPreamble } from "./emitters/output-finalizer.js";
+import { runTopLevelPreprocessing } from "./emitters/top-level-prep.js";
+import { synthesizeEntrypoints } from "./emitters/entrypoint-synthesizer.js";
+import { emitTypeDeclarations } from "./emitters/type-decl-emitter.js";
+import { emitNamespaces } from "./emitters/namespace-emitter.js";
+import { emitClasses } from "./emitters/class-emitter.js";
+import { emitPostClassDeclarations, emitCallbackFunctions, emitFunctions, emitFunctionForwardDeclarations } from "./emitters/function-emitter-impl.js";
+import { emitUIRuntime } from "./emitters/ui-emitter.js";
+import { finalizeOutput } from "./emitters/output-finalizer.js";
+const globalEnumNames = new Set();
+const globalLargeEnumNames = new Set();
+export function registerAllEnumNames(enums) {
+    for (const e of enums) {
+        globalEnumNames.add(e.name);
+        if (e.members && e.members.some((m) => m.value !== undefined && (m.value > 32767 || m.value < -32768))) {
+            globalLargeEnumNames.add(e.name);
+        }
+    }
+}
+export function emitCpp(program, options) {
+    // 1. Build shared emitter context (strategy, renderers, analysis, etc.)
+    const ctx = buildEmitterContext(program, options);
+    // 2. Emit preamble (includes, polyfills, async task classes, shims)
+    emitPreamble(ctx);
+    // 2.5. Emit UI runtime (header structs + static tables) — entry file only,
+    //      when a UI is mounted. File-scope, must precede any function using it.
+    emitUIRuntime(ctx);
+    // 3. Run top-level preprocessing (timing promotion, ISR extraction, pointer tracking)
+    runTopLevelPreprocessing(ctx);
+    // 4. Synthesize entrypoint functions (setup/main/loop)
+    synthesizeEntrypoints(ctx);
+    // 5. Emit type declarations (enums, type aliases, interfaces, top-level constants)
+    emitTypeDeclarations(ctx);
+    // 6. Emit namespaces
+    emitNamespaces(ctx);
+    // 6.5. Emit function forward declarations (split mode — must precede class definitions)
+    emitFunctionForwardDeclarations(ctx);
+    // 7. Emit classes
+    emitClasses(ctx);
+    // 8. Emit post-class declarations (runtime vars, promoted vars, object literal structs)
+    emitPostClassDeclarations(ctx);
+    // 9. Emit callbacks + forward declarations + function definitions
+    emitCallbackFunctions(ctx);
+    emitFunctions(ctx);
+    // 10. Finalize output (write files, source maps, post-processing)
+    return finalizeOutput(ctx);
+}

package/dist/emit/emitters/class-emitter.d.ts

@@ -0,0 +1,2 @@
+import type { EmitterContext } from "./emitter-context.js";
+export declare function emitClasses(ctx: EmitterContext): void;

package/dist/emit/emitters/class-emitter.js

@@ -0,0 +1,523 @@
+import { emitCommentLines } from "../utils/index.js";
+import { appendSourceLine, appendRenderedStatement } from "./line-appender.js";
+import { createChildEmissionScope } from "../snprintf-helpers.js";
+import { escapeCppKeyword } from "../../utils/strings.js";
+import { accessorGetterName, accessorSetterName } from "../utils/cpp-helpers.js";
+import { parseCppType, parsedIsPointer, parsedIsVector, isStaticArray } from "../../api/shared/cpp-type-ir.js";
+export function emitClasses(ctx) {
+    const { program, strategy, effectiveEmitMode, reservedNames, mappedFunctions, topLevelScope, exprRenderer, statementRenderer, isEntryFile } = ctx;
+    if (effectiveEmitMode === "split") {
+        const _swapLines = ctx.sourceLines;
+        ctx.sourceLines = ctx.headerLines;
+        ctx.headerLines = _swapLines;
+        const _swapMaps = ctx.sourceMapEntries;
+        ctx.sourceMapEntries = ctx.headerMapEntries;
+        ctx.headerMapEntries = _swapMaps;
+    }
+    const normalizeCppTypeForTarget = (cppType) => strategy.normalizeCppType(cppType);
+    const renderExpression = (expr, calleeTransformer) => exprRenderer.render(expr, calleeTransformer);
+    const renderParameters = (params, forHeader = false) => statementRenderer.renderParameters(params, forHeader);
+    const renderTypedName = (cppType, name) => statementRenderer.renderTypedName(cppType, name);
+    // Forward-declare locally-defined base classes
+    const localClassNames = new Set(program.classes.map(c => c.name));
+    const baseClassesNeeded = new Set();
+    for (const classDef of program.classes) {
+        if (classDef.extendsClass && !localClassNames.has(classDef.extendsClass)) {
+            // Base class from import — header handles it
+        }
+        else if (classDef.extendsClass && localClassNames.has(classDef.extendsClass)) {
+            baseClassesNeeded.add(classDef.extendsClass);
+        }
+    }
+    for (const classDef of program.classes) {
+        if (classDef.extendsClass && baseClassesNeeded.has(classDef.extendsClass)) {
+            const baseIdx = program.classes.findIndex(c => c.name === classDef.extendsClass);
+            const derivedIdx = program.classes.findIndex(c => c.name === classDef.name);
+            if (derivedIdx < baseIdx) {
+                appendSourceLine(ctx, `class ${classDef.extendsClass};`);
+            }
+        }
+    }
+    // Track static member names per class
+    const classStaticMembers = new Map();
+    for (const classDef of program.classes) {
+        const statics = new Set();
+        for (const method of classDef.methods) {
+            if (method.isStatic)
+                statics.add(method.name);
+        }
+        for (const field of classDef.fields) {
+            if (field.isStatic)
+                statics.add(field.name);
+        }
+        for (const getter of classDef.getters) {
+            if (getter.isStatic)
+                statics.add(getter.name);
+        }
+        for (const setter of classDef.setters) {
+            if (setter.isStatic)
+                statics.add(setter.name);
+        }
+        if (statics.size > 0) {
+            classStaticMembers.set(classDef.name, statics);
+        }
+    }
+    // String-typed variable tracking + C-array variable tracking
+    const stringVarTypes = new Set();
+    ctx.cArrayVarNames = new Set();
+    const fnCArrayVarNames = new Map();
+    const addCArrayIfNotMutable = (name, normalizedType, target) => {
+        if (!normalizedType.startsWith("StaticArray<")) {
+            target.add(name);
+        }
+    };
+    // Note: this intentionally matches only const char*/char*/String, NOT
+    // std::string — the latter is tracked separately as a "managed" string var.
+    const isStringLikeType = (t) => t === "const char*" || t === "char*" || t === "String";
+    for (const stmt of program.topLevelStatements) {
+        if (stmt.kind === "var_decl") {
+            const normalizedType = normalizeCppTypeForTarget(stmt.cppType);
+            if (isStringLikeType(normalizedType)) {
+                stringVarTypes.add(stmt.name);
+            }
+            if (stmt.initializer?.kind === "array") {
+                if (!parsedIsVector(normalizedType) || !strategy.needsStdVector()) {
+                    addCArrayIfNotMutable(stmt.name, normalizedType, ctx.cArrayVarNames);
+                }
+            }
+            if (stmt.initializer?.kind === "spread_array") {
+                addCArrayIfNotMutable(stmt.name, normalizedType, ctx.cArrayVarNames);
+            }
+        }
+    }
+    for (let fi = 0; fi < mappedFunctions.length; fi++) {
+        const fn = mappedFunctions[fi];
+        const fnSet = new Set();
+        for (const stmt of fn.statements) {
+            if (stmt.kind === "var_decl") {
+                const normalizedType = normalizeCppTypeForTarget(stmt.cppType);
+                if (isStringLikeType(normalizedType)) {
+                    stringVarTypes.add(stmt.name);
+                }
+                if (stmt.initializer?.kind === "array") {
+                    if (!parsedIsVector(normalizedType) || !strategy.needsStdVector()) {
+                        addCArrayIfNotMutable(stmt.name, normalizedType, fnSet);
+                    }
+                }
+                if (stmt.initializer?.kind === "spread_array") {
+                    addCArrayIfNotMutable(stmt.name, normalizedType, fnSet);
+                }
+                // Demo #17 Finding A — `new Uint8Array([...])` / `new Int8Array(N)`
+                // lowers to a raw C array var_decl whose cppType is a staticArray
+                // (e.g. `uint8_t[5]`) but whose initializer is NOT `kind: "array"`
+                // (it's a raw/text initializer). The `stmt.initializer?.kind === "array"`
+                // gate above therefore misses it, so `.length` on the buffer fell
+                // through to the invalid `buf.size()` (avr-g++: "request for member
+                // 'size' in 'buf', which is of non-class type 'uint8_t [5]'").
+                // Detect by cppType shape: a staticArray on a no-std::vector target is
+                // a raw C array → sizeof. (StaticArray<T,N> — the mutable promoted
+                // form — is excluded by addCArrayIfNotMutable and keeps its .size().)
+                if (!strategy.needsStdVector() && isStaticArray(parseCppType(normalizedType))) {
+                    addCArrayIfNotMutable(stmt.name, normalizedType, fnSet);
+                }
+            }
+        }
+        fnCArrayVarNames.set(String(fi), fnSet);
+    }
+    ctx.fnCArrayVarNames = fnCArrayVarNames;
+    // Build class accessor name map
+    const classAccessorNames = new Map();
+    for (const classDef of program.classes) {
+        const accessors = new Map();
+        for (const g of classDef.getters) {
+            accessors.set(g.name, accessors.has(g.name) ? "both" : "getter");
+        }
+        for (const s of classDef.setters) {
+            accessors.set(s.name, accessors.has(s.name) ? "both" : "setter");
+        }
+        if (accessors.size > 0) {
+            classAccessorNames.set(classDef.name, accessors);
+        }
+    }
+    // Build variable → accessor map. NOTE: the variable/parameter registration
+    // now lives in setup.ts so it runs before any emit pass. The classAccessorNames
+    // map built here is still used below for the per-method "this" registration.
+    // See SUPPORT_MATRIX §4.3 (demo #4 fix).
+    // Build virtual/override maps for inherited methods
+    const classMethodNames = new Map();
+    for (const cls of program.classes) {
+        const names = new Set(cls.methods
+            .filter(m => !m.isStatic && !m.isAbstract)
+            .map(m => m.name));
+        classMethodNames.set(cls.name, names);
+    }
+    const virtualMethodNames = new Map();
+    for (const cls of program.classes) {
+        if (cls.extendsClass) {
+            const baseMethods = classMethodNames.get(cls.extendsClass);
+            if (baseMethods) {
+                for (const method of cls.methods) {
+                    if (!method.isStatic && !method.isAbstract && baseMethods.has(method.name)) {
+                        if (!virtualMethodNames.has(cls.extendsClass)) {
+                            virtualMethodNames.set(cls.extendsClass, new Set());
+                        }
+                        virtualMethodNames.get(cls.extendsClass).add(method.name);
+                    }
+                }
+            }
+        }
+    }
+    const collectAllFields = (classDef) => {
+        const fields = [...classDef.fields];
+        if (classDef.extendsClass) {
+            const parent = program.classes.find((c) => c.name === classDef.extendsClass);
+            if (parent)
+                fields.push(...collectAllFields(parent));
+        }
+        return fields;
+    };
+    const addClassFieldsToScope = (classDef, scope) => {
+        for (const f of collectAllFields(classDef)) {
+            const normalizedFieldType = strategy.normalizeCppType(f.cppType);
+            scope.knownVariableTypes.set(f.name, { cppType: normalizedFieldType });
+        }
+    };
+    const withThisAccessors = (classDef, isStatic, fn) => {
+        const classAccessors = classAccessorNames.get(classDef.name);
+        if (classAccessors && !isStatic)
+            ctx.varAccessorNames.set("this", classAccessors);
+        fn();
+        if (classAccessors && !isStatic)
+            ctx.varAccessorNames.delete("this");
+    };
+    // Emit each class
+    for (const classDef of program.classes) {
+        emitCommentLines(classDef.leadingComments, "", (line) => appendSourceLine(ctx, line));
+        const inheritanceParts = [];
+        if (classDef.extendsClass) {
+            inheritanceParts.push(`public ${classDef.extendsClass}`);
+        }
+        const inheritanceClause = inheritanceParts.length > 0 ? ` : ${inheritanceParts.join(", ")}` : "";
+        if (classDef.isAbstract) {
+            appendSourceLine(ctx, `// Abstract class - contains pure virtual methods`);
+        }
+        if (classDef.decorators && classDef.decorators.length > 0) {
+            for (const dec of classDef.decorators) {
+                if (dec === "sealed")
+                    appendSourceLine(ctx, `// @sealed → class marked final`);
+                else if (dec === "deprecated")
+                    appendSourceLine(ctx, `[[deprecated]]`);
+                else if (dec === "nodiscard")
+                    appendSourceLine(ctx, `[[nodiscard]]`);
+            }
+        }
+        if (classDef.decorators && classDef.decorators.includes("sealed")) {
+            if (classDef.typeParameters && classDef.typeParameters.length > 0) {
+                appendSourceLine(ctx, `template<typename ${classDef.typeParameters.join(", typename ")}>`);
+            }
+            appendSourceLine(ctx, `class ${classDef.name}${inheritanceClause} final {`);
+        }
+        else {
+            if (classDef.typeParameters && classDef.typeParameters.length > 0) {
+                appendSourceLine(ctx, `template<typename ${classDef.typeParameters.join(", typename ")}>`);
+            }
+            appendSourceLine(ctx, `class ${classDef.name}${inheritanceClause} {`);
+        }
+        const publicFields = classDef.fields.filter(f => f.visibility === "public");
+        const privateFields = classDef.fields.filter(f => f.visibility === "private");
+        const protectedFields = classDef.fields.filter(f => f.visibility === "protected");
+        const publicMethods = classDef.methods.filter(m => m.visibility === "public");
+        const privateMethods = classDef.methods.filter(m => m.visibility === "private");
+        const protectedMethods = classDef.methods.filter(m => m.visibility === "protected");
+        const publicGetters = classDef.getters.filter(g => g.visibility === "public");
+        const publicSetters = classDef.setters.filter(s => s.visibility === "public");
+        const privateGetters = classDef.getters.filter(g => g.visibility === "private");
+        const privateSetters = classDef.setters.filter(s => s.visibility === "private");
+        const protectedGetters = classDef.getters.filter(g => g.visibility === "protected");
+        const protectedSetters = classDef.setters.filter(s => s.visibility === "protected");
+        const classPointerFieldNames = classDef.fields
+            .filter(f => parsedIsPointer(f.cppType))
+            .map(f => f.name);
+        ctx.currentClassPointerFields = classPointerFieldNames.length > 0 ? classPointerFieldNames : undefined;
+        const classPointerFieldTypes = new Map();
+        for (const f of classDef.fields) {
+            if (parsedIsPointer(f.cppType)) {
+                classPointerFieldTypes.set(f.name, f.cppType);
+            }
+        }
+        ctx.currentClassPointerFieldTypes = classPointerFieldTypes.size > 0 ? classPointerFieldTypes : undefined;
+        const needsPublicSection = publicFields.length > 0 || publicMethods.length > 0 || publicGetters.length > 0 || publicSetters.length > 0 || classDef.constructor || ctx.callbackFunctions.length > 0;
+        if (needsPublicSection) {
+            appendSourceLine(ctx, "public:");
+            if (ctx.callbackFunctions.length > 0) {
+                for (const callback of ctx.callbackFunctions) {
+                    // Friend declaration must match the synthesized callback's actual
+                    // signature (void name() for ISRs, or R name(args) for typed
+                    // std::function-callback lambdas). See renderCallbackSignature in
+                    // function-emitter-impl.ts.
+                    const fret = callback.returnType && callback.returnType !== "void" ? callback.returnType : "void";
+                    const fparams = (callback.typedParams ?? []).map((p) => `${p.cppType} ${p.name}`).join(", ");
+                    appendSourceLine(ctx, `  friend ${fret} ${callback.name}(${fparams});`);
+                }
+                appendSourceLine(ctx, "");
+            }
+            if (classDef.constructor) {
+                const ctorParamsMapped = classDef.constructor.parameters.map(p => ({
+                    ...p,
+                    cppType: normalizeCppTypeForTarget(p.cppType)
+                }));
+                const ctorParams = renderParameters(ctorParamsMapped);
+                let ctorInitializer = "";
+                let ctorStatements = classDef.constructor.statements;
+                const firstCtorStatement = ctorStatements[0];
+                if (classDef.extendsClass && firstCtorStatement && firstCtorStatement.kind === "super_call") {
+                    const baseArgs = firstCtorStatement.args.map((arg) => renderExpression(arg, ctx.fixPointerFieldAccess)).join(", ");
+                    ctorInitializer = ` : ${classDef.extendsClass}(${baseArgs})`;
+                    ctorStatements = ctorStatements.slice(1);
+                }
+                appendSourceLine(ctx, `  ${classDef.name}(${ctorParams})${ctorInitializer} {`);
+                const ctorScope = createChildEmissionScope(topLevelScope, classDef.constructor.parameters);
+                addClassFieldsToScope(classDef, ctorScope);
+                const classAccessors = classAccessorNames.get(classDef.name);
+                if (classAccessors)
+                    ctx.varAccessorNames.set("this", classAccessors);
+                for (const stmt of ctorStatements) {
+                    appendRenderedStatement(ctx, stmt, "    ", ctorScope);
+                }
+                if (classAccessors)
+                    ctx.varAccessorNames.delete("this");
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+            // Class-typed fields are references, not implicitly owned allocations.
+            // Deleting every pointer field here double-frees borrowed constructor
+            // parameters and breaks aliasing. Only bases used polymorphically need a
+            // generated destructor, and the default destructor is sufficient.
+            if (program.classes.some((candidate) => candidate.extendsClass === classDef.name)) {
+                appendSourceLine(ctx, `  virtual ~${classDef.name}() = default;`);
+                appendSourceLine(ctx, "");
+            }
+            for (const field of publicFields) {
+                const initSuffix = field.initializer ? ` = ${renderExpression(field.initializer, undefined)}` : "";
+                const fieldType = strategy.overrideClassFieldType(field.name, normalizeCppTypeForTarget(field.cppType));
+                // `static inline` lets an initialized static field live entirely in the
+                // header (C++17) — required because this transpiler emits class bodies
+                // inline rather than splitting decl/defn across .h/.cpp.
+                const staticPrefix = field.isStatic ? "static inline " : "";
+                appendSourceLine(ctx, `  ${staticPrefix}${renderTypedName(fieldType, field.name)}${initSuffix};`);
+            }
+            if (publicFields.length > 0)
+                appendSourceLine(ctx, "");
+            for (const method of publicMethods) {
+                const methodParams = renderParameters(method.parameters);
+                const staticPrefix = method.isStatic ? "static " : "";
+                const returnType = normalizeCppTypeForTarget(method.returnType);
+                if (method.isAbstract) {
+                    appendSourceLine(ctx, `  virtual ${returnType} ${escapeCppKeyword(method.name, reservedNames)}(${methodParams}) = 0;`);
+                    appendSourceLine(ctx, "");
+                    continue;
+                }
+                const virtualSet = virtualMethodNames.get(classDef.name);
+                const isVirtual = !method.isStatic && virtualSet?.has(method.name);
+                const virtualPrefix = isVirtual ? "virtual " : "";
+                const baseMethods = classDef.extendsClass ? classMethodNames.get(classDef.extendsClass) : undefined;
+                const isOverrideMethod = !method.isStatic && (method.isOverride || baseMethods?.has(method.name));
+                const overrideSuffix = isOverrideMethod ? " override" : "";
+                if (method.typeParameters && method.typeParameters.length > 0) {
+                    appendSourceLine(ctx, `  template<typename ${method.typeParameters.join(", typename ")}>`);
+                }
+                appendSourceLine(ctx, `  ${virtualPrefix}${staticPrefix}${returnType} ${escapeCppKeyword(method.name, reservedNames)}(${methodParams})${overrideSuffix} {`);
+                const methodScope = createChildEmissionScope(topLevelScope, method.parameters);
+                addClassFieldsToScope(classDef, methodScope);
+                const classAccessors = classAccessorNames.get(classDef.name);
+                if (classAccessors && !method.isStatic)
+                    ctx.varAccessorNames.set("this", classAccessors);
+                for (const stmt of method.statements) {
+                    appendRenderedStatement(ctx, stmt, "    ", methodScope);
+                }
+                if (classAccessors && !method.isStatic)
+                    ctx.varAccessorNames.delete("this");
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+            for (const getter of publicGetters) {
+                const staticPrefix = getter.isStatic ? "static " : "";
+                const returnType = normalizeCppTypeForTarget(getter.returnType);
+                const getterName = accessorGetterName(getter.name);
+                // A `const` cv-qualifier is illegal on a static member function
+                // (g++: "static member function ... cannot have cv-qualifier"). Only
+                // add `const` for instance getters.
+                const constQualifier = getter.isStatic ? "" : " const";
+                appendSourceLine(ctx, `  ${staticPrefix}${returnType} ${getterName}()${constQualifier} {`);
+                const getterScope = createChildEmissionScope(topLevelScope, []);
+                addClassFieldsToScope(classDef, getterScope);
+                withThisAccessors(classDef, getter.isStatic, () => {
+                    for (const stmt of getter.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", getterScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+            for (const setter of publicSetters) {
+                const staticPrefix = setter.isStatic ? "static " : "";
+                const paramType = normalizeCppTypeForTarget(setter.parameter.cppType);
+                const setterName = accessorSetterName(setter.name);
+                appendSourceLine(ctx, `  ${staticPrefix}void ${setterName}(${paramType} ${setter.parameter.name}) {`);
+                const setterScope = createChildEmissionScope(topLevelScope, [setter.parameter]);
+                addClassFieldsToScope(classDef, setterScope);
+                withThisAccessors(classDef, setter.isStatic, () => {
+                    for (const stmt of setter.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", setterScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+        }
+        // Private section
+        if (privateFields.length > 0 || privateMethods.length > 0 || privateGetters.length > 0 || privateSetters.length > 0) {
+            appendSourceLine(ctx, "private:");
+            for (const field of privateFields) {
+                const initSuffix = field.initializer ? ` = ${renderExpression(field.initializer, undefined)}` : "";
+                const fieldType = strategy.overrideClassFieldType(field.name, normalizeCppTypeForTarget(field.cppType));
+                const staticPrefix = field.isStatic ? "static inline " : "";
+                appendSourceLine(ctx, `  ${staticPrefix}${renderTypedName(fieldType, field.name)}${initSuffix};`);
+            }
+            if (privateFields.length > 0)
+                appendSourceLine(ctx, "");
+            for (const method of privateMethods) {
+                const methodParams = renderParameters(method.parameters);
+                const staticPrefix = method.isStatic ? "static " : "";
+                const virtualSet = virtualMethodNames.get(classDef.name);
+                const isVirtual = !method.isStatic && virtualSet?.has(method.name);
+                const virtualPrefix = isVirtual ? "virtual " : "";
+                const baseMethods = classDef.extendsClass ? classMethodNames.get(classDef.extendsClass) : undefined;
+                const isOverrideMethod = !method.isStatic && (method.isOverride || baseMethods?.has(method.name));
+                const overrideSuffix = isOverrideMethod ? " override" : "";
+                if (method.typeParameters && method.typeParameters.length > 0) {
+                    appendSourceLine(ctx, `  template<typename ${method.typeParameters.join(", typename ")}>`);
+                }
+                appendSourceLine(ctx, `  ${virtualPrefix}${staticPrefix}${normalizeCppTypeForTarget(method.returnType)} ${escapeCppKeyword(method.name, reservedNames)}(${methodParams})${overrideSuffix} {`);
+                const methodScope = createChildEmissionScope(topLevelScope, method.parameters);
+                addClassFieldsToScope(classDef, methodScope);
+                withThisAccessors(classDef, method.isStatic, () => {
+                    for (const stmt of method.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", methodScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+            for (const getter of privateGetters) {
+                const staticPrefix = getter.isStatic ? "static " : "";
+                const returnType = normalizeCppTypeForTarget(getter.returnType);
+                const getterName = accessorGetterName(getter.name);
+                const constQualifier = getter.isStatic ? "" : " const";
+                appendSourceLine(ctx, `  ${staticPrefix}${returnType} ${getterName}()${constQualifier} {`);
+                const getterScope = createChildEmissionScope(topLevelScope, []);
+                addClassFieldsToScope(classDef, getterScope);
+                withThisAccessors(classDef, getter.isStatic, () => {
+                    for (const stmt of getter.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", getterScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+            for (const setter of privateSetters) {
+                const staticPrefix = setter.isStatic ? "static " : "";
+                const paramType = normalizeCppTypeForTarget(setter.parameter.cppType);
+                const setterName = accessorSetterName(setter.name);
+                appendSourceLine(ctx, `  ${staticPrefix}void ${setterName}(${paramType} ${setter.parameter.name}) {`);
+                const setterScope = createChildEmissionScope(topLevelScope, [setter.parameter]);
+                addClassFieldsToScope(classDef, setterScope);
+                withThisAccessors(classDef, setter.isStatic, () => {
+                    for (const stmt of setter.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", setterScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+        }
+        // Protected section
+        if (protectedFields.length > 0 || protectedMethods.length > 0 || protectedGetters.length > 0 || protectedSetters.length > 0) {
+            appendSourceLine(ctx, "protected:");
+            for (const field of protectedFields) {
+                const initSuffix = field.initializer ? ` = ${renderExpression(field.initializer, undefined)}` : "";
+                const fieldType = strategy.overrideClassFieldType(field.name, normalizeCppTypeForTarget(field.cppType));
+                const staticPrefix = field.isStatic ? "static inline " : "";
+                appendSourceLine(ctx, `  ${staticPrefix}${renderTypedName(fieldType, field.name)}${initSuffix};`);
+            }
+            if (protectedFields.length > 0)
+                appendSourceLine(ctx, "");
+            for (const method of protectedMethods) {
+                const methodParams = renderParameters(method.parameters);
+                const staticPrefix = method.isStatic ? "static " : "";
+                const virtualSet = virtualMethodNames.get(classDef.name);
+                const isVirtual = !method.isStatic && virtualSet?.has(method.name);
+                const virtualPrefix = isVirtual ? "virtual " : "";
+                const baseMethods = classDef.extendsClass ? classMethodNames.get(classDef.extendsClass) : undefined;
+                const isOverrideMethod = !method.isStatic && (method.isOverride || baseMethods?.has(method.name));
+                const overrideSuffix = isOverrideMethod ? " override" : "";
+                if (method.typeParameters && method.typeParameters.length > 0) {
+                    appendSourceLine(ctx, `  template<typename ${method.typeParameters.join(", typename ")}>`);
+                }
+                appendSourceLine(ctx, `  ${virtualPrefix}${staticPrefix}${normalizeCppTypeForTarget(method.returnType)} ${escapeCppKeyword(method.name, reservedNames)}(${methodParams})${overrideSuffix} {`);
+                const methodScope = createChildEmissionScope(topLevelScope, method.parameters);
+                addClassFieldsToScope(classDef, methodScope);
+                withThisAccessors(classDef, method.isStatic, () => {
+                    for (const stmt of method.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", methodScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+            for (const getter of protectedGetters) {
+                const staticPrefix = getter.isStatic ? "static " : "";
+                const returnType = normalizeCppTypeForTarget(getter.returnType);
+                const getterName = accessorGetterName(getter.name);
+                appendSourceLine(ctx, `  ${staticPrefix}${returnType} ${getterName}() const {`);
+                const getterScope = createChildEmissionScope(topLevelScope, []);
+                addClassFieldsToScope(classDef, getterScope);
+                withThisAccessors(classDef, getter.isStatic, () => {
+                    for (const stmt of getter.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", getterScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+            for (const setter of protectedSetters) {
+                const staticPrefix = setter.isStatic ? "static " : "";
+                const paramType = normalizeCppTypeForTarget(setter.parameter.cppType);
+                const setterName = accessorSetterName(setter.name);
+                appendSourceLine(ctx, `  ${staticPrefix}void ${setterName}(${paramType} ${setter.parameter.name}) {`);
+                const setterScope = createChildEmissionScope(topLevelScope, [setter.parameter]);
+                addClassFieldsToScope(classDef, setterScope);
+                withThisAccessors(classDef, setter.isStatic, () => {
+                    for (const stmt of setter.statements) {
+                        appendRenderedStatement(ctx, stmt, "    ", setterScope);
+                    }
+                });
+                appendSourceLine(ctx, "  }");
+                appendSourceLine(ctx, "");
+            }
+        }
+        appendSourceLine(ctx, "};");
+        emitCommentLines(classDef.trailingComments, "", (line) => appendSourceLine(ctx, line));
+        appendSourceLine(ctx, "");
+        ctx.currentClassPointerFields = undefined;
+        ctx.currentClassPointerFieldTypes = undefined;
+    }
+    if (effectiveEmitMode === "split") {
+        const _swapLines = ctx.sourceLines;
+        ctx.sourceLines = ctx.headerLines;
+        ctx.headerLines = _swapLines;
+        const _swapMaps = ctx.sourceMapEntries;
+        ctx.sourceMapEntries = ctx.headerMapEntries;
+        ctx.headerMapEntries = _swapMaps;
+    }
+}