quicktype-core 20.0.26 → 21.0.0

package/dist/language/CPlusPlus.d.ts

@@ -120,12 +120,22 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     private readonly _memberNamingFunction;
     private _stringType;
     private _optionalType;
+    private _optionalFactory;
     private _nulloptType;
     private _variantType;
     private _variantIndexMethodName;
     protected readonly typeNamingStyle: NamingStyle;
     protected readonly enumeratorNamingStyle: NamingStyle;
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _options: OptionValues<typeof cPlusPlusOptions>);
+    isUnion(t: Type | UnionType): t is UnionType;
+    isOptionalAsValuePossible(t: Type): boolean;
+    isImplicitCycleBreaker(t: Type): boolean;
+    optionalTypeStack(): string;
+    optionalFactoryStack(): string;
+    optionalTypeHeap(): string;
+    optionalFactoryHeap(): string;
+    optionalType(t: Type): string;
+    optionalTypeLabel(t: Type): string;
     protected getConstraintMembers(): ConstraintMember[];
     protected lookupGlobalName(type: GlobalNames): string;
     protected lookupMemberName(type: MemberNames): string;
@@ -154,7 +164,7 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     protected variantType(u: UnionType, inJsonNamespace: boolean): Sourcelike;
     protected ourQualifier(inJsonNamespace: boolean): Sourcelike;
     protected jsonQualifier(inJsonNamespace: boolean): Sourcelike;
-    protected variantIndirection(needIndirection: boolean, typeSrc: Sourcelike): Sourcelike;
+    protected variantIndirection(type: Type, needIndirection: boolean, typeSrc: Sourcelike): Sourcelike;
     protected cppType(t: Type, ctx: TypeContext, withIssues: boolean, forceNarrowString: boolean, isOptional: boolean): Sourcelike;
     /**
      * similar to cppType, it practically gathers all the generated types within

package/dist/language/CPlusPlus.js

@@ -216,19 +216,10 @@ const keywords = [
     "transaction_safe_dynamic",
     "NULL"
 ];
-/**
- * We can't use boost/std optional. They MUST have the declaration of
- * the given structure available, meaning we can't forward declare anything.
- * Which is bad as we have circles in Json schema, which require at least
- * forward declarability.
- * The next question, why isn't unique_ptr is enough here?
- * That problem relates to getter/setter. If using getter/setters we
- * can't/mustn't return a unique_ptr out of the class -> as that is the
- * sole reason why we have declared that as unique_ptr, so that only
- * the class owns it. We COULD return unique_ptr references, which practically
- * kills the uniqueness of the smart pointer -> hence we use shared_ptrs.
- */
-const optionalType = "std::shared_ptr";
+/// Type to use as an optional if cycle breaking is required
+const optionalAsSharedType = "std::shared_ptr";
+/// Factory to use when creating an optional if cycle breaking is required
+const optionalFactoryAsSharedType = "std::make_shared";
 /**
  * To be able to support circles in multiple files -
  * e.g. class#A using class#B using class#A (obviously not directly,
@@ -434,18 +425,124 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         if (_options.boost) {
             this._optionalType = "boost::optional";
+            this._optionalFactory = "boost::optional";
             this._nulloptType = "boost::none";
             this._variantType = "boost::variant";
             this._variantIndexMethodName = "which";
         }
         else {
             this._optionalType = "std::optional";
+            this._optionalFactory = "std::make_optional";
             this._nulloptType = "std::nullopt";
             this._variantType = "std::variant";
             this._variantIndexMethodName = "index";
         }
         this.setupGlobalNames();
     }
+    // union typeguard
+    isUnion(t) {
+        return t.kind === "union";
+    }
+    // Returns true if the type can be stored in
+    // a stack based optional type. This requires
+    // that the type does not require forward declaration.
+    isOptionalAsValuePossible(t) {
+        if (this.isForwardDeclaredType(t))
+            return false;
+        if (this.isUnion(t)) {
+            // There is something stinky about this test.
+            // There is special handling somewhere that if you
+            // have the following schema
+            // {
+            //     "$schema": "http://json-schema.org/draft-06/schema#",
+            //     "$ref": "#/definitions/List",
+            //     "definitions": {
+            //         "List": {
+            //             "type": "object",
+            //             "additionalProperties": false,
+            //             "properties": {
+            //                 "data": {
+            //                     "type": "string"
+            //                 },
+            //                 "next": {
+            //                     "anyOf": [
+            //                         {
+            //                             "$ref": "#/definitions/List"
+            //                         }
+            //                         {
+            //                             "type": "null"
+            //                         }
+            //                     ]
+            //                 }
+            //             },
+            //             "required": [],
+            //             "title": "List"
+            //         }
+            //     }
+            // }
+            // Then a variant is not output but the single item inlined
+            //
+            //     struct TopLevel {
+            //       std::optional<std::string> data;
+            //       std::optional<TopLevel> next;
+            //     };
+            //
+            // instead of
+            //     struct TopLevel {
+            //       std::optional<std::string> data;
+            //       std::shared_ptr<TopLevel> next;
+            //     };
+            //
+            // checking to see if the collapse of the variant has
+            // occured and then doing the isCycleBreakerType check
+            // on the single type the variant would contain seems
+            // to solve the problem. But does this point to a problem
+            // with the core library or with the CPlusPlus package
+            const [, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t);
+            if (nonNulls.size === 1) {
+                const tt = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(nonNulls));
+                return !this.isCycleBreakerType(tt);
+            }
+        }
+        return !this.isCycleBreakerType(t);
+    }
+    isImplicitCycleBreaker(t) {
+        const kind = t.kind;
+        return kind === "array" || kind === "map";
+    }
+    // Is likely to return std::optional or boost::optional
+    optionalTypeStack() {
+        return this._optionalType;
+    }
+    // Is likely to return std::make_optional or boost::optional
+    optionalFactoryStack() {
+        return this._optionalFactory;
+    }
+    // Is likely to return std::shared_ptr
+    optionalTypeHeap() {
+        return optionalAsSharedType;
+    }
+    // Is likely to return std::make_shared
+    optionalFactoryHeap() {
+        return optionalFactoryAsSharedType;
+    }
+    // Returns the optional type most suitable for the given type.
+    // Classes that don't require forward declarations can be stored
+    // in std::optional ( or boost::optional )
+    optionalType(t) {
+        if (this.isOptionalAsValuePossible(t))
+            return this.optionalTypeStack();
+        else
+            return this.optionalTypeHeap();
+    }
+    // Returns a label that can be used to distinguish between
+    // heap and stack based optional handling methods
+    optionalTypeLabel(t) {
+        if (this.isOptionalAsValuePossible(t))
+            return "stack";
+        else
+            return "heap";
+    }
     getConstraintMembers() {
         return [
             {
@@ -672,7 +769,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         if (!indirection) {
             return variant;
         }
-        return [optionalType, "<", variant, ">"];
+        return [this.optionalType(u), "<", variant, ">"];
     }
     ourQualifier(inJsonNamespace) {
         return inJsonNamespace ? [(0, collection_utils_1.arrayIntercalate)("::", this._namespaceNames), "::"] : [];
@@ -680,10 +777,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     jsonQualifier(inJsonNamespace) {
         return inJsonNamespace ? [] : "nlohmann::";
     }
-    variantIndirection(needIndirection, typeSrc) {
+    variantIndirection(type, needIndirection, typeSrc) {
         if (!needIndirection)
             return typeSrc;
-        return [optionalType, "<", typeSrc, ">"];
+        return [this.optionalType(type), "<", typeSrc, ">"];
     }
     cppType(t, ctx, withIssues, forceNarrowString, isOptional) {
         const inJsonNamespace = ctx.inJsonNamespace;
@@ -719,7 +816,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             "std::vector<",
             this.cppType(arrayType.items, { needsForwardIndirection: false, needsOptionalIndirection: true, inJsonNamespace }, withIssues, forceNarrowString, false),
             ">"
-        ], classType => this.variantIndirection(ctx.needsForwardIndirection && this.isForwardDeclaredType(classType) && !isOptional, [this.ourQualifier(inJsonNamespace), this.nameForNamedType(classType)]), mapType => {
+        ], classType => this.variantIndirection(classType, ctx.needsForwardIndirection && this.isForwardDeclaredType(classType) && !isOptional, [this.ourQualifier(inJsonNamespace), this.nameForNamedType(classType)]), mapType => {
             let keyType = this._stringType.getType();
             if (forceNarrowString) {
                 keyType = "std::string";
@@ -733,14 +830,17 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             ];
         }, enumType => [this.ourQualifier(inJsonNamespace), this.nameForNamedType(enumType)], unionType => {
             const nullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
-            if (nullable === null)
+            if (nullable !== null) {
+                isOptional = true;
+                return this.cppType(nullable, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace }, withIssues, forceNarrowString, false);
+            }
+            else {
                 return [this.ourQualifier(inJsonNamespace), this.nameForNamedType(unionType)];
-            isOptional = true;
-            return this.cppType(nullable, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace }, withIssues, forceNarrowString, false);
+            }
         });
         if (!isOptional)
             return typeSource;
-        return [optionalType, "<", typeSource, ">"];
+        return [this.optionalType(t), "<", typeSource, ">"];
     }
     /**
      * similar to cppType, it practically gathers all the generated types within
@@ -938,8 +1038,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         // 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("template <>");
             this.emitBlock(["struct adl_serializer<", ourQualifier, className, ">"], true, () => {
+                this.emitLine("template <>");
                 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);");
             });
@@ -1045,9 +1145,9 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             inJsonNamespace: false
                         }, false, false);
                         this.emitLine(assignment.wrap([], [
-                            this._stringType.wrapEncodingChange([ourQualifier], [optionalType, "<", cppType, ">"], [optionalType, "<", toType, ">"], [
+                            this._stringType.wrapEncodingChange([ourQualifier], [this.optionalType(t), "<", cppType, ">"], [this.optionalType(t), "<", toType, ">"], [
                                 ourQualifier,
-                                "get_optional<",
+                                `get_${this.optionalTypeLabel(t)}_optional<`,
                                 cppType,
                                 ">(j, ",
                                 this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
@@ -1276,16 +1376,20 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("#ifndef NLOHMANN_OPT_HELPER");
         this.emitLine("#define NLOHMANN_OPT_HELPER");
         this.emitNamespaces(["nlohmann"], () => {
-            this.emitLine("template <typename T>");
-            this.emitBlock(["struct adl_serializer<", optionalType, "<T>>"], true, () => {
-                this.emitBlock(["static void to_json(json & j, ", this.withConst([optionalType, "<T>"]), " & opt)"], false, () => {
-                    this.emitLine("if (!opt) j = nullptr; else j = *opt;");
-                });
-                this.ensureBlankLine();
-                this.emitBlock(["static ", optionalType, "<T> from_json(", this.withConst("json"), " & j)"], false, () => {
-                    this.emitLine(`if (j.is_null()) return std::unique_ptr<T>(); else return std::unique_ptr<T>(new T(j.get<T>()));`);
+            const emitAdlStruct = (optType, factory) => {
+                this.emitLine("template <typename T>");
+                this.emitBlock(["struct adl_serializer<", optType, "<T>>"], true, () => {
+                    this.emitBlock(["static void to_json(json & j, ", this.withConst([optType, "<T>"]), " & opt)"], false, () => {
+                        this.emitLine("if (!opt) j = nullptr; else j = *opt;");
+                    });
+                    this.ensureBlankLine();
+                    this.emitBlock(["static ", optType, "<T> from_json(", this.withConst("json"), " & j)"], false, () => {
+                        this.emitLine(`if (j.is_null()) return ${factory}<T>(); else return ${factory}<T>(j.get<T>());`);
+                    });
                 });
-            });
+            };
+            emitAdlStruct(this.optionalTypeHeap(), this.optionalFactoryHeap());
+            emitAdlStruct(this.optionalTypeStack(), this.optionalFactoryStack());
         });
         this.emitLine("#endif");
     }
@@ -1481,26 +1585,37 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
             this.emitLine("#ifndef " + optionalMacroName);
             this.emitLine("#define " + optionalMacroName);
-            this.emitLine("template <typename T>");
-            this.emitBlock([
-                "inline ",
-                optionalType,
-                "<T> get_optional(",
-                this.withConst("json"),
-                " & j, ",
-                this.withConst("char"),
-                " * property)"
-            ], false, () => {
-                this.emitBlock(["if (j.find(property) != j.end())"], false, () => {
-                    this.emitLine("return j.at(property).get<", optionalType, "<T>>();");
+            const emitGetOptional = (optionalType, label) => {
+                this.emitLine("template <typename T>");
+                this.emitBlock([
+                    "inline ",
+                    optionalType,
+                    `<T> get_${label}_optional(`,
+                    this.withConst("json"),
+                    " & j, ",
+                    this.withConst("char"),
+                    " * property)"
+                ], false, () => {
+                    this.emitLine(["auto it = j.find(property);"]);
+                    this.emitBlock(["if (it != j.end() && !it->is_null())"], false, () => {
+                        this.emitLine("return j.at(property).get<", optionalType, "<T>>();");
+                    });
+                    this.emitLine("return ", optionalType, "<T>();");
                 });
-                this.emitLine("return ", optionalType, "<T>();");
-            });
-            this.ensureBlankLine();
-            this.emitLine("template <typename T>");
-            this.emitBlock(["inline ", optionalType, "<T> get_optional(", this.withConst("json"), " & j, std::string property)"], false, () => {
-                this.emitLine("return get_optional<T>(j, property.data());");
-            });
+                this.ensureBlankLine();
+                this.emitLine("template <typename T>");
+                this.emitBlock([
+                    "inline ",
+                    optionalType,
+                    `<T> get_${label}_optional(`,
+                    this.withConst("json"),
+                    " & j, std::string property)"
+                ], false, () => {
+                    this.emitLine(`return get_${label}_optional<T>(j, property.data());`);
+                });
+            };
+            emitGetOptional(this.optionalTypeHeap(), "heap");
+            emitGetOptional(this.optionalTypeStack(), "stack");
             this.emitLine("#endif");
             this.ensureBlankLine();
         }

package/dist/language/Dart.d.ts

@@ -54,10 +54,11 @@ export declare class DartRenderer extends ConvenienceRenderer {
     protected emitDescriptionBlock(lines: Sourcelike[]): void;
     protected emitBlock(line: Sourcelike, f: () => void): void;
     protected dartType(t: Type, withIssues?: boolean): Sourcelike;
-    protected mapList(itemType: Sourcelike, list: Sourcelike, mapper: Sourcelike): Sourcelike;
-    protected mapMap(valueType: Sourcelike, map: Sourcelike, valueMapper: Sourcelike): Sourcelike;
-    protected fromDynamicExpression(t: Type, ...dynamic: Sourcelike[]): Sourcelike;
-    protected toDynamicExpression(t: Type, ...dynamic: Sourcelike[]): Sourcelike;
+    protected mapList(isNullable: boolean, itemType: Sourcelike, list: Sourcelike, mapper: Sourcelike): Sourcelike;
+    protected mapMap(isNullable: boolean, valueType: Sourcelike, map: Sourcelike, valueMapper: Sourcelike): Sourcelike;
+    protected mapClass(isNullable: boolean, classType: ClassType, dynamic: Sourcelike): Sourcelike[];
+    protected fromDynamicExpression(isNullable: boolean | undefined, t: Type, ...dynamic: Sourcelike[]): Sourcelike;
+    protected toDynamicExpression(isNullable: boolean | undefined, t: Type, ...dynamic: Sourcelike[]): Sourcelike;
     protected emitClassDefinition(c: ClassType, className: Name): void;
     protected emitFreezedClassDefinition(c: ClassType, className: Name): void;
     protected emitEnumDefinition(e: EnumType, enumName: Name): void;

package/dist/language/Dart.js

@@ -49,7 +49,6 @@ class DartTargetLanguage extends TargetLanguage_1.TargetLanguage {
         const mapping = new Map();
         mapping.set("date", "date");
         mapping.set("date-time", "date-time");
-        //        mapping.set("uuid", "uuid");
         return mapping;
     }
     makeRenderer(renderContext, untypedOptionValues) {
@@ -269,132 +268,97 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("}");
     }
     dartType(t, withIssues = false) {
-        return (0, TypeUtils_1.matchType)(t, _anyType => (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.anyTypeIssueAnnotation, "dynamic"), _nullType => (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.nullTypeIssueAnnotation, "dynamic"), _boolType => {
-            if (this._options.nullSafety) {
-                return ["bool", "?"];
-            }
-            return "bool";
-        }, _integerType => {
-            if (this._options.nullSafety) {
-                return ["int", "?"];
-            }
-            return "int";
-        }, _doubleType => {
-            if (this._options.nullSafety) {
-                return ["double", "?"];
-            }
-            return "double";
-        }, _stringType => {
-            if (this._options.nullSafety) {
-                return ["String", "?"];
-            }
-            return "String";
-        }, arrayType => {
-            if (this._options.nullSafety) {
-                return ["List<", this.dartType(arrayType.items, withIssues), ">", "?"];
-            }
-            return ["List<", this.dartType(arrayType.items, withIssues), ">"];
-        }, classType => {
-            if (this._options.nullSafety) {
-                return [this.nameForNamedType(classType), "?"];
-            }
-            return this.nameForNamedType(classType);
-        }, mapType => {
-            if (this._options.nullSafety) {
-                return [["Map<String, ", this.dartType(mapType.values, withIssues), ">"], "?"];
-            }
-            return ["Map<String, ", this.dartType(mapType.values, withIssues), ">"];
-        }, enumType => {
-            if (this._options.nullSafety) {
-                return [this.nameForNamedType(enumType), "?"];
-            }
-            return this.nameForNamedType(enumType);
-        }, unionType => {
+        const nullable = this._options.nullSafety && t.isNullable && !this._options.requiredProperties;
+        const withNullable = (s) => (nullable ? [s, "?"] : s);
+        return (0, TypeUtils_1.matchType)(t, _anyType => (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.anyTypeIssueAnnotation, "dynamic"), _nullType => (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.nullTypeIssueAnnotation, "dynamic"), _boolType => withNullable("bool"), _integerType => withNullable("int"), _doubleType => withNullable("double"), _stringType => withNullable("String"), arrayType => withNullable(["List<", this.dartType(arrayType.items, withIssues), ">"]), classType => withNullable(this.nameForNamedType(classType)), mapType => withNullable(["Map<String, ", this.dartType(mapType.values, withIssues), ">"]), enumType => withNullable(this.nameForNamedType(enumType)), unionType => {
             const maybeNullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
             if (maybeNullable === null) {
                 return "dynamic";
             }
-            return this.dartType(maybeNullable, withIssues);
+            return withNullable(this.dartType(maybeNullable, withIssues));
         }, transformedStringType => {
             switch (transformedStringType.kind) {
                 case "date-time":
                 case "date":
-                    return this._options.nullSafety ? ["DateTime", "?"] : "DateTime";
+                    return withNullable("DateTime");
                 default:
-                    return this._options.nullSafety ? ["String", "?"] : "String";
+                    return withNullable("String");
             }
         });
     }
-    mapList(itemType, list, mapper) {
-        if (this._options.nullSafety) {
+    mapList(isNullable, itemType, list, mapper) {
+        if (this._options.nullSafety && isNullable && !this._options.requiredProperties) {
             return [list, " == null ? [] : ", "List<", itemType, ">.from(", list, "!.map((x) => ", mapper, "))"];
         }
         return ["List<", itemType, ">.from(", list, ".map((x) => ", mapper, "))"];
     }
-    mapMap(valueType, map, valueMapper) {
-        if (this._options.nullSafety) {
+    mapMap(isNullable, valueType, map, valueMapper) {
+        if (this._options.nullSafety && isNullable && !this._options.requiredProperties) {
             return ["Map.from(", map, "!).map((k, v) => MapEntry<String, ", valueType, ">(k, ", valueMapper, "))"];
         }
         return ["Map.from(", map, ").map((k, v) => MapEntry<String, ", valueType, ">(k, ", valueMapper, "))"];
     }
-    fromDynamicExpression(t, ...dynamic) {
+    mapClass(isNullable, classType, dynamic) {
+        if (this._options.nullSafety && isNullable && !this._options.requiredProperties) {
+            return [dynamic, " == null ? null : ", this.nameForNamedType(classType), ".", this.fromJson, "(", dynamic, ")"];
+        }
+        return [this.nameForNamedType(classType), ".", this.fromJson, "(", dynamic, ")"];
+    }
+    //If the first time is the unionType type, after nullableFromUnion conversion,
+    //the isNullable property will become false, which is obviously wrong,
+    //so add isNullable property
+    fromDynamicExpression(isNullable = false, t, ...dynamic) {
         return (0, TypeUtils_1.matchType)(t, _anyType => dynamic, _nullType => dynamic, // FIXME: check null
         // FIXME: check null
-        _boolType => dynamic, _integerType => dynamic, _doubleType => [dynamic, ".toDouble()"], _stringType => dynamic, arrayType => this.mapList(this.dartType(arrayType.items), dynamic, this.fromDynamicExpression(arrayType.items, "x")), classType => [this.nameForNamedType(classType), ".", this.fromJson, "(", dynamic, ")"], mapType => this.mapMap(this.dartType(mapType.values), dynamic, this.fromDynamicExpression(mapType.values, "v")), enumType => {
-            if (this._options.nullSafety) {
-                return [(0, Support_1.defined)(this._enumValues.get(enumType)), "!.map[", dynamic, "]"];
-            }
-            return [(0, Support_1.defined)(this._enumValues.get(enumType)), ".map[", dynamic, "]"];
+        _boolType => dynamic, _integerType => dynamic, _doubleType => [dynamic, this._options.nullSafety ? "?.toDouble()" : ".toDouble()"], _stringType => dynamic, arrayType => this.mapList(isNullable || arrayType.isNullable, this.dartType(arrayType.items), dynamic, this.fromDynamicExpression(arrayType.items.isNullable, arrayType.items, "x")), classType => this.mapClass(isNullable || classType.isNullable, classType, dynamic), mapType => this.mapMap(mapType.isNullable || isNullable, this.dartType(mapType.values), dynamic, this.fromDynamicExpression(mapType.values.isNullable, mapType.values, "v")), enumType => {
+            return [(0, Support_1.defined)(this._enumValues.get(enumType)), ".map[", dynamic, this._options.nullSafety ? "]!" : "]"];
         }, unionType => {
             const maybeNullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
             if (maybeNullable === null) {
                 return dynamic;
             }
-            if (maybeNullable.kind === "array") {
-                return [dynamic, " == null ? [] : ", this.fromDynamicExpression(maybeNullable, dynamic)];
-            }
-            return dynamic;
+            return this.fromDynamicExpression(unionType.isNullable, maybeNullable, dynamic);
         }, transformedStringType => {
             switch (transformedStringType.kind) {
                 case "date-time":
                 case "date":
+                    if ((transformedStringType.isNullable || isNullable) && !this._options.requiredProperties && this._options.nullSafety) {
+                        return [dynamic, " == null ? null : ", "DateTime.parse(", dynamic, ")"];
+                    }
                     return ["DateTime.parse(", dynamic, ")"];
                 default:
                     return dynamic;
             }
         });
     }
-    toDynamicExpression(t, ...dynamic) {
-        return (0, TypeUtils_1.matchType)(t, _anyType => dynamic, _nullType => dynamic, _boolType => dynamic, _integerType => dynamic, _doubleType => dynamic, _stringType => dynamic, arrayType => this.mapList("dynamic", dynamic, this.toDynamicExpression(arrayType.items, "x")), _classType => {
-            if (this._options.nullSafety) {
-                return [dynamic, "!.", this.toJson, "()"];
+    //If the first time is the unionType type, after nullableFromUnion conversion,
+    //the isNullable property will become false, which is obviously wrong,
+    //so add isNullable property
+    toDynamicExpression(isNullable = false, t, ...dynamic) {
+        return (0, TypeUtils_1.matchType)(t, _anyType => dynamic, _nullType => dynamic, _boolType => dynamic, _integerType => dynamic, _doubleType => dynamic, _stringType => dynamic, arrayType => this.mapList(arrayType.isNullable || isNullable, "dynamic", dynamic, this.toDynamicExpression(arrayType.items.isNullable, arrayType.items, "x")), _classType => {
+            if (this._options.nullSafety && (_classType.isNullable || isNullable) && !this._options.requiredProperties) {
+                return [dynamic, "?.", this.toJson, "()"];
             }
             return [dynamic, ".", this.toJson, "()"];
-        }, mapType => this.mapMap("dynamic", dynamic, this.toDynamicExpression(mapType.values, "v")), enumType => {
-            if (this._options.nullSafety) {
-                return [(0, Support_1.defined)(this._enumValues.get(enumType)), ".reverse![", dynamic, "]"];
-            }
+        }, mapType => this.mapMap(mapType.isNullable || isNullable, "dynamic", dynamic, this.toDynamicExpression(mapType.values.isNullable, mapType.values, "v")), enumType => {
             return [(0, Support_1.defined)(this._enumValues.get(enumType)), ".reverse[", dynamic, "]"];
         }, unionType => {
             const maybeNullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
             if (maybeNullable === null) {
                 return dynamic;
             }
-            if (maybeNullable.kind === "array") {
-                return [dynamic, " == null ? [] : ", this.toDynamicExpression(maybeNullable, dynamic)];
-            }
-            return dynamic;
+            return this.toDynamicExpression(unionType.isNullable, maybeNullable, dynamic);
         }, transformedStringType => {
             switch (transformedStringType.kind) {
                 case "date-time":
-                    if (this._options.nullSafety) {
+                    if (this._options.nullSafety && !this._options.requiredProperties && (transformedStringType.isNullable || isNullable)) {
                         return [dynamic, "?.toIso8601String()"];
                     }
                     return [dynamic, ".toIso8601String()"];
                 case "date":
-                    if (this._options.nullSafety) {
+                    if (this._options.nullSafety && !this._options.requiredProperties && (transformedStringType.isNullable || isNullable)) {
                         return [
-                            '"${',
+                            "\"${",
                             dynamic,
                             "!.year.toString().padLeft(4, '0')",
                             "}-${",
@@ -405,7 +369,7 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                         ];
                     }
                     return [
-                        '"${',
+                        "\"${",
                         dynamic,
                         ".year.toString().padLeft(4, '0')",
                         "}-${",
@@ -433,8 +397,9 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             else {
                 this.emitLine(className, "({");
                 this.indent(() => {
-                    this.forEachClassProperty(c, "none", (name, _, _p) => {
-                        this.emitLine(this._options.requiredProperties ? "required " : "", "this.", name, ",");
+                    this.forEachClassProperty(c, "none", (name, _, prop) => {
+                        const required = this._options.requiredProperties || (this._options.nullSafety && !prop.type.isNullable);
+                        this.emitLine(required ? "required " : "", "this.", name, ",");
                     });
                 });
                 this.emitLine("});");
@@ -482,7 +447,7 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("factory ", className, ".", this.fromJson, "(Map<String, dynamic> json) => ", className, "(");
             this.indent(() => {
                 this.forEachClassProperty(c, "none", (name, jsonName, property) => {
-                    this.emitLine(name, ": ", this.fromDynamicExpression(property.type, 'json["', stringEscape(jsonName), '"]'), ",");
+                    this.emitLine(name, ": ", this.fromDynamicExpression(property.type.isNullable, property.type, "json[\"", stringEscape(jsonName), "\"]"), ",");
                 });
             });
             this.emitLine(");");
@@ -490,7 +455,7 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("Map<String, dynamic> ", this.toJson, "() => {");
             this.indent(() => {
                 this.forEachClassProperty(c, "none", (name, jsonName, property) => {
-                    this.emitLine('"', stringEscape(jsonName), '": ', this.toDynamicExpression(property.type, name), ",");
+                    this.emitLine("\"", stringEscape(jsonName), "\": ", this.toDynamicExpression(property.type.isNullable, property.type, name), ",");
                 });
             });
             this.emitLine("};");
@@ -531,7 +496,7 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.indent(() => {
             this.forEachEnumCase(e, "none", (name, jsonName, pos) => {
                 const comma = pos === "first" || pos === "middle" ? "," : [];
-                this.emitLine('"', stringEscape(jsonName), '": ', enumName, ".", name, comma);
+                this.emitLine("\"", stringEscape(jsonName), "\": ", enumName, ".", name, comma);
             });
         });
         this.emitLine("});");
@@ -541,12 +506,12 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.ensureBlankLine();
         this.emitMultiline(`class EnumValues<T> {
     Map<String, T> map;
-    Map<T, String>? reverseMap;
+    late Map<T, String> reverseMap;
 
     EnumValues(this.map);
 
-    Map<T, String>? get reverse {
-        reverseMap ??= map.map((k, v) => MapEntry(v, k));
+    Map<T, String> get reverse {
+        reverseMap = map.map((k, v) => MapEntry(v, k));
         return reverseMap;
     }
 }`);
@@ -556,9 +521,9 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         if (!this._options.justTypes && !this._options.codersInClass) {
             this.forEachTopLevel("leading-and-interposing", (t, name) => {
                 const { encoder, decoder } = (0, Support_1.defined)(this._topLevelDependents.get(name));
-                this.emitLine(this.dartType(t), " ", decoder, "(String str) => ", this.fromDynamicExpression(t, "json.decode(str)"), ";");
+                this.emitLine(this.dartType(t), " ", decoder, "(String str) => ", this.fromDynamicExpression(t.isNullable, t, "json.decode(str)"), ";");
                 this.ensureBlankLine();
-                this.emitLine("String ", encoder, "(", this.dartType(t), " data) => json.encode(", this.toDynamicExpression(t, "data"), ");");
+                this.emitLine("String ", encoder, "(", this.dartType(t), " data) => json.encode(", this.toDynamicExpression(t.isNullable, t, "data"), ");");
                 // this.emitBlock(["String ", encoder, "(", this.dartType(t), " data)"], () => {
                 //     this.emitJsonEncoderBlock(t);
                 // });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "20.0.26",
+    "version": "21.0.0",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",