quicktype-core 7.0.35 → 7.0.36

package/dist/language/CPlusPlus.d.ts

@@ -12,7 +12,6 @@ export declare const cPlusPlusOptions: {
     includeLocation: EnumOption<boolean>;
     codeFormat: EnumOption<boolean>;
     wstring: EnumOption<boolean>;
-    msbuildPermissive: EnumOption<boolean>;
     westConst: EnumOption<boolean>;
     justTypes: BooleanOption;
     namespace: StringOption;
@@ -189,6 +188,10 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     protected emitExtraIncludes(): void;
     protected emitHelper(): void;
     protected emitTypes(): void;
+    protected gatherUserNamespaceForwardDecls(): Sourcelike[];
+    protected gatherNlohmannNamespaceForwardDecls(): Sourcelike[];
+    protected emitUserNamespaceImpls(): void;
+    protected emitNlohmannNamespaceImpls(): void;
     protected emitGenerators(): void;
     protected emitSingleSourceStructure(proposedFilename: string): void;
     protected updateIncludes(isClassMember: boolean, includes: IncludeMap, propertyType: Type, _defName: string): void;

package/dist/language/CPlusPlus.js

@@ -38,10 +38,6 @@ exports.cPlusPlusOptions = {
         ["use-string", false],
         ["use-wstring", true]
     ], "use-string"),
-    msbuildPermissive: new RendererOptions_1.EnumOption("msbuildPermissive", "Moves to_json and from_json types into the nlohmann::details namespace, so that msbuild can build it with conformance mode disabled", [
-        ["not-permissive", false],
-        ["use-permissive", true]
-    ], "not-permissive", "secondary"),
     westConst: new RendererOptions_1.EnumOption("const-style", "Put const to the left/west (const T) or right/east (T const)", [
         ["west-const", true],
         ["east-const", false]
@@ -86,7 +82,6 @@ class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.cPlusPlusOptions.namespace,
             exports.cPlusPlusOptions.codeFormat,
             exports.cPlusPlusOptions.wstring,
-            exports.cPlusPlusOptions.msbuildPermissive,
             exports.cPlusPlusOptions.westConst,
             exports.cPlusPlusOptions.typeSourceStyle,
             exports.cPlusPlusOptions.includeLocation,
@@ -571,18 +566,18 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             ]);
             if (this._options.typeSourceStyle) {
                 this.forEachTopLevel("none", (_, topLevelName) => {
-                    this.emitLine("//     ", this.ourQualifier(false), topLevelName, " data = nlohmann::json::parse(jsonString);");
+                    this.emitLine("//     ", topLevelName, " data = nlohmann::json::parse(jsonString);");
                 });
             }
             else {
-                this.emitLine("//     ", this.ourQualifier(false), basename, " data = nlohmann::json::parse(jsonString);");
+                this.emitLine("//     ", basename, " data = nlohmann::json::parse(jsonString);");
             }
             if (this._options.wstring) {
                 this.emitLine("//");
                 this.emitLine("//  You can get std::wstring data back out using");
                 this.emitLine("//");
                 this.forEachTopLevel("none", (_, topLevelName) => {
-                    this.emitLine("//     std::wcout << ", this.ourQualifier(false), "wdump((nlohmann::json) ", topLevelName, ");");
+                    this.emitLine("//     std::wcout << ", "wdump((nlohmann::json) ", topLevelName, ");");
                 });
             }
         }
@@ -679,12 +674,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return [optionalType, "<", variant, ">"];
     }
     ourQualifier(inJsonNamespace) {
-        return inJsonNamespace || this._options.msbuildPermissive
-            ? [collection_utils_1.arrayIntercalate("::", this._namespaceNames), "::"]
-            : [];
+        return inJsonNamespace ? [collection_utils_1.arrayIntercalate("::", this._namespaceNames), "::"] : [];
     }
     jsonQualifier(inJsonNamespace) {
-        return inJsonNamespace || this._options.msbuildPermissive ? [] : "nlohmann::";
+        return inJsonNamespace ? [] : "nlohmann::";
     }
     variantIndirection(needIndirection, typeSrc) {
         if (!needIndirection)
@@ -704,16 +697,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         let typeSource = TypeUtils_1.matchType(t, _anyType => {
             isOptional = false;
-            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [
-                this.jsonQualifier(inJsonNamespace),
-                "json"
-            ]);
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]);
         }, _nullType => {
             isOptional = false;
-            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, [
-                this.jsonQualifier(inJsonNamespace),
-                "json"
-            ]);
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]);
         }, _boolType => "bool", _integerType => "int64_t", _doubleType => "double", _stringType => {
             if (forceNarrowString) {
                 return "std::string";
@@ -941,25 +928,28 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         });
     }
     emitTopLevelHeaders(t, className) {
-        // Maps need ecoding conversions, since they have a string in the key. Other types don't.
+        // Forward declarations for std::map<std::wstring, Key> (need to convert UTF16 <-> UTF8)
         if (t instanceof Type_1.MapType && this._stringType !== this.NarrowString) {
             const ourQualifier = this.ourQualifier(true);
-            this.emitLine("void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, " & x);");
-            this.emitLine("void to_json(json & j, ", this.withConst([ourQualifier, className]), " & x);");
+            this.emitLine("template <>");
+            this.emitBlock(["struct adl_serializer<", ourQualifier, className, ">"], true, () => {
+                this.emitLine("static void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, " & x);");
+                this.emitLine("static void to_json(json & j, ", this.withConst([ourQualifier, className]), " & x);");
+            });
         }
     }
     emitClassHeaders(className) {
-        const ourQualifier = this.ourQualifier(true);
+        const ourQualifier = this.ourQualifier(false);
         this.emitLine("void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, " & x);");
         this.emitLine("void to_json(json & j, ", this.withConst([ourQualifier, className]), " & x);");
     }
     emitTopLevelFunction(t, className) {
-        // Maps need ecoding conversions, since they have a string in the key. Other types don't.
+        // Function definitions for std::map<std::wstring, Key> (need to convert UTF16 <-> UTF8)
         if (t instanceof Type_1.MapType && this._stringType !== this.NarrowString) {
             const ourQualifier = this.ourQualifier(true);
             let cppType;
             let toType;
-            this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, "& x)"], false, () => {
+            this.emitBlock(["inline void adl_serializer<", ourQualifier, className, ">::from_json(", this.withConst("json"), " & j, ", ourQualifier, className, "& x)"], false, () => {
                 cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
                 toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, false);
                 this.emitLine([
@@ -972,7 +962,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     ";"
                 ]);
             });
-            this.emitBlock(["inline void to_json(json & j, ", this.withConst([ourQualifier, className]), " & x)"], false, () => {
+            this.emitBlock(["inline void adl_serializer<", ourQualifier, className, ">::to_json(json & j, ", this.withConst([ourQualifier, className]), " & x)"], false, () => {
                 cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, false);
                 toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
                 this.emitLine([
@@ -984,7 +974,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
     }
     emitClassFunctions(c, className) {
-        const ourQualifier = this.ourQualifier(true);
+        const ourQualifier = this.ourQualifier(false);
         let cppType;
         let toType;
         this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, "& x)"], false, () => {
@@ -1023,12 +1013,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                         cppType = this.cppTypeInOptional(typeSet, {
                             needsForwardIndirection: false,
                             needsOptionalIndirection: false,
-                            inJsonNamespace: true
+                            inJsonNamespace: false
                         }, false, true);
                         toType = this.cppTypeInOptional(typeSet, {
                             needsForwardIndirection: false,
                             needsOptionalIndirection: false,
-                            inJsonNamespace: true
+                            inJsonNamespace: false
                         }, false, false);
                         this.emitLine(assignment.wrap([], [
                             this._stringType.wrapEncodingChange([ourQualifier], [optionalType, "<", cppType, ">"], [optionalType, "<", toType, ">"], [
@@ -1043,8 +1033,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                         return;
                     }
                 }
-                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, p.isOptional);
-                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, p.isOptional);
+                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, false, true, p.isOptional);
+                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, false, false, p.isOptional);
                 this.emitLine(assignment.wrap([], this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, [
                     "j.at(",
                     this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
@@ -1059,8 +1049,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("j = json::object();");
             this.forEachClassProperty(c, "none", (name, json, p) => {
                 const t = p.type;
-                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, p.isOptional);
-                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, p.isOptional);
+                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, false, false, p.isOptional);
+                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, false, true, p.isOptional);
                 const [getterName, ,] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
                 let getter;
                 if (this._options.codeFormat) {
@@ -1112,12 +1102,21 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("using ", unionName, " = ", this.variantType(u, false), ";");
     }
     emitUnionHeaders(u) {
+        // Forward declarations for boost::variant<Ts...>. If none of the Ts were defined by us (e.g. if we have
+        // boost::variant<int32_t, std::string>) then we need to specialize nlohmann::adl_serializer for our
+        // variant type. If at least one of the Ts is our type then we could get away with regular adl definitions,
+        // but it's nontrivial to detect that (consider variant<string, variant<map<string, string>, int>> which
+        // does need an adl_serializer specialization) so we'll just specialize every time.
         const nonNulls = TypeUtils_1.removeNullFromUnion(u, true)[1];
         const variantType = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false);
-        this.emitLine("void from_json(", this.withConst("json"), " & j, ", variantType, " & x);");
-        this.emitLine("void to_json(json & j, ", this.withConst(variantType), " & x);");
+        this.emitLine("template <>");
+        this.emitBlock(["struct adl_serializer<", variantType, ">"], true, () => {
+            this.emitLine("static void from_json(", this.withConst("json"), " & j, ", variantType, " & x);");
+            this.emitLine("static void to_json(json & j, ", this.withConst(variantType), " & x);");
+        });
     }
     emitUnionFunctions(u) {
+        // Function definitions for boost::variant<Ts...>.
         const ourQualifier = this.ourQualifier(true);
         const functionForKind = [
             ["bool", "is_boolean"],
@@ -1131,7 +1130,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         ];
         const nonNulls = TypeUtils_1.removeNullFromUnion(u, true)[1];
         const variantType = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false);
-        this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", variantType, " & x)"], false, () => {
+        this.emitBlock(["inline void adl_serializer<", variantType, ">::from_json(", this.withConst("json"), " & j, ", variantType, " & x)"], false, () => {
             let onFirst = true;
             for (const [kind, func] of functionForKind) {
                 const typeForKind = collection_utils_1.iterableFind(nonNulls, t => t.kind === kind);
@@ -1152,7 +1151,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine('else throw "Could not deserialize";');
         });
         this.ensureBlankLine();
-        this.emitBlock(["inline void to_json(json & j, ", this.withConst(variantType), " & x)"], false, () => {
+        this.emitBlock(["inline void adl_serializer<", variantType, ">::to_json(json & j, ", this.withConst(variantType), " & x)"], false, () => {
             this.emitBlock(["switch (x.", this._variantIndexMethodName, "())"], false, () => {
                 let i = 0;
                 for (const t of nonNulls) {
@@ -1182,7 +1181,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         });
     }
     emitEnumHeaders(enumName) {
-        const ourQualifier = this.ourQualifier(true);
+        const ourQualifier = this.ourQualifier(false);
         this.emitLine("void from_json(", this.withConst("json"), " & j, ", ourQualifier, enumName, " & x);");
         this.emitLine("void to_json(json & j, ", this.withConst([ourQualifier, enumName]), " & x);");
     }
@@ -1192,7 +1191,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return e.cases.size > 15;
     }
     emitEnumFunctions(e, enumName) {
-        const ourQualifier = this.ourQualifier(true);
+        const ourQualifier = this.ourQualifier(false);
         this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", ourQualifier, enumName, " & x)"], false, () => {
             if (this.isLargeEnum(e)) {
                 this.emitBlock([
@@ -1236,7 +1235,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("using ", name, " = ", this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, false), ";");
     }
     emitAllUnionFunctions() {
-        this.forEachUniqueUnion("interposing", u => this.sourcelikeToString(this.cppTypeInOptional(TypeUtils_1.removeNullFromUnion(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionFunctions(u));
+        this.forEachUniqueUnion("leading-and-interposing", u => this.sourcelikeToString(this.cppTypeInOptional(TypeUtils_1.removeNullFromUnion(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionFunctions(u));
     }
     emitAllUnionHeaders() {
         this.forEachUniqueUnion("interposing", u => this.sourcelikeToString(this.cppTypeInOptional(TypeUtils_1.removeNullFromUnion(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionHeaders(u));
@@ -1421,9 +1420,9 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
         }
         this.ensureBlankLine();
-        var untypedMacroName = new String("NLOHMANN_UNTYPED_");
-        var optionalMacroName = new String("NLOHMANN_OPTIONAL_");
-        this._namespaceNames.forEach(function (value) {
+        let untypedMacroName = "NLOHMANN_UNTYPED_";
+        let optionalMacroName = "NLOHMANN_OPTIONAL_";
+        this._namespaceNames.forEach(value => {
             // We can't use upper name, because namespaces are case sensitive
             untypedMacroName += value;
             untypedMacroName += "_";
@@ -1523,35 +1522,68 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             return;
         this.forEachTopLevel("leading", (t, name) => this.emitTopLevelTypedef(t, name), t => this.namedTypeToNameForTopLevel(t) === undefined);
     }
-    emitGenerators() {
-        let didEmit = false;
-        const gathered = this.gatherSource(() => this.emitNamespaces(this._namespaceNames, () => {
-            didEmit = this.forEachTopLevel("none", (t, name) => this.emitTopLevelTypedef(t, name), t => this.namedTypeToNameForTopLevel(t) === undefined);
-        }));
-        if (didEmit) {
-            this.emitGatheredSource(gathered);
+    gatherUserNamespaceForwardDecls() {
+        return this.gatherSource(() => {
+            this.forEachObject("leading-and-interposing", (_, className) => this.emitClassHeaders(className));
+            this.forEachEnum("leading-and-interposing", (_, enumName) => this.emitEnumHeaders(enumName));
+        });
+    }
+    gatherNlohmannNamespaceForwardDecls() {
+        return this.gatherSource(() => {
+            this.forEachTopLevel("leading-and-interposing", (t, className) => this.emitTopLevelHeaders(t, className));
             this.ensureBlankLine();
+            this.emitAllUnionHeaders();
+        });
+    }
+    emitUserNamespaceImpls() {
+        this.forEachObject("leading-and-interposing", (c, className) => this.emitClassFunctions(c, className));
+        this.forEachEnum("leading-and-interposing", (e, enumName) => this.emitEnumFunctions(e, enumName));
+    }
+    emitNlohmannNamespaceImpls() {
+        this.forEachTopLevel("leading-and-interposing", (t, name) => this.emitTopLevelFunction(t, name), t => this.namedTypeToNameForTopLevel(t) === undefined);
+        this.ensureBlankLine();
+        this.emitAllUnionFunctions();
+    }
+    emitGenerators() {
+        if (this._options.justTypes) {
+            let didEmit = false;
+            const gathered = this.gatherSource(() => this.emitNamespaces(this._namespaceNames, () => {
+                didEmit = this.forEachTopLevel("none", (t, name) => this.emitTopLevelTypedef(t, name), t => this.namedTypeToNameForTopLevel(t) === undefined);
+            }));
+            if (didEmit) {
+                this.emitGatheredSource(gathered);
+                this.ensureBlankLine();
+            }
         }
-        if (!this._options.justTypes) {
-            let namespaces = ["nlohmann"];
-            if (this._options.msbuildPermissive) {
-                namespaces = ["nlohmann", "detail"];
+        else {
+            let userNamespaceForwardDecls = this.gatherUserNamespaceForwardDecls();
+            let nlohmannNamespaceForwardDecls = this.gatherNlohmannNamespaceForwardDecls();
+            if (userNamespaceForwardDecls.length == 0 && nlohmannNamespaceForwardDecls.length > 0) {
+                this.emitNamespaces(["nlohmann"], () => {
+                    this.emitGatheredSource(nlohmannNamespaceForwardDecls);
+                    this.emitNlohmannNamespaceImpls();
+                });
+            }
+            else if (userNamespaceForwardDecls.length > 0 && nlohmannNamespaceForwardDecls.length == 0) {
+                this.emitNamespaces(this._namespaceNames, () => {
+                    this.emitGatheredSource(userNamespaceForwardDecls);
+                    this.emitUserNamespaceImpls();
+                });
+            }
+            else if (userNamespaceForwardDecls.length > 0 && nlohmannNamespaceForwardDecls.length > 0) {
+                this.emitNamespaces(this._namespaceNames, () => {
+                    this.emitGatheredSource(userNamespaceForwardDecls);
+                });
+                this.emitNamespaces(["nlohmann"], () => {
+                    this.emitGatheredSource(nlohmannNamespaceForwardDecls);
+                });
+                this.emitNamespaces(this._namespaceNames, () => {
+                    this.emitUserNamespaceImpls();
+                });
+                this.emitNamespaces(["nlohmann"], () => {
+                    this.emitNlohmannNamespaceImpls();
+                });
             }
-            this.emitNamespaces(namespaces, () => {
-                this.forEachObject("leading-and-interposing", (_, className) => this.emitClassHeaders(className));
-                this.forEachTopLevel("leading-and-interposing", (t, className) => this.emitTopLevelHeaders(t, className));
-                this.forEachEnum("leading-and-interposing", (_, enumName) => this.emitEnumHeaders(enumName));
-                if (this.haveUnions) {
-                    this.emitAllUnionHeaders();
-                }
-                this.ensureBlankLine();
-                this.forEachObject("leading-and-interposing", (c, className) => this.emitClassFunctions(c, className));
-                this.forEachEnum("leading-and-interposing", (e, enumName) => this.emitEnumFunctions(e, enumName));
-                if (this.haveUnions) {
-                    this.emitAllUnionFunctions();
-                }
-                this.forEachTopLevel("leading-and-interposing", (t, name) => this.emitTopLevelFunction(t, name), t => this.namedTypeToNameForTopLevel(t) === undefined);
-            });
         }
     }
     emitSingleSourceStructure(proposedFilename) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "7.0.35",
+    "version": "7.0.36",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",
@@ -45,6 +45,6 @@
         "fs": false
     },
     "config": {
-        "commit": "b3ef38043ae6a0dc6a64760f50c0a43cbba053b6"
+        "commit": "05dad2ee30fb9db7ef5a26db39e57299445c6dc8"
     }
 }