odin-jsonschema

emit.odin (18293B)

---

 package jschema
 
 import "core:strings"
 
 @(private)
 Kind :: enum u8 {
 	Any,     // no usable constraints -> json.Value
 	Boolean,
 	Integer,
 	Number,
 	Str,
 	Struct,
 	Enum,
 	Union,   // oneOf / anyOf
 	Array,
 	Map,     // object keyed by arbitrary strings
 	Multi,   // several simple types -> inline union
 }
 
 @(private)
 Visit_State :: enum u8 {
 	Unvisited,
 	On_Stack,
 	Done,
 }
 
 @(private)
 Member :: struct {
 	prop: u32,    // global index into Pool.props
 	name: string, // original JSON name
 	node: Node_Index,
 }
 
 @(private)
 Emitter :: struct {
 	pool:      ^Pool,
 	opts:      Options,
 	openapi:   bool,                 // OpenAPI-idiom lowering enabled
 	def_names: map[Node_Index]string, // raw def key per node
 	names:     []string,              // assigned declaration name per node
 	visit:     []Visit_State,
 	queued:    []bool,
 	queue:     [dynamic]Node_Index,
 	broken:    map[u32]bool,          // props that would form a by-value cycle
 	taken:     map[string]bool,
 	body:             strings.Builder,
 	uses_json:        bool,
 	uses_or_reference: bool,
 }
 
 // Follows chains of nodes that are nothing but a $ref.
 @(private)
 effective :: proc(e: ^Emitter, idx: Node_Index) -> Node_Index {
 	idx := idx
 	for _ in 0 ..< len(e.pool.nodes) {
 		node := &e.pool.nodes[idx]
 		if node.ref == NIL_NODE {
 			break
 		}
 		pure := node.props.count == 0 &&
 			node.all_of.count == 0 &&
 			node.any_of.count == 0 &&
 			node.one_of.count == 0 &&
 			node.enum_kind == .None &&
 			node.types == {} &&
 			node.items == NIL_NODE &&
 			node.additional == NIL_NODE
 		if !pure {
 			break
 		}
 		idx = node.ref
 	}
 	return idx
 }
 
 @(private)
 is_null_only :: proc(e: ^Emitter, idx: Node_Index) -> bool {
 	node := &e.pool.nodes[idx]
 	return node.types == {.Null} &&
 		node.props.count == 0 &&
 		node.all_of.count == 0 &&
 		node.any_of.count == 0 &&
 		node.one_of.count == 0 &&
 		node.enum_kind == .None
 }
 
 @(private)
 classify :: proc(e: ^Emitter, idx: Node_Index) -> Kind {
 	node := &e.pool.nodes[idx]
 	if node.props.count > 0 || node.all_of.count > 0 {
 		return .Struct
 	}
 	if node.enum_kind == .Strings {
 		all_idents := node.enum_values.count > 0
 		for value in enum_values(e, idx) {
 			if !is_valid_ident(value) {
 				all_idents = false
 				break
 			}
 		}
 		if all_idents {
 			return .Enum
 		}
 		return .Str
 	}
 	if node.one_of.count > 0 || node.any_of.count > 0 {
 		return .Union
 	}
 
 	types := node.types - {.Null}
 	switch card(types) {
 	case 0:
 		if node.additional != NIL_NODE || node.additional_bool != .Unset {
 			return .Map
 		}
 		if node.items != NIL_NODE {
 			return .Array
 		}
 		return .Any
 	case 1:
 		switch {
 		case .String in types:
 			return .Str
 		case .Integer in types:
 			return .Integer
 		case .Number in types:
 			return .Number
 		case .Boolean in types:
 			return .Boolean
 		case .Array in types:
 			return .Array
 		}
 		return .Map // .Object
 	}
 	return .Multi
 }
 
 @(private)
 enum_values :: proc(e: ^Emitter, idx: Node_Index) -> []string {
 	r := e.pool.nodes[idx].enum_values
 	return e.pool.strings[r.first:][:r.count]
 }
 
 @(private)
 is_reference_def :: proc(e: ^Emitter, idx: Node_Index) -> bool {
 	name, ok := e.def_names[idx]
 	return ok && name == "reference"
 }
 
 // A 2-variant union shaped like OpenAPI's "X-or-reference" idiom: one
 // branch resolves to the "reference" $def, the other to a concrete type.
 // Lowered to the generic Or_Reference($T) instead of a dedicated decl.
 // Only applies when the non-reference branch is itself a named decl
 // (struct/enum/union); inline-only kinds (map, array, etc.) cannot be a
 // polymorphic type argument and fall back to a dedicated union decl.
 @(private)
 is_or_reference :: proc(e: ^Emitter, idx: Node_Index) -> (ref: Node_Index, other: Node_Index, ok: bool) {
 	if !e.openapi {
 		return NIL_NODE, NIL_NODE, false
 	}
 	variants := union_variants(e, idx)
 	if len(variants) != 2 {
 		return NIL_NODE, NIL_NODE, false
 	}
 	a := effective(e, variants[0])
 	b := effective(e, variants[1])
 	a_ref := is_reference_def(e, a)
 	b_ref := is_reference_def(e, b)
 	if a_ref && !b_ref {
 		#partial switch classify(e, b) {
 		case .Struct, .Enum, .Union:
 			return a, b, true
 		}
 	}
 	if b_ref && !a_ref {
 		#partial switch classify(e, a) {
 		case .Struct, .Enum, .Union:
 			return b, a, true
 		}
 	}
 	return NIL_NODE, NIL_NODE, false
 }
 
 @(private)
 union_variants :: proc(e: ^Emitter, idx: Node_Index) -> []Node_Index {
 	node := &e.pool.nodes[idx]
 	r := node.one_of if node.one_of.count > 0 else node.any_of
 	return e.pool.children[r.first:][:r.count]
 }
 
 // Collects the struct members of a node, merging $ref targets and allOf
 // children depth-first. The first occurrence of a property name wins.
 @(private)
 collect_members :: proc(
 	e: ^Emitter,
 	idx: Node_Index,
 	members: ^[dynamic]Member,
 	required: ^map[string]bool,
 ) {
 	seen := make(map[Node_Index]bool, context.temp_allocator)
 	have := make(map[string]bool, context.temp_allocator)
 
 	gather :: proc(
 		e: ^Emitter,
 		idx: Node_Index,
 		members: ^[dynamic]Member,
 		required: ^map[string]bool,
 		seen: ^map[Node_Index]bool,
 		have: ^map[string]bool,
 	) {
 		if seen[idx] {
 			return
 		}
 		seen[idx] = true
 		node := e.pool.nodes[idx]
 		if node.ref != NIL_NODE {
 			gather(e, node.ref, members, required, seen, have)
 		}
 		for child in e.pool.children[node.all_of.first:][:node.all_of.count] {
 			gather(e, child, members, required, seen, have)
 		}
 		for name in e.pool.names[node.required.first:][:node.required.count] {
 			required[name] = true
 		}
 		for i in 0 ..< node.props.count {
 			prop_index := node.props.first + i
 			prop := e.pool.props[prop_index]
 			if have[prop.name] {
 				continue
 			}
 			have[prop.name] = true
 			append(members, Member{prop = prop_index, name = prop.name, node = prop.node})
 		}
 	}
 	gather(e, idx, members, required, &seen, &have)
 }
 
 // --- by-value cycle detection ------------------------------------------------
 //
 // Odin structs cannot contain themselves by value (including through Maybe or
 // a union), so any property whose type chain reaches a struct that is already
 // being laid out is emitted as json.Value instead.
 
 @(private)
 find_cycles :: proc(e: ^Emitter, idx: Node_Index) {
 	visit_indirect(e, idx)
 }
 
 // Follows a property's type by value; reports whether it hit a struct that is
 // currently on the layout stack.
 @(private)
 visit_value :: proc(e: ^Emitter, idx: Node_Index) -> (cycles: bool) {
 	target := effective(e, idx)
 	switch classify(e, target) {
 	case .Struct:
 		switch e.visit[target] {
 		case .On_Stack:
 			return true
 		case .Done:
 			return false
 		case .Unvisited:
 			visit_struct(e, target)
 		}
 	case .Union:
 		for variant in union_variants(e, target) {
 			if is_null_only(e, effective(e, variant)) {
 				continue
 			}
 			if visit_value(e, variant) {
 				return true
 			}
 		}
 	case .Multi, .Array:
 		items := e.pool.nodes[target].items
 		if items != NIL_NODE {
 			visit_indirect(e, items)
 		}
 		if classify(e, target) == .Multi && .Object in e.pool.nodes[target].types {
 			additional := e.pool.nodes[target].additional
 			if additional != NIL_NODE {
 				visit_indirect(e, additional)
 			}
 		}
 	case .Map:
 		additional := e.pool.nodes[target].additional
 		if additional != NIL_NODE {
 			visit_indirect(e, additional)
 		}
 	case .Any, .Boolean, .Integer, .Number, .Str, .Enum:
 	}
 	return false
 }
 
 // Crosses an indirection (slice or map), which breaks value containment.
 @(private)
 visit_indirect :: proc(e: ^Emitter, idx: Node_Index) {
 	target := effective(e, idx)
 	switch classify(e, target) {
 	case .Struct:
 		if e.visit[target] == .Unvisited {
 			visit_struct(e, target)
 		}
 	case .Union:
 		for variant in union_variants(e, target) {
 			visit_indirect(e, variant)
 		}
 	case .Multi, .Array:
 		items := e.pool.nodes[target].items
 		if items != NIL_NODE {
 			visit_indirect(e, items)
 		}
 		additional := e.pool.nodes[target].additional
 		if additional != NIL_NODE {
 			visit_indirect(e, additional)
 		}
 	case .Map:
 		additional := e.pool.nodes[target].additional
 		if additional != NIL_NODE {
 			visit_indirect(e, additional)
 		}
 	case .Any, .Boolean, .Integer, .Number, .Str, .Enum:
 	}
 }
 
 @(private)
 visit_struct :: proc(e: ^Emitter, idx: Node_Index) {
 	e.visit[idx] = .On_Stack
 	members := make([dynamic]Member, context.temp_allocator)
 	required := make(map[string]bool, context.temp_allocator)
 	collect_members(e, idx, &members, &required)
 	for member in members {
 		if visit_value(e, member.node) {
 			e.broken[member.prop] = true
 		}
 	}
 	e.visit[idx] = .Done
 }
 
 // --- naming ------------------------------------------------------------------
 
 @(private)
 unique_name :: proc(e: ^Emitter, base: string) -> string {
 	if !e.taken[base] {
 		e.taken[base] = true
 		return base
 	}
 	for n := 2; ; n += 1 {
 		candidate := strings.concatenate({base, "_", itoa(n)})
 		if !e.taken[candidate] {
 			e.taken[candidate] = true
 			return candidate
 		}
 	}
 }
 
 // Assigns (once) a declaration name to a node and queues it for emission.
 @(private)
 ensure_decl :: proc(e: ^Emitter, idx: Node_Index, hint: string) -> string {
 	if e.names[idx] != "" {
 		return e.names[idx]
 	}
 	base := hint
 	if def, is_def := e.def_names[idx]; is_def {
 		base = type_name(def)
 	}
 	name := unique_name(e, base)
 	e.names[idx] = name
 	if !e.queued[idx] {
 		e.queued[idx] = true
 		append(&e.queue, idx)
 	}
 	return name
 }
 
 // --- type expressions ----------------------------------------------------------
 
 // Produces the Odin type expression for a property or element schema.
 // union_like types (unions and json.Value) already encode absence as nil,
 // so they are never wrapped in Maybe.
 @(private)
 type_expr :: proc(e: ^Emitter, idx: Node_Index, hint: string) -> (expr: string, union_like: bool, nullable: bool) {
 	target := effective(e, idx)
 	node := &e.pool.nodes[target]
 	nullable = .Null in e.pool.nodes[idx].types || .Null in node.types
 
 	switch classify(e, target) {
 	case .Any:
 		e.uses_json = true
 		return "json.Value", true, nullable
 	case .Str:
 		return "string", false, nullable
 	case .Integer:
 		return "i64", false, nullable
 	case .Number:
 		return "f64", false, nullable
 	case .Boolean:
 		return "bool", false, nullable
 	case .Struct, .Enum:
 		return ensure_decl(e, target, hint), false, nullable
 	case .Union:
 		if ref, other, ok := is_or_reference(e, target); ok {
 			other_name := ensure_decl(e, other, hint)
 			ensure_decl(e, ref, "Reference")
 			e.uses_or_reference = true
 			return strings.concatenate({"Or_Reference(", other_name, ")"}), true, nullable
 		}
 		if _, is_def := e.def_names[target]; is_def || e.names[target] != "" {
 			return ensure_decl(e, target, hint), true, nullable
 		}
 		inline, inline_union_like, nullable_variant := union_expr(e, target, hint)
 		return inline, inline_union_like, nullable || nullable_variant
 	case .Multi:
 		return multi_expr(e, target, hint), true, nullable
 	case .Array:
 		item := "json.Value"
 		if node.items != NIL_NODE {
 			item, _, _ = type_expr(e, node.items, strings.concatenate({hint, "_Item"}))
 		} else {
 			e.uses_json = true
 		}
 		return strings.concatenate({"[]", item}), false, nullable
 	case .Map:
 		value := "json.Value"
 		if node.additional != NIL_NODE {
 			value, _, _ = type_expr(e, node.additional, strings.concatenate({hint, "_Value"}))
 		} else {
 			e.uses_json = true
 		}
 		return strings.concatenate({"map[string]", value}), false, nullable
 	}
 	e.uses_json = true
 	return "json.Value", true, nullable
 }
 
 @(private)
 union_expr :: proc(e: ^Emitter, idx: Node_Index, hint: string) -> (expr: string, union_like: bool, nullable: bool) {
 	parts := make([dynamic]string, context.temp_allocator)
 	sole_union_like := false
 	for variant, i in union_variants(e, idx) {
 		if is_null_only(e, effective(e, variant)) {
 			nullable = true
 			continue
 		}
 		variant_hint := strings.concatenate({hint, "_Variant_", itoa(i + 1)})
 		part, part_union_like, variant_nullable := type_expr(e, variant, variant_hint)
 		nullable |= variant_nullable
 		sole_union_like = part_union_like
 		append(&parts, part)
 	}
 	switch len(parts) {
 	case 0:
 		e.uses_json = true
 		return "json.Value", true, nullable
 	case 1:
 		return parts[0], sole_union_like, nullable
 	}
 	b: strings.Builder
 	strings.builder_init(&b)
 	strings.write_string(&b, "union {")
 	for part, i in parts {
 		if i > 0 {
 			strings.write_string(&b, ", ")
 		}
 		strings.write_string(&b, part)
 	}
 	strings.write_string(&b, "}")
 	return strings.to_string(b), true, nullable
 }
 
 // Emission order for multi-type schemas, so output is deterministic.
 @(private)
 MULTI_ORDER :: [?]Simple_Type{.String, .Integer, .Number, .Boolean, .Array, .Object}
 
 @(private)
 multi_expr :: proc(e: ^Emitter, idx: Node_Index, hint: string) -> string {
 	node := &e.pool.nodes[idx]
 	b: strings.Builder
 	strings.builder_init(&b)
 	strings.write_string(&b, "union {")
 	written := 0
 	for t in MULTI_ORDER {
 		if t not_in node.types {
 			continue
 		}
 		if written > 0 {
 			strings.write_string(&b, ", ")
 		}
 		switch t {
 		case .String:
 			strings.write_string(&b, "string")
 		case .Integer:
 			strings.write_string(&b, "i64")
 		case .Number:
 			strings.write_string(&b, "f64")
 		case .Boolean:
 			strings.write_string(&b, "bool")
 		case .Array:
 			item := "json.Value"
 			if node.items != NIL_NODE {
 				item, _, _ = type_expr(e, node.items, strings.concatenate({hint, "_Item"}))
 			} else {
 				e.uses_json = true
 			}
 			strings.write_string(&b, "[]")
 			strings.write_string(&b, item)
 		case .Object:
 			value := "json.Value"
 			if node.additional != NIL_NODE {
 				value, _, _ = type_expr(e, node.additional, strings.concatenate({hint, "_Value"}))
 			} else {
 				e.uses_json = true
 			}
 			strings.write_string(&b, "map[string]")
 			strings.write_string(&b, value)
 		case .Null:
 		}
 		written += 1
 	}
 	strings.write_string(&b, "}")
 	return strings.to_string(b)
 }
 
 // --- declarations ----------------------------------------------------------------
 
 @(private)
 emit_struct :: proc(e: ^Emitter, idx: Node_Index) {
 	name := e.names[idx]
 	members := make([dynamic]Member, context.temp_allocator)
 	required := make(map[string]bool, context.temp_allocator)
 	collect_members(e, idx, &members, &required)
 
 	b := &e.body
 	if len(members) == 0 {
 		strings.write_string(b, name)
 		strings.write_string(b, " :: struct {}")
 		return
 	}
 
 	strings.write_string(b, name)
 	strings.write_string(b, " :: struct {\n")
 	field_names := make(map[string]bool, context.temp_allocator)
 	for member in members {
 		fname := field_name(member.name)
 		if field_names[fname] {
 			fname = unique_field(fname, &field_names)
 		}
 		field_names[fname] = true
 
 		expr: string
 		union_like: bool
 		nullable: bool
 		if e.broken[member.prop] {
 			e.uses_json = true
 			expr, union_like = "json.Value", true
 		} else {
 			hint := strings.concatenate({name, "_", type_name(member.name)})
 			expr, union_like, nullable = type_expr(e, member.node, hint)
 		}
 
 		optional := !required[member.name]
 		strings.write_string(b, "\t")
 		strings.write_string(b, fname)
 		strings.write_string(b, ": ")
 		if !union_like && (optional || nullable) {
 			strings.write_string(b, "Maybe(")
 			strings.write_string(b, expr)
 			strings.write_string(b, ")")
 		} else {
 			strings.write_string(b, expr)
 		}
 		strings.write_string(b, " `json:\"")
 		strings.write_string(b, member.name)
 		strings.write_string(b, "\"`,\n")
 	}
 	strings.write_string(b, "}")
 }
 
 @(private)
 unique_field :: proc(base: string, taken: ^map[string]bool) -> string {
 	for n := 2; ; n += 1 {
 		candidate := strings.concatenate({base, "_", itoa(n)})
 		if !taken[candidate] {
 			return candidate
 		}
 	}
 }
 
 @(private)
 emit_enum :: proc(e: ^Emitter, idx: Node_Index) {
 	b := &e.body
 	strings.write_string(b, e.names[idx])
 	strings.write_string(b, " :: enum {\n")
 	for value in enum_values(e, idx) {
 		strings.write_string(b, "\t")
 		strings.write_string(b, value)
 		strings.write_string(b, ",\n")
 	}
 	strings.write_string(b, "}")
 }
 
 @(private)
 emit_union :: proc(e: ^Emitter, idx: Node_Index) {
 	name := e.names[idx]
 	b := &e.body
 	if ref, other, ok := is_or_reference(e, idx); ok {
 		other_name := ensure_decl(e, other, name)
 		ensure_decl(e, ref, "Reference")
 		e.uses_or_reference = true
 		strings.write_string(b, name)
 		strings.write_string(b, " :: Or_Reference(")
 		strings.write_string(b, other_name)
 		strings.write_string(b, ")")
 		return
 	}
 	expr, _, _ := union_expr(e, idx, name)
 	strings.write_string(b, name)
 	strings.write_string(b, " :: ")
 	strings.write_string(b, expr)
 }
 
 // Emits the full Odin source for a resolved pool.
 @(private)
 emit :: proc(pool: ^Pool, opts: Options, openapi: bool) -> string {
 	e := Emitter {
 		pool    = pool,
 		opts    = opts,
 		openapi = openapi,
 		names   = make([]string, len(pool.nodes)),
 		visit   = make([]Visit_State, len(pool.nodes)),
 		queued  = make([]bool, len(pool.nodes)),
 	}
 	strings.builder_init(&e.body)
 
 	for def in pool.defs {
 		if _, exists := e.def_names[def.node]; !exists {
 			e.def_names[def.node] = def.name
 		}
 	}
 
 	root := effective(&e, pool.root)
 	find_cycles(&e, root)
 
 	root_name := opts.root_name if opts.root_name != "" else "Root"
 	switch classify(&e, root) {
 	case .Struct, .Enum, .Union:
 		ensure_decl(&e, root, root_name)
 	case .Any, .Boolean, .Integer, .Number, .Str, .Array, .Map, .Multi:
 		// Root is an alias-style declaration.
 		expr, _, _ := type_expr(&e, root, root_name)
 		name := unique_name(&e, root_name)
 		strings.write_string(&e.body, name)
 		strings.write_string(&e.body, " :: ")
 		strings.write_string(&e.body, expr)
 	}
 
 	for i := 0; i < len(e.queue); i += 1 {
 		if strings.builder_len(e.body) > 0 {
 			strings.write_string(&e.body, "\n\n")
 		}
 		idx := e.queue[i]
 		switch classify(&e, idx) {
 		case .Struct:
 			emit_struct(&e, idx)
 		case .Enum:
 			emit_enum(&e, idx)
 		case .Union:
 			emit_union(&e, idx)
 		case .Any, .Boolean, .Integer, .Number, .Str, .Array, .Map, .Multi:
 		}
 	}
 
 	package_name := opts.package_name if opts.package_name != "" else "schema"
 	out: strings.Builder
 	strings.builder_init(&out)
 	strings.write_string(&out, "// Code generated by jschema. DO NOT EDIT.\npackage ")
 	strings.write_string(&out, package_name)
 	strings.write_string(&out, "\n\n")
 	if e.uses_json {
 		strings.write_string(&out, "import \"core:encoding/json\"\n\n")
 	}
 	if e.uses_or_reference {
 		strings.write_string(&out, "Or_Reference :: union($T: typeid) {Reference, T}\n\n")
 	}
 	strings.write_string(&out, strings.to_string(e.body))
 	strings.write_string(&out, "\n")
 	return strings.to_string(out)
 }