fix(c++): auto-include Generators.hpp and use real type names in multi-source usage comments

packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts

@@ -503,21 +503,13 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
                 "",
             ]);
 
-            if (this._options.typeSourceStyle) {
-                this.forEachTopLevel("none", (_, topLevelName) => {
-                    this.emitLine(
-                        "//     ",
-                        topLevelName,
-                        " data = nlohmann::json::parse(jsonString);",
-                    );
-                });
-            } else {
+            this.forEachTopLevel("none", (_, topLevelName) => {
                 this.emitLine(
                     "//     ",
-                    basename,
+                    topLevelName,
                     " data = nlohmann::json::parse(jsonString);",
                 );
-            }
+            });
 
             if (this._options.wstring) {
                 this.emitLine("//");
@@ -3187,6 +3179,7 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
             this.emitHelper();
 
             this.startFile("Generators.hpp", true);
+            this._generatedFiles.add("Generators.hpp");
 
             this._allTypeNames.forEach((t) => {
                 this.emitInclude(false, [t, ".hpp"]);

test/fixtures.ts

@@ -1563,6 +1563,10 @@ export const allFixtures: Fixture[] = [
     new JSONFixture(languages.CJSONMultiHeaderLanguage, "cjson-multi-header"),
     new JSONFixture(languages.CJSONMultiSplitLanguage, "cjson-multi-split"),
     new JSONFixture(languages.CPlusPlusLanguage),
+    new JSONFixture(
+        languages.CPlusPlusMultiSourceLanguage,
+        "cplusplus-multi-source",
+    ),
     new JSONFixture(languages.PHPLanguage),
     new JSONFixture(languages.RustLanguage),
     new JSONFixture(languages.RubyLanguage),

test/fixtures/cplusplus/main.cpp

@@ -3,8 +3,7 @@
 #include <fstream>
 #include <streambuf>
 
-#include "TopLevel.hpp"
-#include "Generators.hpp"
+#include "quicktype.hpp"
 
 using quicktype::TopLevel;
 using nlohmann::json;

test/languages.ts

@@ -712,7 +712,7 @@ export const CPlusPlusLanguage: Language = {
         "union",
         "no-defaults",
     ],
-    output: "TopLevel.hpp",
+    output: "quicktype.hpp",
     topLevel: "TopLevel",
     skipJSON: [
         // fails on a string containing null
@@ -737,7 +737,6 @@ export const CPlusPlusLanguage: Language = {
     ],
     rendererOptions: {},
     quickTestRendererOptions: [
-        { "source-style": "multi-source" },
         { "code-format": "with-struct" },
         { wstring: "use-wstring" },
         { "const-style": "east-const" },
@@ -753,6 +752,13 @@ export const CPlusPlusLanguage: Language = {
     sourceFiles: ["src/language/CPlusPlus/index.ts"],
 };
 
+export const CPlusPlusMultiSourceLanguage: Language = {
+    ...CPlusPlusLanguage,
+    includeJSON: ["pokedex.json"],
+    rendererOptions: { "source-style": "multi-source" },
+    quickTestRendererOptions: [],
+};
+
 export const ElmLanguage: Language = {
     name: "elm",
     base: "test/fixtures/elm",

test/unit/cplusplus-multi-source.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "vitest";
+
+import {
+    InputData,
+    jsonInputForTargetLanguage,
+    quicktypeMultiFile,
+} from "quicktype-core";
+
+async function cPlusPlusMultiSourceFiles(): Promise<Map<string, string>> {
+    const jsonInput = jsonInputForTargetLanguage("cplusplus");
+    await jsonInput.addSource({
+        name: "ChunkCache",
+        samples: ['{"chunks":["one"],"size":1}'],
+    });
+    await jsonInput.addSource({
+        name: "BufferPath",
+        samples: ['{"path":"somewhere","maxSize":2}'],
+    });
+
+    const inputData = new InputData();
+    inputData.addInput(jsonInput);
+    const result = await quicktypeMultiFile({
+        inputData,
+        lang: "cplusplus",
+        outputFilename: "quicktype.hpp",
+        rendererOptions: { "source-style": "multi-source" },
+    });
+
+    return new Map(
+        Array.from(result, ([filename, serialized]) => [
+            filename,
+            serialized.lines.join("\n"),
+        ]),
+    );
+}
+
+describe("C++ multi-source output", () => {
+    test("the umbrella header includes the JSON generators", async () => {
+        const files = await cPlusPlusMultiSourceFiles();
+        expect(files.get("quicktype.hpp")).toContain(
+            '#include "Generators.hpp"',
+        );
+    });
+
+    test("usage comments name top-level types, not generated files", async () => {
+        const files = await cPlusPlusMultiSourceFiles();
+        for (const [filename, source] of files) {
+            expect(source).toContain(
+                "//     ChunkCache data = nlohmann::json::parse(jsonString);",
+            );
+            expect(source).toContain(
+                "//     BufferPath data = nlohmann::json::parse(jsonString);",
+            );
+            expect(source).not.toContain(
+                `//     ${filename} data = nlohmann::json::parse(jsonString);`,
+            );
+        }
+    });
+});