quicktype 17.0.4 → 17.0.6

package/dist/quicktype-core/language/CPlusPlus.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CPlusPlusRenderer = exports.MemberNames = exports.GlobalNames = exports.IncludeKind = exports.CPlusPlusTargetLanguage = exports.cPlusPlusOptions = void 0;
 const collection_utils_1 = require("collection-utils");
 const TargetLanguage_1 = require("../TargetLanguage");
 const Type_1 = require("../Type");
@@ -39,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]
@@ -87,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,
@@ -106,19 +100,19 @@ class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
         return true;
     }
     makeRenderer(renderContext, untypedOptionValues) {
-        return new CPlusPlusRenderer(this, renderContext, (0, RendererOptions_1.getOptionValues)(exports.cPlusPlusOptions, untypedOptionValues));
+        return new CPlusPlusRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.cPlusPlusOptions, untypedOptionValues));
     }
 }
 exports.CPlusPlusTargetLanguage = CPlusPlusTargetLanguage;
 function constraintsForType(t) {
-    const minMax = (0, Constraints_1.minMaxValueForType)(t);
-    const minMaxLength = (0, Constraints_1.minMaxLengthForType)(t);
-    const pattern = (0, Constraints_1.patternForType)(t);
+    const minMax = Constraints_1.minMaxValueForType(t);
+    const minMaxLength = Constraints_1.minMaxLengthForType(t);
+    const pattern = Constraints_1.patternForType(t);
     if (minMax === undefined && minMaxLength === undefined && pattern === undefined)
         return undefined;
     return { minMax, minMaxLength, pattern };
 }
-const legalizeName = (0, Strings_1.legalizeCharacters)(cp => (0, Strings_1.isAscii)(cp) && (0, Strings_1.isLetterOrUnderscoreOrDigit)(cp));
+const legalizeName = Strings_1.legalizeCharacters(cp => Strings_1.isAscii(cp) && Strings_1.isLetterOrUnderscoreOrDigit(cp));
 const keywords = [
     "alignas",
     "alignof",
@@ -280,8 +274,6 @@ function addQualifier(qualifier, qualified) {
     return [qualifier, qualified];
 }
 class WrappingCode {
-    _start;
-    _end;
     constructor(start, end) {
         this._start = start;
         this._end = end;
@@ -291,14 +283,6 @@ class WrappingCode {
     }
 }
 class BaseString {
-    _stringType;
-    _constStringType;
-    _smatch;
-    _regex;
-    _stringLiteralPrefix;
-    _toString;
-    _encodingClass;
-    _encodingFunction;
     constructor(stringType, constStringType, smatch, regex, stringLiteralPrefix, toString, encodingClass, encodingFunction) {
         (this._stringType = stringType),
             (this._constStringType = constStringType),
@@ -329,39 +313,112 @@ class BaseString {
     }
 }
 class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
-    _options;
-    /**
-     * For forward declaration practically
-     */
-    _enumType;
-    _generatedFiles;
-    _currentFilename;
-    _allTypeNames;
-    _gettersAndSettersForPropertyName = new Map();
-    _namespaceNames;
-    _memberNameStyle;
-    _namedTypeNameStyle;
-    _generatedGlobalNames;
-    _generatedMemberNames;
-    _forbiddenGlobalNames;
-    _memberNamingFunction;
-    _stringType;
-    _optionalType;
-    _nulloptType;
-    _variantType;
-    _variantIndexMethodName;
-    typeNamingStyle;
-    enumeratorNamingStyle;
     constructor(targetLanguage, renderContext, _options) {
         super(targetLanguage, renderContext);
         this._options = _options;
+        this._gettersAndSettersForPropertyName = new Map();
+        this.NarrowString = new (class extends BaseString {
+            constructor() {
+                super("std::string", "const std::string & ", "std::smatch", "std::regex", "", new WrappingCode(["std::to_string("], [")"]), "", "");
+            }
+            wrapEncodingChange(_qualifier, _fromType, _toType, inner) {
+                return inner;
+            }
+            emitHelperFunctions() {
+                return;
+            }
+        })();
+        this.WideString = new (class extends BaseString {
+            constructor(superThis) {
+                super("std::wstring", "const std::wstring & ", "std::wsmatch", "std::wregex", "L", new WrappingCode(["std::to_wstring("], [")"]), "Utf16_Utf8", "convert");
+                this.superThis = superThis;
+            }
+            wrapEncodingChange(qualifier, fromType, toType, inner) {
+                if (this.superThis.sourcelikeToString(fromType) === this.superThis.sourcelikeToString(toType)) {
+                    return inner;
+                }
+                return [
+                    addQualifier(qualifier, [this._encodingClass]),
+                    "<",
+                    fromType,
+                    ", ",
+                    toType,
+                    ">::",
+                    this._encodingFunction,
+                    "(",
+                    inner,
+                    ")"
+                ];
+            }
+            emitHelperFunctions() {
+                this.superThis.emitLine("template<typename T>");
+                this.superThis.emitLine("struct tag {};");
+                this.superThis.ensureBlankLine();
+                this.superThis.emitLine("template<typename fromType, typename toType>");
+                this.superThis.emitBlock(["class Utf16_Utf8"], true, () => {
+                    this.superThis.emitLine("private:");
+                    this.superThis.emitLine("template<typename TF, typename TT>");
+                    this.superThis.emitBlock(["static toType convert(tag<std::shared_ptr<TF> >, tag<std::shared_ptr<TT> >, fromType ptr)"], false, () => {
+                        this.superThis.emitLine("if (ptr == nullptr) return std::unique_ptr<TT>(); else return std::unique_ptr<TT>(new TT(Utf16_Utf8<TF,TT>::convert(*ptr)));");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("template<typename TF, typename TT>");
+                    this.superThis.emitBlock(["static toType convert(tag<std::vector<TF> >, tag<std::vector<TT> >, fromType v)"], false, () => {
+                        this.superThis.emitLine("auto it = v.begin();");
+                        this.superThis.emitLine("auto newVector = std::vector<TT>();");
+                        this.superThis.emitBlock(["while (it != v.end())"], false, () => {
+                            this.superThis.emitLine("newVector.push_back(Utf16_Utf8<TF,TT>::convert(*it));");
+                            this.superThis.emitLine("it++;");
+                        });
+                        this.superThis.emitLine("return newVector;");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("template<typename KF, typename VF, typename KT, typename VT>");
+                    this.superThis.emitBlock(["static toType convert(tag<std::map<KF,VF> >, tag<std::map<KT,VT> >, fromType m)"], false, () => {
+                        this.superThis.emitLine("auto it = m.begin();");
+                        this.superThis.emitLine("auto newMap = std::map<KT, VT>();");
+                        this.superThis.emitBlock(["while (it != m.end())"], false, () => {
+                            this.superThis.emitLine("newMap.insert(std::pair<KT, VT>(Utf16_Utf8<KF, KT>::convert(it->first), Utf16_Utf8<VF, VT>::convert(it->second)));");
+                            this.superThis.emitLine("it++;");
+                        });
+                        this.superThis.emitLine("return newMap;");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("template<typename TF, typename TT>");
+                    this.superThis.emitBlock(["static fromType convert(tag<TF>, tag<TT>, fromType from)"], false, () => {
+                        this.superThis.emitLine("return from;");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitBlock(["static std::wstring convert(tag<std::string>, tag<std::wstring>, std::string str)"], false, () => {
+                        this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.from_bytes(str.data());");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitBlock(["static std::string convert(tag<std::wstring>, tag<std::string>, std::wstring str)"], false, () => {
+                        this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.to_bytes(str.data());");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("public:");
+                    this.superThis.emitBlock(["static toType convert(fromType in)"], false, () => {
+                        this.superThis.emitLine("return convert(tag<fromType>(), tag<toType>(), in);");
+                    });
+                });
+                this.superThis.ensureBlankLine();
+                this.superThis.emitLine("template<typename T>");
+                this.superThis.emitBlock(["std::wstring wdump(const T& j)"], false, () => {
+                    this.superThis.emitLine("std::ostringstream s;");
+                    this.superThis.emitLine("s << j;");
+                    this.superThis.emitLine("return ", this.superThis.ourQualifier(false), "Utf16_Utf8<std::string, std::wstring>::convert(s.str()); ");
+                });
+                this.superThis.ensureBlankLine();
+            }
+        })(this);
         this._enumType = _options.enumType;
         this._namespaceNames = _options.namespace.split("::");
         this.typeNamingStyle = _options.typeNamingStyle;
-        this._namedTypeNameStyle = (0, Strings_1.makeNameStyle)(this.typeNamingStyle, legalizeName);
+        this._namedTypeNameStyle = Strings_1.makeNameStyle(this.typeNamingStyle, legalizeName);
         this.enumeratorNamingStyle = _options.enumeratorNamingStyle;
-        this._memberNameStyle = (0, Strings_1.makeNameStyle)(_options.memberNamingStyle, legalizeName);
-        this._memberNamingFunction = (0, Naming_1.funPrefixNamer)("members", this._memberNameStyle);
+        this._memberNameStyle = Strings_1.makeNameStyle(_options.memberNamingStyle, legalizeName);
+        this._memberNamingFunction = Naming_1.funPrefixNamer("members", this._memberNameStyle);
         this._gettersAndSettersForPropertyName = new Map();
         this._allTypeNames = new Set();
         this._generatedFiles = new Set();
@@ -424,10 +481,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         ];
     }
     lookupGlobalName(type) {
-        return (0, Support_1.defined)(this._generatedGlobalNames.get(type));
+        return Support_1.defined(this._generatedGlobalNames.get(type));
     }
     lookupMemberName(type) {
-        return (0, Support_1.defined)(this._generatedMemberNames.get(type));
+        return Support_1.defined(this._generatedMemberNames.get(type));
     }
     addGlobalName(type) {
         const genName = this._namedTypeNameStyle(GlobalNames[type]);
@@ -438,10 +495,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this._generatedMemberNames.set(type, this._memberNameStyle(MemberNames[type]));
     }
     setupGlobalNames() {
-        for (const v of (0, Support_1.numberEnumValues)(GlobalNames)) {
+        for (const v of Support_1.numberEnumValues(GlobalNames)) {
             this.addGlobalName(v);
         }
-        for (const v of (0, Support_1.numberEnumValues)(MemberNames)) {
+        for (const v of Support_1.numberEnumValues(MemberNames)) {
             this.addMemberName(v);
         }
     }
@@ -455,7 +512,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return { names: [], includeGlobalForbidden: true };
     }
     makeNamedTypeNamer() {
-        return (0, Naming_1.funPrefixNamer)("types", this._namedTypeNameStyle);
+        return Naming_1.funPrefixNamer("types", this._namedTypeNameStyle);
     }
     namerForObjectProperty() {
         return this._memberNamingFunction;
@@ -464,7 +521,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return null;
     }
     makeEnumCaseNamer() {
-        return (0, Naming_1.funPrefixNamer)("enumerators", (0, Strings_1.makeNameStyle)(this.enumeratorNamingStyle, legalizeName));
+        return Naming_1.funPrefixNamer("enumerators", Strings_1.makeNameStyle(this.enumeratorNamingStyle, legalizeName));
     }
     makeNamesForPropertyGetterAndSetter(_c, _className, _p, _jsonName, name) {
         const getterName = new Naming_1.DependencyName(this._memberNamingFunction, name.order, lookup => `get_${lookup(name)}`);
@@ -489,7 +546,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("#include ", global ? "<" : '"', name, global ? ">" : '"');
     }
     startFile(basename, includeHelper = true) {
-        (0, Support_2.assert)(this._currentFilename === undefined, "Previous file wasn't finished");
+        Support_2.assert(this._currentFilename === undefined, "Previous file wasn't finished");
         if (basename !== undefined) {
             this._currentFilename = this.sourcelikeToString(basename);
         }
@@ -509,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, ");");
                 });
             }
         }
@@ -549,7 +606,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.ensureBlankLine();
     }
     finishFile() {
-        super.finishFile((0, Support_1.defined)(this._currentFilename));
+        super.finishFile(Support_1.defined(this._currentFilename));
         this._currentFilename = undefined;
     }
     get needsTypeDeclarationBeforeUse() {
@@ -580,7 +637,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
     }
     emitNamespaces(namespaceNames, f) {
-        const namesArray = (0, collection_utils_1.toReadonlyArray)(namespaceNames);
+        const namesArray = collection_utils_1.toReadonlyArray(namespaceNames);
         const first = namesArray[0];
         if (first === undefined) {
             f();
@@ -591,7 +648,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     cppTypeInOptional(nonNulls, ctx, withIssues, forceNarrowString) {
         if (nonNulls.size === 1) {
-            return this.cppType((0, Support_1.defined)((0, collection_utils_1.iterableFirst)(nonNulls)), ctx, withIssues, forceNarrowString, false);
+            return this.cppType(Support_1.defined(collection_utils_1.iterableFirst(nonNulls)), ctx, withIssues, forceNarrowString, false);
         }
         const typeList = [];
         for (const t of nonNulls) {
@@ -607,8 +664,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return [this._variantType, "<", typeList, ">"];
     }
     variantType(u, inJsonNamespace) {
-        const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(u, true);
-        (0, Support_2.assert)(nonNulls.size >= 2, "Variant not needed for less than two types.");
+        const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(u, true);
+        Support_2.assert(nonNulls.size >= 2, "Variant not needed for less than two types.");
         const indirection = maybeNull !== null;
         const variant = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: !indirection, needsOptionalIndirection: !indirection, inJsonNamespace }, true, false);
         if (!indirection) {
@@ -617,12 +674,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return [optionalType, "<", variant, ">"];
     }
     ourQualifier(inJsonNamespace) {
-        return inJsonNamespace || this._options.msbuildPermissive
-            ? [(0, 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)
@@ -640,18 +695,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
             }
         }
-        let typeSource = (0, TypeUtils_1.matchType)(t, _anyType => {
+        let typeSource = TypeUtils_1.matchType(t, _anyType => {
             isOptional = false;
-            return (0, 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 (0, 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";
@@ -676,7 +725,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 ">"
             ];
         }, enumType => [this.ourQualifier(inJsonNamespace), this.nameForNamedType(enumType)], unionType => {
-            const nullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
+            const nullable = TypeUtils_1.nullableFromUnion(unionType);
             if (nullable === null)
                 return [this.ourQualifier(inJsonNamespace), this.nameForNamedType(unionType)];
             isOptional = true;
@@ -743,7 +792,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     });
                     /** intentional "fall-through", add all subtypes as well - but forced include */
                 }
-                const [hasNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t);
+                const [hasNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t);
                 isVariant = hasNull !== null;
                 /** we need to collect all the subtypes of the union */
                 for (const tt of nonNulls) {
@@ -780,7 +829,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitMember(this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, property.isOptional), name);
             }
             else {
-                const [getterName, mutableGetterName, setterName] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
+                const [getterName, mutableGetterName, setterName] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
                 const rendered = this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, property.isOptional);
                 /**
                  * fix for optional type -> e.g. unique_ptrs can't be copied
@@ -839,7 +888,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     : [
                         this._stringType.getType(),
                         "(",
-                        this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(pattern)]),
+                        this._stringType.createStringLiteral([Strings_1.stringEscape(pattern)]),
                         ")"
                     ],
                 ")"
@@ -879,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([
@@ -910,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([
@@ -922,12 +974,12 @@ 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, () => {
             this.forEachClassProperty(c, "none", (name, json, p) => {
-                const [, , setterName] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
+                const [, , setterName] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
                 const t = p.type;
                 let assignment;
                 if (this._options.codeFormat) {
@@ -940,7 +992,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     this.emitLine(assignment.wrap([], [
                         ourQualifier,
                         "get_untyped(j, ",
-                        this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
+                        this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(json)])]),
                         ")"
                     ]), ";");
                     return;
@@ -948,7 +1000,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 if (p.isOptional || t instanceof Type_1.UnionType) {
                     const [nullOrOptional, typeSet] = (function () {
                         if (t instanceof Type_1.UnionType) {
-                            const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t, true);
+                            const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t, true);
                             return [maybeNull !== null || p.isOptional, nonNulls];
                         }
                         else {
@@ -961,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, ">"], [
@@ -974,18 +1026,18 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                                 "get_optional<",
                                 cppType,
                                 ">(j, ",
-                                this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
+                                this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(json)])]),
                                 ")"
                             ])
                         ]), ";");
                         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([(0, Strings_1.stringEscape)(json)])),
+                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
                     ").get<",
                     cppType,
                     ">()"
@@ -997,9 +1049,9 @@ 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);
-                const [getterName, ,] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
+                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) {
                     getter = [getterName, "()"];
@@ -1009,7 +1061,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
                 let assignment = [
                     "j[",
-                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])),
+                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
                     "] = ",
                     this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]),
                     ";"
@@ -1031,13 +1083,13 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitEnum(e, enumName) {
         const caseNames = [];
-        const enumValues = (0, EnumValues_1.enumCaseValues)(e, this.targetLanguage.name);
+        const enumValues = EnumValues_1.enumCaseValues(e, this.targetLanguage.name);
         this.forEachEnumCase(e, "none", (name, jsonName) => {
             if (caseNames.length > 0)
                 caseNames.push(", ");
             caseNames.push(name);
             if (enumValues !== undefined) {
-                const [enumValue] = (0, AccessorNames_1.getAccessorName)(enumValues, jsonName);
+                const [enumValue] = AccessorNames_1.getAccessorName(enumValues, jsonName);
                 if (enumValue !== undefined) {
                     caseNames.push(" = ", enumValue.toString());
                 }
@@ -1050,12 +1102,21 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("using ", unionName, " = ", this.variantType(u, false), ";");
     }
     emitUnionHeaders(u) {
-        const nonNulls = (0, TypeUtils_1.removeNullFromUnion)(u, true)[1];
+        // 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"],
@@ -1067,12 +1128,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             ["array", "is_array"],
             ["enum", "is_string"]
         ];
-        const nonNulls = (0, TypeUtils_1.removeNullFromUnion)(u, true)[1];
+        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 = (0, collection_utils_1.iterableFind)(nonNulls, t => t.kind === kind);
+                const typeForKind = collection_utils_1.iterableFind(nonNulls, t => t.kind === kind);
                 if (typeForKind === undefined)
                     continue;
                 this.emitLine(onFirst ? "if" : "else if", " (j.", func, "())");
@@ -1090,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) {
@@ -1120,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);");
     }
@@ -1130,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([
@@ -1142,7 +1203,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     "> enumValues"
                 ], true, () => {
                     this.forEachEnumCase(e, "none", (name, jsonName) => {
-                        this.emitLine("{", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(jsonName)])]), ", ", ourQualifier, enumName, "::", name, "},");
+                        this.emitLine("{", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ", ", ourQualifier, enumName, "::", name, "},");
                     });
                 });
                 this.emitLine(`auto iter = enumValues.find(j.get<${this._stringType.getType()}>());`);
@@ -1154,7 +1215,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 let onFirst = true;
                 this.forEachEnumCase(e, "none", (name, jsonName) => {
                     const maybeElse = onFirst ? "" : "else ";
-                    this.emitLine(maybeElse, "if (j == ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(jsonName)])]), ") x = ", ourQualifier, enumName, "::", name, ";");
+                    this.emitLine(maybeElse, "if (j == ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ") x = ", ourQualifier, enumName, "::", name, ";");
                     onFirst = false;
                 });
                 this.emitLine('else throw "Input JSON does not conform to schema";');
@@ -1164,7 +1225,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitBlock(["inline void to_json(json & j, ", this.withConst([ourQualifier, enumName]), " & x)"], false, () => {
             this.emitBlock("switch (x)", false, () => {
                 this.forEachEnumCase(e, "none", (name, jsonName) => {
-                    this.emitLine("case ", ourQualifier, enumName, "::", name, ": j = ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(jsonName)])]), "; break;");
+                    this.emitLine("case ", ourQualifier, enumName, "::", name, ": j = ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), "; break;");
                 });
                 this.emitLine('default: throw "This should not happen";');
             });
@@ -1174,10 +1235,10 @@ 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((0, 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((0, TypeUtils_1.removeNullFromUnion)(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionHeaders(u));
+        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));
     }
     emitOptionalHelpers() {
         this.emitLine("#ifndef NLOHMANN_OPT_HELPER");
@@ -1218,11 +1279,11 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitUnionTypedefs(t, name);
             }
             else {
-                return (0, Support_1.panic)(`Cannot declare type ${t.kind}`);
+                return Support_1.panic(`Cannot declare type ${t.kind}`);
             }
         }
         else {
-            return (0, Support_1.assertNever)(decl.kind);
+            return Support_1.assertNever(decl.kind);
         }
     }
     emitGetterSetter(t, getterName, setterName, memberName) {
@@ -1256,12 +1317,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 const member = this.lookupMemberName(name);
                 return [member, "(", member, ")"];
             });
-            this.emitLine(") : ", (0, collection_utils_1.arrayIntercalate)([", "], args), " {}");
+            this.emitLine(") : ", collection_utils_1.arrayIntercalate([", "], args), " {}");
             this.emitLine(classConstraint, "() = default;");
             this.emitLine("virtual ~", classConstraint, "() = default;");
             for (const member of constraintMembers) {
                 this.ensureBlankLine();
-                this.emitGetterSetter((0, collection_utils_1.withDefault)(member.cppConstType, member.cppType), this.lookupMemberName(member.getter), this.lookupMemberName(member.setter), this.lookupMemberName(member.name));
+                this.emitGetterSetter(collection_utils_1.withDefault(member.cppConstType, member.cppType), this.lookupMemberName(member.getter), this.lookupMemberName(member.setter), this.lookupMemberName(member.name));
             }
         });
         this.ensureBlankLine();
@@ -1354,14 +1415,14 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     emitHelperFunctions() {
         this._stringType.emitHelperFunctions();
         if (this._options.codeFormat &&
-            (0, collection_utils_1.iterableSome)(this.typeGraph.allTypesUnordered(), t => constraintsForType(t) !== undefined)) {
+            collection_utils_1.iterableSome(this.typeGraph.allTypesUnordered(), t => constraintsForType(t) !== undefined)) {
             this.emitConstraintClasses();
             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 += "_";
@@ -1461,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) {
@@ -1534,7 +1628,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             else if (t.type instanceof Type_1.UnionType) {
                 propRecord.typeKind = "union";
                 /** Recurse into the union */
-                const [maybeNull] = (0, TypeUtils_1.removeNullFromUnion)(t.type, true);
+                const [maybeNull] = TypeUtils_1.removeNullFromUnion(t.type, true);
                 if (maybeNull !== undefined) {
                     /** Houston this is a variant, include it */
                     propRecord.kind = IncludeKind.Include;
@@ -1618,7 +1712,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             this.emitLine("enum class ", name, " : ", this._enumType, ";");
                         }
                         else {
-                            (0, Support_1.panic)(`Invalid type "${rec.typeKind}" to forward declare`);
+                            Support_1.panic(`Invalid type "${rec.typeKind}" to forward declare`);
                         }
                     });
                 });
@@ -1689,8 +1783,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         /** Gather all the unique/custom types used by the schema */
         this._allTypeNames.clear();
         this.forEachDeclaration("none", decl => {
-            const definedTypes = (0, TypeUtils_1.directlyReachableTypes)(decl.type, t => {
-                if ((0, TypeUtils_1.isNamedType)(t) && (t instanceof Type_1.ClassType || t instanceof Type_1.EnumType || t instanceof Type_1.UnionType)) {
+            const definedTypes = TypeUtils_1.directlyReachableTypes(decl.type, t => {
+                if (TypeUtils_1.isNamedType(t) && (t instanceof Type_1.ClassType || t instanceof Type_1.EnumType || t instanceof Type_1.UnionType)) {
                     return new Set([
                         this.sourcelikeToString(this.cppType(t, {
                             needsForwardIndirection: false,
@@ -1701,7 +1795,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
                 return null;
             });
-            this._allTypeNames = (0, collection_utils_1.setUnion)(definedTypes, this._allTypeNames);
+            this._allTypeNames = collection_utils_1.setUnion(definedTypes, this._allTypeNames);
         });
         if (this._options.typeSourceStyle) {
             this.emitSingleSourceStructure(proposedFilename);
@@ -1715,101 +1809,5 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         let newType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
         return originalType !== newType;
     }
-    NarrowString = new (class extends BaseString {
-        constructor() {
-            super("std::string", "const std::string & ", "std::smatch", "std::regex", "", new WrappingCode(["std::to_string("], [")"]), "", "");
-        }
-        wrapEncodingChange(_qualifier, _fromType, _toType, inner) {
-            return inner;
-        }
-        emitHelperFunctions() {
-            return;
-        }
-    })();
-    WideString = new (class extends BaseString {
-        superThis;
-        constructor(superThis) {
-            super("std::wstring", "const std::wstring & ", "std::wsmatch", "std::wregex", "L", new WrappingCode(["std::to_wstring("], [")"]), "Utf16_Utf8", "convert");
-            this.superThis = superThis;
-        }
-        wrapEncodingChange(qualifier, fromType, toType, inner) {
-            if (this.superThis.sourcelikeToString(fromType) === this.superThis.sourcelikeToString(toType)) {
-                return inner;
-            }
-            return [
-                addQualifier(qualifier, [this._encodingClass]),
-                "<",
-                fromType,
-                ", ",
-                toType,
-                ">::",
-                this._encodingFunction,
-                "(",
-                inner,
-                ")"
-            ];
-        }
-        emitHelperFunctions() {
-            this.superThis.emitLine("template<typename T>");
-            this.superThis.emitLine("struct tag {};");
-            this.superThis.ensureBlankLine();
-            this.superThis.emitLine("template<typename fromType, typename toType>");
-            this.superThis.emitBlock(["class Utf16_Utf8"], true, () => {
-                this.superThis.emitLine("private:");
-                this.superThis.emitLine("template<typename TF, typename TT>");
-                this.superThis.emitBlock(["static toType convert(tag<std::shared_ptr<TF> >, tag<std::shared_ptr<TT> >, fromType ptr)"], false, () => {
-                    this.superThis.emitLine("if (ptr == nullptr) return std::unique_ptr<TT>(); else return std::unique_ptr<TT>(new TT(Utf16_Utf8<TF,TT>::convert(*ptr)));");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("template<typename TF, typename TT>");
-                this.superThis.emitBlock(["static toType convert(tag<std::vector<TF> >, tag<std::vector<TT> >, fromType v)"], false, () => {
-                    this.superThis.emitLine("auto it = v.begin();");
-                    this.superThis.emitLine("auto newVector = std::vector<TT>();");
-                    this.superThis.emitBlock(["while (it != v.end())"], false, () => {
-                        this.superThis.emitLine("newVector.push_back(Utf16_Utf8<TF,TT>::convert(*it));");
-                        this.superThis.emitLine("it++;");
-                    });
-                    this.superThis.emitLine("return newVector;");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("template<typename KF, typename VF, typename KT, typename VT>");
-                this.superThis.emitBlock(["static toType convert(tag<std::map<KF,VF> >, tag<std::map<KT,VT> >, fromType m)"], false, () => {
-                    this.superThis.emitLine("auto it = m.begin();");
-                    this.superThis.emitLine("auto newMap = std::map<KT, VT>();");
-                    this.superThis.emitBlock(["while (it != m.end())"], false, () => {
-                        this.superThis.emitLine("newMap.insert(std::pair<KT, VT>(Utf16_Utf8<KF, KT>::convert(it->first), Utf16_Utf8<VF, VT>::convert(it->second)));");
-                        this.superThis.emitLine("it++;");
-                    });
-                    this.superThis.emitLine("return newMap;");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("template<typename TF, typename TT>");
-                this.superThis.emitBlock(["static fromType convert(tag<TF>, tag<TT>, fromType from)"], false, () => {
-                    this.superThis.emitLine("return from;");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitBlock(["static std::wstring convert(tag<std::string>, tag<std::wstring>, std::string str)"], false, () => {
-                    this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.from_bytes(str.data());");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitBlock(["static std::string convert(tag<std::wstring>, tag<std::string>, std::wstring str)"], false, () => {
-                    this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.to_bytes(str.data());");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("public:");
-                this.superThis.emitBlock(["static toType convert(fromType in)"], false, () => {
-                    this.superThis.emitLine("return convert(tag<fromType>(), tag<toType>(), in);");
-                });
-            });
-            this.superThis.ensureBlankLine();
-            this.superThis.emitLine("template<typename T>");
-            this.superThis.emitBlock(["std::wstring wdump(const T& j)"], false, () => {
-                this.superThis.emitLine("std::ostringstream s;");
-                this.superThis.emitLine("s << j;");
-                this.superThis.emitLine("return ", this.superThis.ourQualifier(false), "Utf16_Utf8<std::string, std::wstring>::convert(s.str()); ");
-            });
-            this.superThis.ensureBlankLine();
-        }
-    })(this);
 }
 exports.CPlusPlusRenderer = CPlusPlusRenderer;