Merge branch 'odin-lang:master' into fix-omitempty-comma

4 files changed, 116 insertions, 113 deletions

diff --git a/core/encoding/cbor/cbor.odin b/core/encoding/cbor/cbor.odin
index d0e406ab1..7897b2a37 100644
--- a/core/encoding/cbor/cbor.odin
+++ b/core/encoding/cbor/cbor.odin
@@ -320,8 +320,8 @@ to_diagnostic_format :: proc {
 
 // Turns the given CBOR value into a human-readable string.
 // See docs on the proc group `diagnose` for more info.
-to_diagnostic_format_string :: proc(val: Value, padding := 0, allocator := context.allocator) -> (string, mem.Allocator_Error) #optional_allocator_error {
-	b := strings.builder_make(allocator)
+to_diagnostic_format_string :: proc(val: Value, padding := 0, allocator := context.allocator, loc := #caller_location) -> (string, mem.Allocator_Error) #optional_allocator_error {
+	b := strings.builder_make(allocator, loc)
 	w := strings.to_stream(&b)
 	err := to_diagnostic_format_writer(w, val, padding)
 	if err == .EOF {
diff --git a/core/encoding/cbor/coding.odin b/core/encoding/cbor/coding.odin
index 0d276a7a1..07f0637a6 100644
--- a/core/encoding/cbor/coding.odin
+++ b/core/encoding/cbor/coding.odin
@@ -95,24 +95,25 @@ decode :: decode_from
 
 // Decodes the given string as CBOR.
 // See docs on the proc group `decode` for more information.
-decode_from_string :: proc(s: string, flags: Decoder_Flags = {}, allocator := context.allocator) -> (v: Value, err: Decode_Error) {
+decode_from_string :: proc(s: string, flags: Decoder_Flags = {}, allocator := context.allocator, loc := #caller_location) -> (v: Value, err: Decode_Error) {
 	r: strings.Reader
 	strings.reader_init(&r, s)
-	return decode_from_reader(strings.reader_to_stream(&r), flags, allocator)
+	return decode_from_reader(strings.reader_to_stream(&r), flags, allocator, loc)
 }
 
 // Reads a CBOR value from the given reader.
 // See docs on the proc group `decode` for more information.
-decode_from_reader :: proc(r: io.Reader, flags: Decoder_Flags = {}, allocator := context.allocator) -> (v: Value, err: Decode_Error) {
+decode_from_reader :: proc(r: io.Reader, flags: Decoder_Flags = {}, allocator := context.allocator, loc := #caller_location) -> (v: Value, err: Decode_Error) {
 	return decode_from_decoder(
 		Decoder{ DEFAULT_MAX_PRE_ALLOC, flags, r },
 		allocator=allocator,
+		loc = loc,
 	)
 }
 
 // Reads a CBOR value from the given decoder.
 // See docs on the proc group `decode` for more information.
-decode_from_decoder :: proc(d: Decoder, allocator := context.allocator) -> (v: Value, err: Decode_Error) {
+decode_from_decoder :: proc(d: Decoder, allocator := context.allocator, loc := #caller_location) -> (v: Value, err: Decode_Error) {
 	context.allocator = allocator
 	
 	d := d
@@ -121,13 +122,13 @@ decode_from_decoder :: proc(d: Decoder, allocator := context.allocator) -> (v: V
 		d.max_pre_alloc = DEFAULT_MAX_PRE_ALLOC
 	}
 
-	v, err = _decode_from_decoder(d)
+	v, err = _decode_from_decoder(d, {}, allocator, loc)
 	// Normal EOF does not exist here, we try to read the exact amount that is said to be provided.
 	if err == .EOF { err = .Unexpected_EOF }
 	return
 }
 
-_decode_from_decoder :: proc(d: Decoder, hdr: Header = Header(0)) -> (v: Value, err: Decode_Error) {
+_decode_from_decoder :: proc(d: Decoder, hdr: Header = Header(0), allocator := context.allocator, loc := #caller_location) -> (v: Value, err: Decode_Error) {
 	hdr := hdr
 	r := d.reader
 	if hdr == Header(0) { hdr = _decode_header(r) or_return }
@@ -161,11 +162,11 @@ _decode_from_decoder :: proc(d: Decoder, hdr: Header = Header(0)) -> (v: Value,
 	switch maj {
 	case .Unsigned: return _decode_tiny_u8(add)
 	case .Negative: return Negative_U8(_decode_tiny_u8(add) or_return), nil
-	case .Bytes:    return _decode_bytes_ptr(d, add)
-	case .Text:     return _decode_text_ptr(d, add)
-	case .Array:    return _decode_array_ptr(d, add)
-	case .Map:      return _decode_map_ptr(d, add)
-	case .Tag:      return _decode_tag_ptr(d, add)
+	case .Bytes:    return _decode_bytes_ptr(d, add, .Bytes, allocator, loc)
+	case .Text:     return _decode_text_ptr(d, add, allocator, loc)
+	case .Array:    return _decode_array_ptr(d, add, allocator, loc)
+	case .Map:      return _decode_map_ptr(d, add, allocator, loc)
+	case .Tag:      return _decode_tag_ptr(d, add, allocator, loc)
 	case .Other:    return _decode_tiny_simple(add)
 	case:           return nil, .Bad_Major
 	}
@@ -203,27 +204,27 @@ encode :: encode_into
 
 // Encodes the CBOR value into binary CBOR allocated on the given allocator.
 // See the docs on the proc group `encode_into` for more info.
-encode_into_bytes :: proc(v: Value, flags := ENCODE_SMALL, allocator := context.allocator, temp_allocator := context.temp_allocator) -> (data: []byte, err: Encode_Error) {
-	b := strings.builder_make(allocator) or_return
+encode_into_bytes :: proc(v: Value, flags := ENCODE_SMALL, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> (data: []byte, err: Encode_Error) {
+	b := strings.builder_make(allocator, loc) or_return
 	encode_into_builder(&b, v, flags, temp_allocator) or_return
 	return b.buf[:], nil
 }
 
 // Encodes the CBOR value into binary CBOR written to the given builder.
 // See the docs on the proc group `encode_into` for more info.
-encode_into_builder :: proc(b: ^strings.Builder, v: Value, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator) -> Encode_Error {
-	return encode_into_writer(strings.to_stream(b), v, flags, temp_allocator)
+encode_into_builder :: proc(b: ^strings.Builder, v: Value, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator, loc := #caller_location) -> Encode_Error {
+	return encode_into_writer(strings.to_stream(b), v, flags, temp_allocator, loc=loc)
 }
 
 // Encodes the CBOR value into binary CBOR written to the given writer.
 // See the docs on the proc group `encode_into` for more info.
-encode_into_writer :: proc(w: io.Writer, v: Value, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator) -> Encode_Error {
-	return encode_into_encoder(Encoder{flags, w, temp_allocator}, v)
+encode_into_writer :: proc(w: io.Writer, v: Value, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator, loc := #caller_location) -> Encode_Error {
+	return encode_into_encoder(Encoder{flags, w, temp_allocator}, v, loc=loc)
 }
 
 // Encodes the CBOR value into binary CBOR written to the given encoder.
 // See the docs on the proc group `encode_into` for more info.
-encode_into_encoder :: proc(e: Encoder, v: Value) -> Encode_Error {
+encode_into_encoder :: proc(e: Encoder, v: Value, loc := #caller_location) -> Encode_Error {
 	e := e
 
 	if e.temp_allocator.procedure == nil {
@@ -366,21 +367,21 @@ _encode_u64_exact :: proc(w: io.Writer, v: u64, major: Major = .Unsigned) -> (er
 	return
 }
 
-_decode_bytes_ptr :: proc(d: Decoder, add: Add, type: Major = .Bytes) -> (v: ^Bytes, err: Decode_Error) {
-	v = new(Bytes) or_return
-	defer if err != nil { free(v) }
+_decode_bytes_ptr :: proc(d: Decoder, add: Add, type: Major = .Bytes, allocator := context.allocator, loc := #caller_location) -> (v: ^Bytes, err: Decode_Error) {
+	v = new(Bytes, allocator, loc) or_return
+	defer if err != nil { free(v, allocator, loc) }
 
-	v^ = _decode_bytes(d, add, type) or_return
+	v^ = _decode_bytes(d, add, type, allocator, loc) or_return
 	return
 }
 
-_decode_bytes :: proc(d: Decoder, add: Add, type: Major = .Bytes, allocator := context.allocator) -> (v: Bytes, err: Decode_Error) {
+_decode_bytes :: proc(d: Decoder, add: Add, type: Major = .Bytes, allocator := context.allocator, loc := #caller_location) -> (v: Bytes, err: Decode_Error) {
 	context.allocator = allocator
 
 	add := add
 	n, scap := _decode_len_str(d, add) or_return
 	
-	buf := strings.builder_make(0, scap) or_return
+	buf := strings.builder_make(0, scap, allocator, loc) or_return
 	defer if err != nil { strings.builder_destroy(&buf) }
 	buf_stream := strings.to_stream(&buf)
 
@@ -426,40 +427,40 @@ _encode_bytes :: proc(e: Encoder, val: Bytes, major: Major = .Bytes) -> (err: En
 	return
 }
 
-_decode_text_ptr :: proc(d: Decoder, add: Add) -> (v: ^Text, err: Decode_Error) {
-	v = new(Text) or_return
+_decode_text_ptr :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: ^Text, err: Decode_Error) {
+	v = new(Text, allocator, loc) or_return
 	defer if err != nil { free(v) }
 
-	v^ = _decode_text(d, add) or_return
+	v^ = _decode_text(d, add, allocator, loc) or_return
 	return
 }
 
-_decode_text :: proc(d: Decoder, add: Add, allocator := context.allocator) -> (v: Text, err: Decode_Error) {
-	return (Text)(_decode_bytes(d, add, .Text, allocator) or_return), nil
+_decode_text :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: Text, err: Decode_Error) {
+	return (Text)(_decode_bytes(d, add, .Text, allocator, loc) or_return), nil
 }
 
 _encode_text :: proc(e: Encoder, val: Text) -> Encode_Error {
     return _encode_bytes(e, transmute([]byte)val, .Text)
 }
 
-_decode_array_ptr :: proc(d: Decoder, add: Add) -> (v: ^Array, err: Decode_Error) {
-	v = new(Array) or_return
+_decode_array_ptr :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: ^Array, err: Decode_Error) {
+	v = new(Array, allocator, loc) or_return
 	defer if err != nil { free(v) }
 
-	v^ = _decode_array(d, add) or_return
+	v^ = _decode_array(d, add, allocator, loc) or_return
 	return
 }
 
-_decode_array :: proc(d: Decoder, add: Add) -> (v: Array, err: Decode_Error) {
+_decode_array :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: Array, err: Decode_Error) {
 	n, scap := _decode_len_container(d, add) or_return
-	array := make([dynamic]Value, 0, scap) or_return
+	array := make([dynamic]Value, 0, scap, allocator, loc) or_return
 	defer if err != nil {
-		for entry in array { destroy(entry) }
-		delete(array)
+		for entry in array { destroy(entry, allocator) }
+		delete(array, loc)
 	}
 	
 	for i := 0; n == -1 || i < n; i += 1 {
-		val, verr := _decode_from_decoder(d)
+		val, verr := _decode_from_decoder(d, {}, allocator, loc)
 		if n == -1 && verr == .Break {
 			break
 		} else if verr != nil {
@@ -485,39 +486,39 @@ _encode_array :: proc(e: Encoder, arr: Array) -> Encode_Error {
     return nil
 }
 
-_decode_map_ptr :: proc(d: Decoder, add: Add) -> (v: ^Map, err: Decode_Error) {
-	v = new(Map) or_return
+_decode_map_ptr :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: ^Map, err: Decode_Error) {
+	v = new(Map, allocator, loc) or_return
 	defer if err != nil { free(v) }
 
-	v^ = _decode_map(d, add) or_return
+	v^ = _decode_map(d, add, allocator, loc) or_return
 	return
 }
 
-_decode_map :: proc(d: Decoder, add: Add) -> (v: Map, err: Decode_Error) {
+_decode_map :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: Map, err: Decode_Error) {
 	n, scap := _decode_len_container(d, add) or_return
-	items := make([dynamic]Map_Entry, 0, scap) or_return
+	items := make([dynamic]Map_Entry, 0, scap, allocator, loc) or_return
 	defer if err != nil { 
 		for entry in items {
 			destroy(entry.key)
 			destroy(entry.value)
 		}
-		delete(items)
+		delete(items, loc)
 	}
 
 	for i := 0; n == -1 || i < n; i += 1 {
-		key, kerr := _decode_from_decoder(d)
+		key, kerr := _decode_from_decoder(d, {}, allocator, loc)
 		if n == -1 && kerr == .Break {
 			break
 		} else if kerr != nil {
 			return nil, kerr
 		} 
 
-		value := _decode_from_decoder(d) or_return
+		value := _decode_from_decoder(d, {}, allocator, loc) or_return
 
 		append(&items, Map_Entry{
 			key   = key,
 			value = value,
-		}) or_return
+		}, loc) or_return
 	}
 
 	if .Shrink_Excess in d.flags { shrink(&items) }
@@ -578,20 +579,20 @@ _encode_map :: proc(e: Encoder, m: Map) -> (err: Encode_Error) {
     return nil
 }
 
-_decode_tag_ptr :: proc(d: Decoder, add: Add) -> (v: Value, err: Decode_Error) {
-	tag := _decode_tag(d, add) or_return
+_decode_tag_ptr :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: Value, err: Decode_Error) {
+	tag := _decode_tag(d, add, allocator, loc) or_return
 	if t, ok := tag.?; ok {
 		defer if err != nil { destroy(t.value) }
-		tp := new(Tag) or_return
+		tp := new(Tag, allocator, loc) or_return
 		tp^ = t
 		return tp, nil
 	}
 
 	// no error, no tag, this was the self described CBOR tag, skip it.
-	return _decode_from_decoder(d)
+	return _decode_from_decoder(d, {}, allocator, loc)
 }
 
-_decode_tag :: proc(d: Decoder, add: Add) -> (v: Maybe(Tag), err: Decode_Error) {
+_decode_tag :: proc(d: Decoder, add: Add, allocator := context.allocator, loc := #caller_location) -> (v: Maybe(Tag), err: Decode_Error) {
 	num := _decode_uint_as_u64(d.reader, add) or_return
 
 	// CBOR can be wrapped in a tag that decoders can use to see/check if the binary data is CBOR.
@@ -602,7 +603,7 @@ _decode_tag :: proc(d: Decoder, add: Add) -> (v: Maybe(Tag), err: Decode_Error)
 
 	t := Tag{
 		number = num,
-		value = _decode_from_decoder(d) or_return,
+		value = _decode_from_decoder(d, {}, allocator, loc) or_return,
 	}
 
 	if nested, ok := t.value.(^Tag); ok {
@@ -883,4 +884,4 @@ _encode_deterministic_f64 :: proc(w: io.Writer, v: f64) -> io.Error {
 	}
 
 	return _encode_f64_exact(w, v)
-}
+}
\ No newline at end of file
diff --git a/core/encoding/cbor/marshal.odin b/core/encoding/cbor/marshal.odin
index 37c9dd180..775eafd9c 100644
--- a/core/encoding/cbor/marshal.odin
+++ b/core/encoding/cbor/marshal.odin
@@ -45,8 +45,8 @@ marshal :: marshal_into
 
 // Marshals the given value into a CBOR byte stream (allocated using the given allocator).
 // See docs on the `marshal_into` proc group for more info.
-marshal_into_bytes :: proc(v: any, flags := ENCODE_SMALL, allocator := context.allocator, temp_allocator := context.temp_allocator) -> (bytes: []byte, err: Marshal_Error) {
-	b, alloc_err := strings.builder_make(allocator)
+marshal_into_bytes :: proc(v: any, flags := ENCODE_SMALL, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> (bytes: []byte, err: Marshal_Error) {
+	b, alloc_err := strings.builder_make(allocator, loc=loc)
  	// The builder as a stream also returns .EOF if it ran out of memory so this is consistent.
 	if alloc_err != nil {
 		return nil, .EOF
@@ -54,7 +54,7 @@ marshal_into_bytes :: proc(v: any, flags := ENCODE_SMALL, allocator := context.a
 
 	defer if err != nil { strings.builder_destroy(&b) }
 
-	if err = marshal_into_builder(&b, v, flags, temp_allocator); err != nil {
+	if err = marshal_into_builder(&b, v, flags, temp_allocator, loc=loc); err != nil {
 		return
 	}
 
@@ -63,20 +63,20 @@ marshal_into_bytes :: proc(v: any, flags := ENCODE_SMALL, allocator := context.a
 
 // Marshals the given value into a CBOR byte stream written to the given builder.
 // See docs on the `marshal_into` proc group for more info.
-marshal_into_builder :: proc(b: ^strings.Builder, v: any, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator) -> Marshal_Error {
-	return marshal_into_writer(strings.to_writer(b), v, flags, temp_allocator)
+marshal_into_builder :: proc(b: ^strings.Builder, v: any, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator, loc := #caller_location) -> Marshal_Error {
+	return marshal_into_writer(strings.to_writer(b), v, flags, temp_allocator, loc=loc)
 }
 
 // Marshals the given value into a CBOR byte stream written to the given writer.
 // See docs on the `marshal_into` proc group for more info.
-marshal_into_writer :: proc(w: io.Writer, v: any, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator) -> Marshal_Error {
+marshal_into_writer :: proc(w: io.Writer, v: any, flags := ENCODE_SMALL, temp_allocator := context.temp_allocator, loc := #caller_location) -> Marshal_Error {
 	encoder := Encoder{flags, w, temp_allocator}
-	return marshal_into_encoder(encoder, v)
+	return marshal_into_encoder(encoder, v, loc=loc)
 }
 
 // Marshals the given value into a CBOR byte stream written to the given encoder.
 // See docs on the `marshal_into` proc group for more info.
-marshal_into_encoder :: proc(e: Encoder, v: any) -> (err: Marshal_Error) {
+marshal_into_encoder :: proc(e: Encoder, v: any, loc :=  #caller_location) -> (err: Marshal_Error) {
 	e := e
 
 	if e.temp_allocator.procedure == nil {
diff --git a/core/encoding/cbor/unmarshal.odin b/core/encoding/cbor/unmarshal.odin
index a1524d9f4..c31ba1d92 100644
--- a/core/encoding/cbor/unmarshal.odin
+++ b/core/encoding/cbor/unmarshal.odin
@@ -31,8 +31,8 @@ unmarshal :: proc {
 	unmarshal_from_string,
 }
 
-unmarshal_from_reader :: proc(r: io.Reader, ptr: ^$T, flags := Decoder_Flags{}, allocator := context.allocator, temp_allocator := context.temp_allocator) -> (err: Unmarshal_Error) {
-	err = unmarshal_from_decoder(Decoder{ DEFAULT_MAX_PRE_ALLOC, flags, r }, ptr, allocator, temp_allocator)
+unmarshal_from_reader :: proc(r: io.Reader, ptr: ^$T, flags := Decoder_Flags{}, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
+	err = unmarshal_from_decoder(Decoder{ DEFAULT_MAX_PRE_ALLOC, flags, r }, ptr, allocator, temp_allocator, loc)
 
 	// Normal EOF does not exist here, we try to read the exact amount that is said to be provided.
 	if err == .EOF { err = .Unexpected_EOF }
@@ -40,21 +40,21 @@ unmarshal_from_reader :: proc(r: io.Reader, ptr: ^$T, flags := Decoder_Flags{},
 }
 
 // Unmarshals from a string, see docs on the proc group `Unmarshal` for more info.
-unmarshal_from_string :: proc(s: string, ptr: ^$T, flags := Decoder_Flags{}, allocator := context.allocator, temp_allocator := context.temp_allocator) -> (err: Unmarshal_Error) {
+unmarshal_from_string :: proc(s: string, ptr: ^$T, flags := Decoder_Flags{}, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
 	sr: strings.Reader
 	r := strings.to_reader(&sr, s)
 
-	err = unmarshal_from_reader(r, ptr, flags, allocator, temp_allocator)
+	err = unmarshal_from_reader(r, ptr, flags, allocator, temp_allocator, loc)
 
 	// Normal EOF does not exist here, we try to read the exact amount that is said to be provided.
 	if err == .EOF { err = .Unexpected_EOF }
 	return
 }
 
-unmarshal_from_decoder :: proc(d: Decoder, ptr: ^$T, allocator := context.allocator, temp_allocator := context.temp_allocator) -> (err: Unmarshal_Error) {
+unmarshal_from_decoder :: proc(d: Decoder, ptr: ^$T, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
 	d := d
 
-	err = _unmarshal_any_ptr(d, ptr, nil, allocator, temp_allocator)
+	err = _unmarshal_any_ptr(d, ptr, nil, allocator, temp_allocator, loc)
 
 	// Normal EOF does not exist here, we try to read the exact amount that is said to be provided.
 	if err == .EOF { err = .Unexpected_EOF }
@@ -62,7 +62,7 @@ unmarshal_from_decoder :: proc(d: Decoder, ptr: ^$T, allocator := context.alloca
 
 }
 
-_unmarshal_any_ptr :: proc(d: Decoder, v: any, hdr: Maybe(Header) = nil, allocator := context.allocator, temp_allocator := context.temp_allocator) -> Unmarshal_Error {
+_unmarshal_any_ptr :: proc(d: Decoder, v: any, hdr: Maybe(Header) = nil, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> Unmarshal_Error {
 	context.allocator = allocator
 	context.temp_allocator = temp_allocator
 	v := v
@@ -78,10 +78,10 @@ _unmarshal_any_ptr :: proc(d: Decoder, v: any, hdr: Maybe(Header) = nil, allocat
 	}
 	
 	data := any{(^rawptr)(v.data)^, ti.variant.(reflect.Type_Info_Pointer).elem.id}	
-	return _unmarshal_value(d, data, hdr.? or_else (_decode_header(d.reader) or_return))
+	return _unmarshal_value(d, data, hdr.? or_else (_decode_header(d.reader) or_return), allocator, temp_allocator, loc)
 }
 
-_unmarshal_value :: proc(d: Decoder, v: any, hdr: Header) -> (err: Unmarshal_Error) {
+_unmarshal_value :: proc(d: Decoder, v: any, hdr: Header, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
 	v := v
 	ti := reflect.type_info_base(type_info_of(v.id))
 	r := d.reader
@@ -104,7 +104,7 @@ _unmarshal_value :: proc(d: Decoder, v: any, hdr: Header) -> (err: Unmarshal_Err
 	// Allow generic unmarshal by doing it into a `Value`.
 	switch &dst in v {
 	case Value:
-		dst = err_conv(_decode_from_decoder(d, hdr)) or_return
+		dst = err_conv(_decode_from_decoder(d, hdr, allocator, loc)) or_return
 		return
 	}
 
@@ -308,7 +308,7 @@ _unmarshal_value :: proc(d: Decoder, v: any, hdr: Header) -> (err: Unmarshal_Err
 		if impl, ok := _tag_implementations_nr[nr]; ok {
 			return impl->unmarshal(d, nr, v)
 		} else if nr == TAG_OBJECT_TYPE {
-			return _unmarshal_union(d, v, ti, hdr)
+			return _unmarshal_union(d, v, ti, hdr, loc=loc)
 		} else {
 			// Discard the tag info and unmarshal as its value.
 			return _unmarshal_value(d, v, _decode_header(r) or_return)
@@ -316,19 +316,19 @@ _unmarshal_value :: proc(d: Decoder, v: any, hdr: Header) -> (err: Unmarshal_Err
 
 		return _unsupported(v, hdr, add)
 
-	case .Bytes: return _unmarshal_bytes(d, v, ti, hdr, add)
-	case .Text:  return _unmarshal_string(d, v, ti, hdr, add)
-	case .Array: return _unmarshal_array(d, v, ti, hdr, add)
-	case .Map:   return _unmarshal_map(d, v, ti, hdr, add)
+	case .Bytes: return _unmarshal_bytes(d, v, ti, hdr, add, allocator=allocator, loc=loc)
+	case .Text:  return _unmarshal_string(d, v, ti, hdr, add, allocator=allocator, loc=loc)
+	case .Array: return _unmarshal_array(d, v, ti, hdr, add, allocator=allocator, loc=loc)
+	case .Map:   return _unmarshal_map(d, v, ti, hdr, add, allocator=allocator, loc=loc)
 
 	case:        return .Bad_Major
 	}
 }
 
-_unmarshal_bytes :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add) -> (err: Unmarshal_Error) {
+_unmarshal_bytes :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add, allocator := context.allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
 	#partial switch t in ti.variant {
 	case reflect.Type_Info_String:
-		bytes := err_conv(_decode_bytes(d, add)) or_return
+		bytes := err_conv(_decode_bytes(d, add, allocator=allocator, loc=loc)) or_return
 
 		if t.is_cstring {
 			raw  := (^cstring)(v.data)
@@ -347,7 +347,7 @@ _unmarshal_bytes :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 
 		if elem_base.id != byte { return _unsupported(v, hdr) }
 
-		bytes := err_conv(_decode_bytes(d, add)) or_return
+		bytes := err_conv(_decode_bytes(d, add, allocator=allocator, loc=loc)) or_return
 		raw   := (^mem.Raw_Slice)(v.data)
 		raw^   = transmute(mem.Raw_Slice)bytes
 		return
@@ -357,12 +357,12 @@ _unmarshal_bytes :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 
 		if elem_base.id != byte { return _unsupported(v, hdr) }
 		
-		bytes         := err_conv(_decode_bytes(d, add)) or_return
+		bytes         := err_conv(_decode_bytes(d, add, allocator=allocator, loc=loc)) or_return
 		raw           := (^mem.Raw_Dynamic_Array)(v.data)
 		raw.data       = raw_data(bytes)
 		raw.len        = len(bytes)
 		raw.cap        = len(bytes)
-		raw.allocator  = context.allocator
+		raw.allocator  = allocator
 		return
 
 	case reflect.Type_Info_Array:
@@ -385,10 +385,10 @@ _unmarshal_bytes :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 	return _unsupported(v, hdr)
 }
 
-_unmarshal_string :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add) -> (err: Unmarshal_Error) {
+_unmarshal_string :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add, allocator := context.allocator, temp_allocator := context.temp_allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
 	#partial switch t in ti.variant {
 	case reflect.Type_Info_String:
-		text := err_conv(_decode_text(d, add)) or_return
+		text := err_conv(_decode_text(d, add, allocator, loc)) or_return
 
 		if t.is_cstring {
 			raw := (^cstring)(v.data)
@@ -403,8 +403,8 @@ _unmarshal_string :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Heade
 
 	// Enum by its variant name.
 	case reflect.Type_Info_Enum:
-		text := err_conv(_decode_text(d, add, allocator=context.temp_allocator)) or_return
-		defer delete(text, context.temp_allocator)
+		text := err_conv(_decode_text(d, add, allocator=temp_allocator, loc=loc)) or_return
+		defer delete(text, temp_allocator, loc)
 
 		for name, i in t.names {
 			if name == text {
@@ -414,8 +414,8 @@ _unmarshal_string :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Heade
 		}
 	
 	case reflect.Type_Info_Rune:
-		text := err_conv(_decode_text(d, add, allocator=context.temp_allocator)) or_return
-		defer delete(text, context.temp_allocator)
+		text := err_conv(_decode_text(d, add, allocator=temp_allocator, loc=loc)) or_return
+		defer delete(text, temp_allocator, loc)
 
 		r := (^rune)(v.data)
 		dr, n := utf8.decode_rune(text)
@@ -430,13 +430,15 @@ _unmarshal_string :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Heade
 	return _unsupported(v, hdr)
 }
 
-_unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add) -> (err: Unmarshal_Error) {
+_unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add, allocator := context.allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
 	assign_array :: proc(
 		d: Decoder,
 		da: ^mem.Raw_Dynamic_Array,
 		elemt: ^reflect.Type_Info,
 		length: int,
 		growable := true,
+		allocator := context.allocator,
+		loc := #caller_location,
 	) -> (out_of_space: bool, err: Unmarshal_Error) {
 		for idx: uintptr = 0; length == -1 || idx < uintptr(length); idx += 1 {
 			elem_ptr := rawptr(uintptr(da.data) + idx*uintptr(elemt.size))
@@ -450,13 +452,13 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 				if !growable { return true, .Out_Of_Memory }
 
 				cap := 2 * da.cap
-				ok := runtime.__dynamic_array_reserve(da, elemt.size, elemt.align, cap)
+				ok := runtime.__dynamic_array_reserve(da, elemt.size, elemt.align, cap, loc)
  				
 				// NOTE: Might be lying here, but it is at least an allocator error.
 				if !ok { return false, .Out_Of_Memory }
 			}
 			
-			err = _unmarshal_value(d, elem, hdr)
+			err = _unmarshal_value(d, elem, hdr, allocator=allocator, loc=loc)
 			if length == -1 && err == .Break { break }
 			if err != nil { return }
 
@@ -469,10 +471,10 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 	// Allow generically storing the values array.
 	switch &dst in v {
 	case ^Array:
-		dst = err_conv(_decode_array_ptr(d, add)) or_return
+		dst = err_conv(_decode_array_ptr(d, add, allocator=allocator, loc=loc)) or_return
 		return
 	case Array:
-		dst = err_conv(_decode_array(d, add)) or_return
+		dst = err_conv(_decode_array(d, add, allocator=allocator, loc=loc)) or_return
 		return
 	}
 
@@ -480,8 +482,8 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 	case reflect.Type_Info_Slice:
 		length, scap := err_conv(_decode_len_container(d, add)) or_return
 
-		data := mem.alloc_bytes_non_zeroed(t.elem.size * scap, t.elem.align) or_return
-		defer if err != nil { mem.free_bytes(data) }
+		data := mem.alloc_bytes_non_zeroed(t.elem.size * scap, t.elem.align, allocator=allocator, loc=loc) or_return
+		defer if err != nil { mem.free_bytes(data, allocator=allocator, loc=loc) }
 
 		da := mem.Raw_Dynamic_Array{raw_data(data), 0, length, context.allocator }
 
@@ -489,7 +491,7 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 
 		if .Shrink_Excess in d.flags {
 			// Ignoring an error here, but this is not critical to succeed.
-			_ = runtime.__dynamic_array_shrink(&da, t.elem.size, t.elem.align, da.len)
+			_ = runtime.__dynamic_array_shrink(&da, t.elem.size, t.elem.align, da.len, loc=loc)
 		}
 
 		raw      := (^mem.Raw_Slice)(v.data)
@@ -500,8 +502,8 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 	case reflect.Type_Info_Dynamic_Array:
 		length, scap := err_conv(_decode_len_container(d, add)) or_return
 
-		data := mem.alloc_bytes_non_zeroed(t.elem.size * scap, t.elem.align) or_return
-		defer if err != nil { mem.free_bytes(data) }
+		data := mem.alloc_bytes_non_zeroed(t.elem.size * scap, t.elem.align, loc=loc) or_return
+		defer if err != nil { mem.free_bytes(data, allocator=allocator, loc=loc) }
 
 		raw           := (^mem.Raw_Dynamic_Array)(v.data)
 		raw.data       = raw_data(data) 
@@ -513,7 +515,7 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 
 		if .Shrink_Excess in d.flags {
 			// Ignoring an error here, but this is not critical to succeed.
-			_ = runtime.__dynamic_array_shrink(raw, t.elem.size, t.elem.align, raw.len)
+			_ = runtime.__dynamic_array_shrink(raw, t.elem.size, t.elem.align, raw.len, loc=loc)
 		}
 		return
 
@@ -525,7 +527,7 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 			return _unsupported(v, hdr)
 		}
 
-		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, length, context.allocator }
+		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, length, allocator }
 
 		out_of_space := assign_array(d, &da, t.elem, length, growable=false) or_return
 		if out_of_space { return _unsupported(v, hdr) }
@@ -539,7 +541,7 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 			return _unsupported(v, hdr)
 		}
 
-		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, length, context.allocator }
+		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, length, allocator }
 
 		out_of_space := assign_array(d, &da, t.elem, length, growable=false) or_return
 		if out_of_space { return _unsupported(v, hdr) }
@@ -553,7 +555,7 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 			return _unsupported(v, hdr)
 		}
 
-		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, 2, context.allocator }
+		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, 2, allocator }
 
 		info: ^runtime.Type_Info
 		switch ti.id {
@@ -575,7 +577,7 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 			return _unsupported(v, hdr)
 		}
 
-		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, 4, context.allocator }
+		da := mem.Raw_Dynamic_Array{rawptr(v.data), 0, 4, allocator }
 
 		info: ^runtime.Type_Info
 		switch ti.id {
@@ -593,17 +595,17 @@ _unmarshal_array :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 	}
 }
 
-_unmarshal_map :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add) -> (err: Unmarshal_Error) {
+_unmarshal_map :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, add: Add, allocator := context.allocator, loc := #caller_location) -> (err: Unmarshal_Error) {
 	r := d.reader
-	decode_key :: proc(d: Decoder, v: any, allocator := context.allocator) -> (k: string, err: Unmarshal_Error) {
+	decode_key :: proc(d: Decoder, v: any, allocator := context.allocator, loc := #caller_location) -> (k: string, err: Unmarshal_Error) {
 		entry_hdr := _decode_header(d.reader) or_return
 		entry_maj, entry_add := _header_split(entry_hdr)
 		#partial switch entry_maj {
 		case .Text:
-			k = err_conv(_decode_text(d, entry_add, allocator)) or_return
+			k = err_conv(_decode_text(d, entry_add, allocator=allocator, loc=loc)) or_return
 			return
 		case .Bytes:
-			bytes := err_conv(_decode_bytes(d, entry_add, allocator=allocator)) or_return
+			bytes := err_conv(_decode_bytes(d, entry_add, allocator=allocator, loc=loc)) or_return
 			k = string(bytes)
 			return
 		case:
@@ -615,10 +617,10 @@ _unmarshal_map :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header,
 	// Allow generically storing the map array.
 	switch &dst in v {
 	case ^Map:
-		dst = err_conv(_decode_map_ptr(d, add)) or_return
+		dst = err_conv(_decode_map_ptr(d, add, allocator=allocator, loc=loc)) or_return
 		return
 	case Map:
-		dst = err_conv(_decode_map(d, add)) or_return
+		dst = err_conv(_decode_map(d, add, allocator=allocator, loc=loc)) or_return
 		return
 	}
 
@@ -754,7 +756,7 @@ _unmarshal_map :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header,
 // Unmarshal into a union, based on the `TAG_OBJECT_TYPE` tag of the spec, it denotes a tag which
 // contains an array of exactly two elements, the first is a textual representation of the following
 // CBOR value's type.
-_unmarshal_union :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header) -> (err: Unmarshal_Error) {
+_unmarshal_union :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header, loc := #caller_location) -> (err: Unmarshal_Error) {
 	r := d.reader
 	#partial switch t in ti.variant {
 	case reflect.Type_Info_Union:
@@ -792,7 +794,7 @@ _unmarshal_union :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 			case reflect.Type_Info_Named:
 				if vti.name == target_name {
 					reflect.set_union_variant_raw_tag(v, tag)
-					return _unmarshal_value(d, any{v.data, variant.id}, _decode_header(r) or_return)
+					return _unmarshal_value(d, any{v.data, variant.id}, _decode_header(r) or_return, loc=loc)
 				}
 
 			case:
@@ -804,7 +806,7 @@ _unmarshal_union :: proc(d: Decoder, v: any, ti: ^reflect.Type_Info, hdr: Header
 				
 				if variant_name == target_name {
 					reflect.set_union_variant_raw_tag(v, tag)
-					return _unmarshal_value(d, any{v.data, variant.id}, _decode_header(r) or_return)
+					return _unmarshal_value(d, any{v.data, variant.id}, _decode_header(r) or_return, loc=loc)
 				}
 			}
 		}