Fix indentations

Fix Objective-C wrapper procs not forwarding return value

1 files changed, 561 insertions, 547 deletions

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index fad542d4a..7ffd4ea30 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -1176,327 +1176,327 @@ gb_internal lbProcedure *lb_create_objc_names(lbModule *main_module) {
 // TODO(harold): Move this out of here and into a more suitable place.
 // TODO(harold): Should not take an allocator, but always use temp, as we return string literals as well.
 String lb_get_objc_type_encoding(Type *t, gbAllocator allocator, isize pointer_depth = 0) {
-    // NOTE(harold): See https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html#//apple_ref/doc/uid/TP40008048-CH100
-
-    // NOTE(harold): Darwin targets are always 64-bit. Should we drop this and assume "q" always?
-    #define INT_SIZE_ENCODING (build_context.metrics.ptr_size == 4 ? "i" : "q")
-    switch (t->kind) {
-    case Type_Basic: {
-        switch (t->Basic.kind) {
-        case Basic_Invalid:
-            return str_lit("?");
-
-        case Basic_llvm_bool:
-        case Basic_bool:
-        case Basic_b8:
-            return str_lit("B");
-
-        case Basic_b16:
-            return str_lit("C");
-        case Basic_b32:
-            return str_lit("I");
-        case Basic_b64:
-            return str_lit("q");
-        case Basic_i8:
-            return str_lit("c");
-        case Basic_u8:
-            return str_lit("C");
-        case Basic_i16:
-        case Basic_i16le:
-        case Basic_i16be:
-            return str_lit("s");
-        case Basic_u16:
-        case Basic_u16le:
-        case Basic_u16be:
-            return str_lit("S");
-        case Basic_i32:
-        case Basic_i32le:
-        case Basic_i32be:
-            return str_lit("i");
-        case Basic_u32le:
-        case Basic_u32:
-        case Basic_u32be:
-            return str_lit("I");
-        case Basic_i64:
-        case Basic_i64le:
-        case Basic_i64be:
-            return str_lit("q");
-        case Basic_u64:
-        case Basic_u64le:
-        case Basic_u64be:
-            return str_lit("Q");
-        case Basic_i128:
-        case Basic_i128le:
-        case Basic_i128be:
-            return str_lit("t");
-        case Basic_u128:
-        case Basic_u128le:
-        case Basic_u128be:
-            return str_lit("T");
-        case Basic_rune:
-            return str_lit("I");
-        case Basic_f16:
-        case Basic_f16le:
-        case Basic_f16be:
-            return str_lit("s");    // @harold: Closest we've got?
-        case Basic_f32:
-        case Basic_f32le:
-        case Basic_f32be:
-            return str_lit("f");
-        case Basic_f64:
-        case Basic_f64le:
-        case Basic_f64be:
-            return str_lit("d");
-
-        // TODO(harold) These:
-        case Basic_complex32:
-        case Basic_complex64:
-        case Basic_complex128:
-        case Basic_quaternion64:
-        case Basic_quaternion128:
-        case Basic_quaternion256:
-                return str_lit("?");
-
-        case Basic_int:
-            return str_lit(INT_SIZE_ENCODING);
-        case Basic_uint:
-            return build_context.metrics.ptr_size == 4 ? str_lit("I") : str_lit("Q");
-        case Basic_uintptr:
-        case Basic_rawptr:
-            return str_lit("^v");
-
-        case Basic_string:
-            return build_context.metrics.ptr_size == 4 ? str_lit("{string=*i}") : str_lit("{string=*q}");
-
-        case Basic_cstring: return str_lit("*");
-        case Basic_any:     return str_lit("{any=^v^v");  // rawptr + ^Type_Info
-
-        case Basic_typeid:
-            GB_ASSERT(t->Basic.size == 8);
-            return str_lit("q");
-
-        // Untyped types
-        case Basic_UntypedBool:
-        case Basic_UntypedInteger:
-        case Basic_UntypedFloat:
-        case Basic_UntypedComplex:
-        case Basic_UntypedQuaternion:
-        case Basic_UntypedString:
-        case Basic_UntypedRune:
-        case Basic_UntypedNil:
-        case Basic_UntypedUninit:
-            GB_PANIC("Untyped types cannot be @encoded()");
-            return str_lit("?");
-        }
-        break;
-    }
-
-    case Type_Named:
-    case Type_Struct:
-    case Type_Union: {
-        Type* base = t;
-        if (base->kind == Type_Named) {
-            base = base_type(base);
-            if(base->kind != Type_Struct && base->kind != Type_Union) {
-                return lb_get_objc_type_encoding(base, allocator, pointer_depth);
-            }
-        }
-
-        const bool is_union = base->kind == Type_Union;
-        if (!is_union) {
-            // Check for objc_SEL
-            if (internal_check_is_assignable_to(base, t_objc_SEL)) {
-                return str_lit(":");
-            }
-
-            // Check for objc_Class
-            if (internal_check_is_assignable_to(base, t_objc_SEL)) {
-                return str_lit("#");
-            }
-
-            // Treat struct as an Objective-C Class?
-            if (has_type_got_objc_class_attribute(base) && pointer_depth == 0) {
-                return str_lit("#");
-            }
-        }
-
-        if (is_type_objc_object(base)) {
-            return str_lit("@");
-        }
-
-
-        gbString s = gb_string_make_reserve(allocator, 16);
-        s = gb_string_append_length(s, is_union ? "(" :"{", 1);
-        if (t->kind == Type_Named) {
-            s = gb_string_append_length(s, t->Named.name.text, t->Named.name.len);
-        }
-
-        // Write fields
-        if (pointer_depth < 2) {
-            s = gb_string_append_length(s, "=", 1);
-
-            if (!is_union) {
-                for( auto& f : base->Struct.fields ) {
-                    String field_type = lb_get_objc_type_encoding(f->type, allocator, pointer_depth);
-                    s = gb_string_append_length(s, field_type.text, field_type.len);
-                }
-            } else {
-                // #TODO(harold): Encode fields
-            }
-        }
-
-        s = gb_string_append_length(s, is_union ? ")" :"}", 1);
-
-        return make_string_c(s);
-    }
-
-    case Type_Generic:
-        GB_PANIC("Generic types cannot be @encoded()");
-        return str_lit("?");
-
-    case Type_Pointer: {
-        String pointee = lb_get_objc_type_encoding(t->Pointer.elem, allocator, pointer_depth +1);
-        // Special case for Objective-C Objects
-        if (pointer_depth == 0 && pointee == "@") {
-            return pointee;
-        }
-
-        return concatenate_strings(allocator, str_lit("^"), pointee);
-    }
-
-    case Type_MultiPointer:
-        return concatenate_strings(allocator, str_lit("^"), lb_get_objc_type_encoding(t->Pointer.elem, allocator, pointer_depth +1));
-
-    case Type_Array: {
-        String type_str = lb_get_objc_type_encoding(t->Array.elem, allocator, pointer_depth);
-
-        gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
-        s = gb_string_append_fmt(s, "[%lld%s]", t->Array.count, type_str.text);
-        return make_string_c(s);
-    }
-
-    case Type_EnumeratedArray: {
-        String type_str = lb_get_objc_type_encoding(t->EnumeratedArray.elem, allocator, pointer_depth);
-
-        gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
-        s = gb_string_append_fmt(s, "[%lld%s]", t->EnumeratedArray.count, type_str.text);
-        return make_string_c(s);
-    }
-
-    case Type_Slice: {
-        String type_str = lb_get_objc_type_encoding(t->Slice.elem, allocator, pointer_depth);
-        gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
-        s = gb_string_append_fmt(s, "{slice=^%s%s}", type_str, INT_SIZE_ENCODING);
-        return make_string_c(s);
-    }
-
-    case Type_DynamicArray: {
-        String type_str = lb_get_objc_type_encoding(t->DynamicArray.elem, allocator, pointer_depth);
-        gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
-        s = gb_string_append_fmt(s, "{dynamic=^%s%s%sAllocator={?^v}}", type_str, INT_SIZE_ENCODING, INT_SIZE_ENCODING);
-        return make_string_c(s);
-    }
-
-    case Type_Map:
-        return str_lit("{^v^v{Allocator=?^v}}");
-    case Type_Enum:
-        return lb_get_objc_type_encoding(t->Enum.base_type, allocator, pointer_depth);
-    case Type_Tuple:
-        // NOTE(harold): Is this allowed here?
-        return str_lit("?");
-    case Type_Proc:
-        return str_lit("?");
-    case Type_BitSet:
-        return lb_get_objc_type_encoding(t->BitSet.underlying, allocator, pointer_depth);
-    case Type_SimdVector:
-        break;
-    case Type_Matrix:
-        break;
-    case Type_BitField:
-        return lb_get_objc_type_encoding(t->BitField.backing_type, allocator, pointer_depth);
-    case Type_SoaPointer: {
-        gbString s = gb_string_make_reserve(allocator, 8);
-        s = gb_string_append_fmt(s, "{=^v%s}", INT_SIZE_ENCODING);
-        return make_string_c(s);
-    }
-
-    } // End switch t->kind
-    #undef INT_SIZE_ENCODING
-
-    GB_PANIC("Unreachable");
+	// NOTE(harold): See https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html#//apple_ref/doc/uid/TP40008048-CH100
+
+	// NOTE(harold): Darwin targets are always 64-bit. Should we drop this and assume "q" always?
+	#define INT_SIZE_ENCODING (build_context.metrics.ptr_size == 4 ? "i" : "q")
+	switch (t->kind) {
+	case Type_Basic: {
+		switch (t->Basic.kind) {
+		case Basic_Invalid:
+			return str_lit("?");
+
+		case Basic_llvm_bool:
+		case Basic_bool:
+		case Basic_b8:
+			return str_lit("B");
+
+		case Basic_b16:
+			return str_lit("C");
+		case Basic_b32:
+			return str_lit("I");
+		case Basic_b64:
+			return str_lit("q");
+		case Basic_i8:
+			return str_lit("c");
+		case Basic_u8:
+			return str_lit("C");
+		case Basic_i16:
+		case Basic_i16le:
+		case Basic_i16be:
+			return str_lit("s");
+		case Basic_u16:
+		case Basic_u16le:
+		case Basic_u16be:
+			return str_lit("S");
+		case Basic_i32:
+		case Basic_i32le:
+		case Basic_i32be:
+			return str_lit("i");
+		case Basic_u32le:
+		case Basic_u32:
+		case Basic_u32be:
+			return str_lit("I");
+		case Basic_i64:
+		case Basic_i64le:
+		case Basic_i64be:
+			return str_lit("q");
+		case Basic_u64:
+		case Basic_u64le:
+		case Basic_u64be:
+			return str_lit("Q");
+		case Basic_i128:
+		case Basic_i128le:
+		case Basic_i128be:
+			return str_lit("t");
+		case Basic_u128:
+		case Basic_u128le:
+		case Basic_u128be:
+			return str_lit("T");
+		case Basic_rune:
+			return str_lit("I");
+		case Basic_f16:
+		case Basic_f16le:
+		case Basic_f16be:
+			return str_lit("s");    // @harold: Closest we've got?
+		case Basic_f32:
+		case Basic_f32le:
+		case Basic_f32be:
+			return str_lit("f");
+		case Basic_f64:
+		case Basic_f64le:
+		case Basic_f64be:
+			return str_lit("d");
+
+		// TODO(harold) These:
+		case Basic_complex32:
+		case Basic_complex64:
+		case Basic_complex128:
+		case Basic_quaternion64:
+		case Basic_quaternion128:
+		case Basic_quaternion256:
+				return str_lit("?");
+
+		case Basic_int:
+			return str_lit(INT_SIZE_ENCODING);
+		case Basic_uint:
+			return build_context.metrics.ptr_size == 4 ? str_lit("I") : str_lit("Q");
+		case Basic_uintptr:
+		case Basic_rawptr:
+			return str_lit("^v");
+
+		case Basic_string:
+			return build_context.metrics.ptr_size == 4 ? str_lit("{string=*i}") : str_lit("{string=*q}");
+
+		case Basic_cstring: return str_lit("*");
+		case Basic_any:     return str_lit("{any=^v^v");  // rawptr + ^Type_Info
+
+		case Basic_typeid:
+			GB_ASSERT(t->Basic.size == 8);
+			return str_lit("q");
+
+		// Untyped types
+		case Basic_UntypedBool:
+		case Basic_UntypedInteger:
+		case Basic_UntypedFloat:
+		case Basic_UntypedComplex:
+		case Basic_UntypedQuaternion:
+		case Basic_UntypedString:
+		case Basic_UntypedRune:
+		case Basic_UntypedNil:
+		case Basic_UntypedUninit:
+			GB_PANIC("Untyped types cannot be @encoded()");
+			return str_lit("?");
+		}
+		break;
+	}
+
+	case Type_Named:
+	case Type_Struct:
+	case Type_Union: {
+		Type* base = t;
+		if (base->kind == Type_Named) {
+			base = base_type(base);
+			if(base->kind != Type_Struct && base->kind != Type_Union) {
+				return lb_get_objc_type_encoding(base, allocator, pointer_depth);
+			}
+		}
+
+		const bool is_union = base->kind == Type_Union;
+		if (!is_union) {
+			// Check for objc_SEL
+			if (internal_check_is_assignable_to(base, t_objc_SEL)) {
+				return str_lit(":");
+			}
+
+			// Check for objc_Class
+			if (internal_check_is_assignable_to(base, t_objc_SEL)) {
+				return str_lit("#");
+			}
+
+			// Treat struct as an Objective-C Class?
+			if (has_type_got_objc_class_attribute(base) && pointer_depth == 0) {
+				return str_lit("#");
+			}
+		}
+
+		if (is_type_objc_object(base)) {
+			return str_lit("@");
+		}
+
+
+		gbString s = gb_string_make_reserve(allocator, 16);
+		s = gb_string_append_length(s, is_union ? "(" :"{", 1);
+		if (t->kind == Type_Named) {
+			s = gb_string_append_length(s, t->Named.name.text, t->Named.name.len);
+		}
+
+		// Write fields
+		if (pointer_depth < 2) {
+			s = gb_string_append_length(s, "=", 1);
+
+			if (!is_union) {
+				for( auto& f : base->Struct.fields ) {
+					String field_type = lb_get_objc_type_encoding(f->type, allocator, pointer_depth);
+					s = gb_string_append_length(s, field_type.text, field_type.len);
+				}
+			} else {
+				// #TODO(harold): Encode fields
+			}
+		}
+
+		s = gb_string_append_length(s, is_union ? ")" :"}", 1);
+
+		return make_string_c(s);
+	}
+
+	case Type_Generic:
+		GB_PANIC("Generic types cannot be @encoded()");
+		return str_lit("?");
+
+	case Type_Pointer: {
+		String pointee = lb_get_objc_type_encoding(t->Pointer.elem, allocator, pointer_depth +1);
+		// Special case for Objective-C Objects
+		if (pointer_depth == 0 && pointee == "@") {
+			return pointee;
+		}
+
+		return concatenate_strings(allocator, str_lit("^"), pointee);
+	}
+
+	case Type_MultiPointer:
+		return concatenate_strings(allocator, str_lit("^"), lb_get_objc_type_encoding(t->Pointer.elem, allocator, pointer_depth +1));
+
+	case Type_Array: {
+		String type_str = lb_get_objc_type_encoding(t->Array.elem, allocator, pointer_depth);
+
+		gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
+		s = gb_string_append_fmt(s, "[%lld%s]", t->Array.count, type_str.text);
+		return make_string_c(s);
+	}
+
+	case Type_EnumeratedArray: {
+		String type_str = lb_get_objc_type_encoding(t->EnumeratedArray.elem, allocator, pointer_depth);
+
+		gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
+		s = gb_string_append_fmt(s, "[%lld%s]", t->EnumeratedArray.count, type_str.text);
+		return make_string_c(s);
+	}
+
+	case Type_Slice: {
+		String type_str = lb_get_objc_type_encoding(t->Slice.elem, allocator, pointer_depth);
+		gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
+		s = gb_string_append_fmt(s, "{slice=^%s%s}", type_str, INT_SIZE_ENCODING);
+		return make_string_c(s);
+	}
+
+	case Type_DynamicArray: {
+		String type_str = lb_get_objc_type_encoding(t->DynamicArray.elem, allocator, pointer_depth);
+		gbString s = gb_string_make_reserve(allocator, type_str.len + 8);
+		s = gb_string_append_fmt(s, "{dynamic=^%s%s%sAllocator={?^v}}", type_str, INT_SIZE_ENCODING, INT_SIZE_ENCODING);
+		return make_string_c(s);
+	}
+
+	case Type_Map:
+		return str_lit("{^v^v{Allocator=?^v}}");
+	case Type_Enum:
+		return lb_get_objc_type_encoding(t->Enum.base_type, allocator, pointer_depth);
+	case Type_Tuple:
+		// NOTE(harold): Is this allowed here?
+		return str_lit("?");
+	case Type_Proc:
+		return str_lit("?");
+	case Type_BitSet:
+		return lb_get_objc_type_encoding(t->BitSet.underlying, allocator, pointer_depth);
+	case Type_SimdVector:
+		break;
+	case Type_Matrix:
+		break;
+	case Type_BitField:
+		return lb_get_objc_type_encoding(t->BitField.backing_type, allocator, pointer_depth);
+	case Type_SoaPointer: {
+		gbString s = gb_string_make_reserve(allocator, 8);
+		s = gb_string_append_fmt(s, "{=^v%s}", INT_SIZE_ENCODING);
+		return make_string_c(s);
+	}
+
+	} // End switch t->kind
+	#undef INT_SIZE_ENCODING
+
+	GB_PANIC("Unreachable");
 }
 
 struct lbObjCGlobalClass {
-    lbObjCGlobal g;
-    lbValue      class_value;    // Local registered class value
+	lbObjCGlobal g;
+	lbValue      class_value;    // Local registered class value
 };
 
 gb_internal void lb_register_objc_thing(
-    StringSet &handled,
-    lbModule *m,
-    Array<lbValue> &args,
-    Array<lbObjCGlobalClass> &class_impls,
-    StringMap<lbObjCGlobalClass> &class_map,
-    lbProcedure *p,
-    lbObjCGlobal const &g,
-    char const *call
+	StringSet &handled,
+	lbModule *m,
+	Array<lbValue> &args,
+	Array<lbObjCGlobalClass> &class_impls,
+	StringMap<lbObjCGlobalClass> &class_map,
+	lbProcedure *p,
+	lbObjCGlobal const &g,
+	char const *call
 ) {
-    if (string_set_update(&handled, g.name)) {
-        return;
-    }
-
-    lbAddr addr = {};
-    lbValue *found = string_map_get(&m->members, g.global_name);
-    if (found) {
-        addr = lb_addr(*found);
-    } else {
-        lbValue v = {};
-        LLVMTypeRef t = lb_type(m, g.type);
-        v.value = LLVMAddGlobal(m->mod, t, g.global_name);
-        v.type = alloc_type_pointer(g.type);
-        addr = lb_addr(v);
-        LLVMSetInitializer(v.value, LLVMConstNull(t));
-    }
-
-    lbValue class_ptr{};
-    lbValue class_name = lb_const_value(m, t_cstring, exact_value_string(g.name));
-
-    // If this class requires an implementation, save it for registration below.
-    if (g.class_impl_type != nullptr) {
-
-        // Make sure the superclass has been initialized before us
-        lbValue superclass_value{};
-
-        auto& tn = g.class_impl_type->Named.type_name->TypeName;
-        Type *superclass = tn.objc_superclass;
-        if (superclass != nullptr) {
-            auto& superclass_global = string_map_must_get(&class_map, superclass->Named.type_name->TypeName.objc_class_name);
-            lb_register_objc_thing(handled, m, args, class_impls, class_map, p, superclass_global.g, call);
-            GB_ASSERT(superclass_global.class_value.value);
-
-            superclass_value = superclass_global.class_value;
-        }
-
-        args.count = 3;
-        args[0] = superclass == nullptr ? lb_const_nil(m, t_objc_Class) : superclass_value;
-        args[1] = class_name;
-        args[2] = lb_const_int(m, t_uint, 0);
-        class_ptr = lb_emit_runtime_call(p, "objc_allocateClassPair", args);
-
-        array_add(&class_impls, lbObjCGlobalClass{g, class_ptr});
-    }
-    else {
-        args.count = 1;
-        args[0] = class_name;
-        class_ptr = lb_emit_runtime_call(p, call, args);
-    }
-
-    lb_addr_store(p, addr, class_ptr);
-
-    lbObjCGlobalClass* class_global = string_map_get(&class_map, g.name);
-    if (class_global != nullptr) {
-        class_global->class_value = class_ptr;
-    }
+	if (string_set_update(&handled, g.name)) {
+		return;
+	}
+
+	lbAddr addr = {};
+	lbValue *found = string_map_get(&m->members, g.global_name);
+	if (found) {
+		addr = lb_addr(*found);
+	} else {
+		lbValue v = {};
+		LLVMTypeRef t = lb_type(m, g.type);
+		v.value = LLVMAddGlobal(m->mod, t, g.global_name);
+		v.type = alloc_type_pointer(g.type);
+		addr = lb_addr(v);
+		LLVMSetInitializer(v.value, LLVMConstNull(t));
+	}
+
+	lbValue class_ptr{};
+	lbValue class_name = lb_const_value(m, t_cstring, exact_value_string(g.name));
+
+	// If this class requires an implementation, save it for registration below.
+	if (g.class_impl_type != nullptr) {
+
+		// Make sure the superclass has been initialized before us
+		lbValue superclass_value{};
+
+		auto& tn = g.class_impl_type->Named.type_name->TypeName;
+		Type *superclass = tn.objc_superclass;
+		if (superclass != nullptr) {
+			auto& superclass_global = string_map_must_get(&class_map, superclass->Named.type_name->TypeName.objc_class_name);
+			lb_register_objc_thing(handled, m, args, class_impls, class_map, p, superclass_global.g, call);
+			GB_ASSERT(superclass_global.class_value.value);
+
+			superclass_value = superclass_global.class_value;
+		}
+
+		args.count = 3;
+		args[0] = superclass == nullptr ? lb_const_nil(m, t_objc_Class) : superclass_value;
+		args[1] = class_name;
+		args[2] = lb_const_int(m, t_uint, 0);
+		class_ptr = lb_emit_runtime_call(p, "objc_allocateClassPair", args);
+
+		array_add(&class_impls, lbObjCGlobalClass{g, class_ptr});
+	}
+	else {
+		args.count = 1;
+		args[0] = class_name;
+		class_ptr = lb_emit_runtime_call(p, call, args);
+	}
+
+	lb_addr_store(p, addr, class_ptr);
+
+	lbObjCGlobalClass* class_global = string_map_get(&class_map, g.name);
+	if (class_global != nullptr) {
+		class_global->class_value = class_ptr;
+	}
 }
 
 gb_internal void lb_finalize_objc_names(lbGenerator *gen, lbProcedure *p) {
@@ -1513,80 +1513,80 @@ gb_internal void lb_finalize_objc_names(lbGenerator *gen, lbProcedure *p) {
 	defer (string_set_destroy(&handled));
 
 	auto args        = array_make<lbValue>(temporary_allocator(), 3, 8);
-    auto class_impls = array_make<lbObjCGlobalClass>(temporary_allocator(), 0, 16);
-
-    // Ensure classes that have been implicitly referenced through
-    // the objc_superclass attribute have a global variable available for them.
-    TypeSet class_set{};
-    type_set_init(&class_set, gen->objc_classes.count+16);
-    defer (type_set_destroy(&class_set));
-
-    auto referenced_classes = array_make<lbObjCGlobal>(temporary_allocator());
-    for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_classes, &g); /**/) {
-        array_add( &referenced_classes, g);
-
-        Type *cls = g.class_impl_type;
-        while (cls) {
-            if (type_set_update(&class_set, cls)) {
-                break;
-            }
-            GB_ASSERT(cls->kind == Type_Named);
-
-            cls = cls->Named.type_name->TypeName.objc_superclass;
-        }
-    }
-
-    for (auto pair : class_set) {
-        auto& tn = pair.type->Named.type_name->TypeName;
-        Type *class_impl = !tn.objc_is_implementation ? nullptr : pair.type;
-        lb_handle_objc_find_or_register_class(p, tn.objc_class_name, class_impl);
-    }
-    for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_classes, &g); /**/) {
-        array_add( &referenced_classes, g );
-    }
-
-    // Add all class globals to a map so that we can look them up dynamically
-    // in order to resolve out-of-order because classes that are being implemented
-    // need their superclasses to have been registered before them.
-    StringMap<lbObjCGlobalClass> global_class_map{};
-    string_map_init(&global_class_map, (usize)gen->objc_classes.count);
-    defer (string_map_destroy(&global_class_map));
-
-    for (lbObjCGlobal g :referenced_classes) {
-        string_map_set(&global_class_map, g.name, lbObjCGlobalClass{g});
-    }
-
-    LLVMSetLinkage(p->value, LLVMInternalLinkage);
-    lb_begin_procedure_body(p);
-
-    // Register class globals, gathering classes that must be implemented
-    for (auto& kv : global_class_map) {
-        lb_register_objc_thing(handled, m, args, class_impls, global_class_map, p, kv.value.g, "objc_lookUpClass");
-    }
-
-    // Prefetch selectors for implemented methods so that they can also be registered.
-    for (const auto& cd : class_impls) {
-        auto& g = cd.g;
-        Type *class_type = g.class_impl_type;
-
-        Array<ObjcMethodData>* methods = map_get(&m->info->objc_method_implementations, class_type);
-        if (!methods) {
-            continue;
-        }
-
-        for (const ObjcMethodData& md : *methods) {
-            lb_handle_objc_find_or_register_selector(p, md.ac.objc_selector);
-        }
-    }
-
-    // Now we can register all referenced selectors
-    for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_selectors, &g); /**/) {
-        lb_register_objc_thing(handled, m, args, class_impls, global_class_map, p, g, "sel_registerName");
-    }
-
-
-    // Emit method wrapper implementations and registration
-    auto wrapper_args     = array_make<Type *>(temporary_allocator(), 2, 8);
+	auto class_impls = array_make<lbObjCGlobalClass>(temporary_allocator(), 0, 16);
+
+	// Ensure classes that have been implicitly referenced through
+	// the objc_superclass attribute have a global variable available for them.
+	TypeSet class_set{};
+	type_set_init(&class_set, gen->objc_classes.count+16);
+	defer (type_set_destroy(&class_set));
+
+	auto referenced_classes = array_make<lbObjCGlobal>(temporary_allocator());
+	for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_classes, &g); /**/) {
+		array_add( &referenced_classes, g);
+
+		Type *cls = g.class_impl_type;
+		while (cls) {
+			if (type_set_update(&class_set, cls)) {
+				break;
+			}
+			GB_ASSERT(cls->kind == Type_Named);
+
+			cls = cls->Named.type_name->TypeName.objc_superclass;
+		}
+	}
+
+	for (auto pair : class_set) {
+		auto& tn = pair.type->Named.type_name->TypeName;
+		Type *class_impl = !tn.objc_is_implementation ? nullptr : pair.type;
+		lb_handle_objc_find_or_register_class(p, tn.objc_class_name, class_impl);
+	}
+	for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_classes, &g); /**/) {
+		array_add( &referenced_classes, g );
+	}
+
+	// Add all class globals to a map so that we can look them up dynamically
+	// in order to resolve out-of-order because classes that are being implemented
+	// need their superclasses to have been registered before them.
+	StringMap<lbObjCGlobalClass> global_class_map{};
+	string_map_init(&global_class_map, (usize)gen->objc_classes.count);
+	defer (string_map_destroy(&global_class_map));
+
+	for (lbObjCGlobal g :referenced_classes) {
+		string_map_set(&global_class_map, g.name, lbObjCGlobalClass{g});
+	}
+
+	LLVMSetLinkage(p->value, LLVMInternalLinkage);
+	lb_begin_procedure_body(p);
+
+	// Register class globals, gathering classes that must be implemented
+	for (auto& kv : global_class_map) {
+		lb_register_objc_thing(handled, m, args, class_impls, global_class_map, p, kv.value.g, "objc_lookUpClass");
+	}
+
+	// Prefetch selectors for implemented methods so that they can also be registered.
+	for (const auto& cd : class_impls) {
+		auto& g = cd.g;
+		Type *class_type = g.class_impl_type;
+
+		Array<ObjcMethodData>* methods = map_get(&m->info->objc_method_implementations, class_type);
+		if (!methods) {
+			continue;
+		}
+
+		for (const ObjcMethodData& md : *methods) {
+			lb_handle_objc_find_or_register_selector(p, md.ac.objc_selector);
+		}
+	}
+
+	// Now we can register all referenced selectors
+	for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_selectors, &g); /**/) {
+		lb_register_objc_thing(handled, m, args, class_impls, global_class_map, p, g, "sel_registerName");
+	}
+
+
+	// Emit method wrapper implementations and registration
+	auto wrapper_args     = array_make<Type *>(temporary_allocator(), 2, 8);
 	auto get_context_args = array_make<lbValue>(temporary_allocator(), 1);
 
 
@@ -1597,186 +1597,200 @@ gb_internal void lb_finalize_objc_names(lbGenerator *gen, lbProcedure *p) {
 		map_set(&ivar_map, g.class_impl_type, g);
 	}
 
-    for (const auto& cd : class_impls) {
-        auto& g = cd.g;
-        Type *class_type = g.class_impl_type;
-    	Type *class_ptr_type = alloc_type_pointer(class_type);
-    	lbValue class_value = cd.class_value;
+	for (const auto& cd : class_impls) {
+		auto& g = cd.g;
+		Type *class_type = g.class_impl_type;
+		Type *class_ptr_type = alloc_type_pointer(class_type);
+		lbValue class_value = cd.class_value;
 
-    	Type *ivar_type = class_type->Named.type_name->TypeName.objc_ivar;
+		Type *ivar_type = class_type->Named.type_name->TypeName.objc_ivar;
 
-    	Entity *context_provider = class_type->Named.type_name->TypeName.objc_context_provider;
-    	Type *contex_provider_self_ptr_type = nullptr;
-    	Type *contex_provider_self_named_type = nullptr;
-    	bool is_context_provider_ivar = false;
-    	lbValue context_provider_proc_value{};
+		Entity *context_provider = class_type->Named.type_name->TypeName.objc_context_provider;
+		Type *contex_provider_self_ptr_type = nullptr;
+		Type *contex_provider_self_named_type = nullptr;
+		bool is_context_provider_ivar = false;
+		lbValue context_provider_proc_value{};
 
-    	if (context_provider) {
-    		context_provider_proc_value = lb_find_procedure_value_from_entity(m, context_provider);
+		if (context_provider) {
+			context_provider_proc_value = lb_find_procedure_value_from_entity(m, context_provider);
 
-    		contex_provider_self_ptr_type = base_type(context_provider->type->Proc.params->Tuple.variables[0]->type);
-    		GB_ASSERT(contex_provider_self_ptr_type->kind == Type_Pointer);
-    		contex_provider_self_named_type = base_named_type(type_deref(contex_provider_self_ptr_type));
+			contex_provider_self_ptr_type = base_type(context_provider->type->Proc.params->Tuple.variables[0]->type);
+			GB_ASSERT(contex_provider_self_ptr_type->kind == Type_Pointer);
+			contex_provider_self_named_type = base_named_type(type_deref(contex_provider_self_ptr_type));
 
-    		is_context_provider_ivar = ivar_type != nullptr && internal_check_is_assignable_to(contex_provider_self_named_type, ivar_type);
-    	}
+			is_context_provider_ivar = ivar_type != nullptr && internal_check_is_assignable_to(contex_provider_self_named_type, ivar_type);
+		}
 
 
-        Array<ObjcMethodData>* methods = map_get(&m->info->objc_method_implementations, class_type);
-        if (!methods) {
-            continue;
-        }
+		Array<ObjcMethodData>* methods = map_get(&m->info->objc_method_implementations, class_type);
+		if (!methods) {
+			continue;
+		}
 
-        for (const ObjcMethodData& md : *methods) {
-            GB_ASSERT( md.proc_entity->kind == Entity_Procedure);
-            Type *method_type = md.proc_entity->type;
+		for (const ObjcMethodData& md : *methods) {
+			GB_ASSERT( md.proc_entity->kind == Entity_Procedure);
+			Type *method_type = md.proc_entity->type;
 
-            String proc_name = make_string_c("__$objc_method::");
-            proc_name = concatenate_strings(temporary_allocator(), proc_name, g.name);
-            proc_name = concatenate_strings(temporary_allocator(), proc_name, str_lit("::"));
-            proc_name = concatenate_strings( permanent_allocator(), proc_name, md.ac.objc_name);
+			String proc_name = make_string_c("__$objc_method::");
+			proc_name = concatenate_strings(temporary_allocator(), proc_name, g.name);
+			proc_name = concatenate_strings(temporary_allocator(), proc_name, str_lit("::"));
+			proc_name = concatenate_strings( permanent_allocator(), proc_name, md.ac.objc_name);
 
-            wrapper_args.count = 2;
-            wrapper_args[0] = md.ac.objc_is_class_method ? t_objc_Class : class_ptr_type;
-            wrapper_args[1] = t_objc_SEL;
+			wrapper_args.count = 2;
+			wrapper_args[0] = md.ac.objc_is_class_method ? t_objc_Class : class_ptr_type;
+			wrapper_args[1] = t_objc_SEL;
 
-            auto method_param_count  = (isize)method_type->Proc.param_count;
-            i32  method_param_offset = 0;
+			auto method_param_count  = (isize)method_type->Proc.param_count;
+			i32  method_param_offset = 0;
 
-            // TODO(harold): Need to make sure (at checker stage) that the non-class method has the self parameter already.
-            //               (Maybe this is already accounted for?.)
-            if (!md.ac.objc_is_class_method) {
-                GB_ASSERT(method_param_count >= 1);
-                method_param_count -= 1;
-                method_param_offset = 1;
-            }
+			// TODO(harold): Need to make sure (at checker stage) that the non-class method has the self parameter already.
+			//               (Maybe this is already accounted for?.)
+			if (!md.ac.objc_is_class_method) {
+				GB_ASSERT(method_param_count >= 1);
+				method_param_count -= 1;
+				method_param_offset = 1;
+			}
 
-            for (i32 i = 0; i < method_param_count; i++) {
-                array_add(&wrapper_args, method_type->Proc.params->Tuple.variables[method_param_offset+i]->type);
-            }
+			for (i32 i = 0; i < method_param_count; i++) {
+				array_add(&wrapper_args, method_type->Proc.params->Tuple.variables[method_param_offset+i]->type);
+			}
 
-            Type *wrapper_args_tuple = alloc_type_tuple_from_field_types(wrapper_args.data, wrapper_args.count, false, true);
-            Type *wrapper_proc_type = alloc_type_proc(nullptr, wrapper_args_tuple, (isize)wrapper_args_tuple->Tuple.variables.count, nullptr, 0, false, ProcCC_CDecl);
+			Type *wrapper_args_tuple = alloc_type_tuple_from_field_types(wrapper_args.data, wrapper_args.count, false, true);
+			Type *wrapper_results_tuple = nullptr;
 
-            lbProcedure *wrapper_proc = lb_create_dummy_procedure(m, proc_name, wrapper_proc_type);
-            lb_add_attribute_to_proc(wrapper_proc->module, wrapper_proc->value, "nounwind");
+			if (method_type->Proc.result_count > 0) {
+				GB_ASSERT(method_type->Proc.result_count == 1);
+				wrapper_results_tuple = alloc_type_tuple_from_field_types(&method_type->Proc.results->Tuple.variables[0]->type, 1, false, true);
+			}
+
+			Type *wrapper_proc_type = alloc_type_proc(nullptr, wrapper_args_tuple, wrapper_args_tuple->Tuple.variables.count,
+														wrapper_results_tuple, method_type->Proc.result_count, false, ProcCC_CDecl);
 
-            // Emit the wrapper
-            LLVMSetLinkage(wrapper_proc->value, LLVMExternalLinkage);
-            lb_begin_procedure_body(wrapper_proc);
-            {
-            	if (method_type->Proc.calling_convention == ProcCC_Odin) {
-            		GB_ASSERT(context_provider);
+			lbProcedure *wrapper_proc = lb_create_dummy_procedure(m, proc_name, wrapper_proc_type);
+			lb_add_attribute_to_proc(wrapper_proc->module, wrapper_proc->value, "nounwind");
 
-            		// Emit the get odin context call
+			// Emit the wrapper
+			LLVMSetLinkage(wrapper_proc->value, LLVMExternalLinkage);
+			lb_begin_procedure_body(wrapper_proc);
+			{
+				if (method_type->Proc.calling_convention == ProcCC_Odin) {
+					GB_ASSERT(context_provider);
 
-            		get_context_args[0] = lbValue {
-            			wrapper_proc->raw_input_parameters[0],
+					// Emit the get odin context call
+
+					get_context_args[0] = lbValue {
+						wrapper_proc->raw_input_parameters[0],
 						contex_provider_self_ptr_type,
 					};
 
-            		if (is_context_provider_ivar) {
-            			// The context provider takes the ivar's type.
-            			// Emit an obj_ivar_get call and use that pointer for 'self' instead.
-            			lbValue real_self {
-            				wrapper_proc->raw_input_parameters[0],
-            				class_ptr_type
-            			};
-            			get_context_args[0] = lb_handle_objc_ivar_for_objc_object_pointer(wrapper_proc, real_self);
-            		}
-
-            		lbValue context	     = lb_emit_call(wrapper_proc, context_provider_proc_value, get_context_args);
-            		lbAddr  context_addr = lb_addr(lb_address_from_load_or_generate_local(wrapper_proc, context));
-            		lb_push_context_onto_stack(wrapper_proc, context_addr);
-            	}
-
-
-                auto method_call_args = array_make<lbValue>(temporary_allocator(), method_param_count + (isize)method_param_offset);
-
-                if (!md.ac.objc_is_class_method) {
-                    method_call_args[0] = lbValue {
-                        wrapper_proc->raw_input_parameters[0],
-                        class_ptr_type,
-                    };
-                }
-
-                for (isize i = 0; i < method_param_count; i++) {
-                    method_call_args[i+method_param_offset] = lbValue {
-                        wrapper_proc->raw_input_parameters[i+2],
-                        method_type->Proc.params->Tuple.variables[i+method_param_offset]->type,
-                    };
-                }
-                lbValue method_proc_value = lb_find_procedure_value_from_entity(m, md.proc_entity);
-
-                // Call real procedure for method from here, passing the parameters expected, if any.
-                lb_emit_call(wrapper_proc, method_proc_value, method_call_args);
-            }
-            lb_end_procedure_body(wrapper_proc);
-
-
-            // Add the method to the class
-            String method_encoding = str_lit("v");
-            // TODO (harold): Checker must ensure that objc_methods have a single return value or none!
-            GB_ASSERT(method_type->Proc.result_count <= 1);
-            if (method_type->Proc.result_count != 0) {
-                method_encoding = lb_get_objc_type_encoding(method_type->Proc.results->Tuple.variables[0]->type, temporary_allocator());
-            }
-
-            if (!md.ac.objc_is_class_method) {
-                method_encoding = concatenate_strings(temporary_allocator(), method_encoding, str_lit("@:"));
-            } else {
-                method_encoding = concatenate_strings(temporary_allocator(), method_encoding, str_lit("#:"));
-            }
-
-            for (i32 i = method_param_offset; i < method_param_count; i++) {
-                Type *param_type = method_type->Proc.params->Tuple.variables[i]->type;
-                String param_encoding = lb_get_objc_type_encoding(param_type, temporary_allocator());
-
-                method_encoding = concatenate_strings(temporary_allocator(), method_encoding, param_encoding);
-            }
-
-            // Emit method registration
-            lbAddr* sel_address = string_map_get(&m->objc_selectors, md.ac.objc_selector);
-            GB_ASSERT(sel_address);
-            lbValue selector_value = lb_addr_load(p, *sel_address);
-
-            args.count = 4;
-            args[0] = class_value;    // Class
-            args[1] = selector_value; // SEL
-            args[2] = lbValue { wrapper_proc->value, wrapper_proc->type };
-            args[3] = lb_const_value(m, t_cstring, exact_value_string(method_encoding));
-
-            // TODO(harold): Emit check BOOL result and panic if false.
-            lb_emit_runtime_call(p, "class_addMethod", args);
-
-        } // End methods
-
-        // Add ivar if we have one
-        if (ivar_type != nullptr) {
-            // Register a single ivar for this class
-            Type *ivar_base = ivar_type->Named.base;
-
-            const i64 size      = type_size_of(ivar_base);
-            const i64 alignment = type_align_of(ivar_base);
-            // TODO(harold): Checker: Alignment must be compatible with ivar rules. Or we should increase the alignment if needed.
-
-        	// TODO(harold): Should we pass the actual type encoding? Might not be ideal for obfuscation.
-            String ivar_name  = str_lit("__$ivar");
-            String ivar_types = str_lit("{= }");	//lb_get_objc_type_encoding(ivar_type, temporary_allocator());// str_lit("{= }");
-            args.count = 5;
-            args[0] = class_value;
-            args[1] = lb_const_value(m, t_cstring, exact_value_string(ivar_name));
-            args[2] = lb_const_value(m, t_uint, exact_value_u64((u64)size));
-            args[3] = lb_const_value(m, t_u8, exact_value_u64((u64)alignment));
-            args[4] = lb_const_value(m, t_cstring, exact_value_string(ivar_types));
-            lb_emit_runtime_call(p, "class_addIvar", args);
-        }
-
-        // Complete the class registration
-        args.count = 1;
-        args[0] = class_value;
-        lb_emit_runtime_call(p, "objc_registerClassPair", args);
-    }
+					if (is_context_provider_ivar) {
+						// The context provider takes the ivar's type.
+						// Emit an obj_ivar_get call and use that pointer for 'self' instead.
+						lbValue real_self {
+							wrapper_proc->raw_input_parameters[0],
+							class_ptr_type
+						};
+						get_context_args[0] = lb_handle_objc_ivar_for_objc_object_pointer(wrapper_proc, real_self);
+					}
+
+					lbValue context	     = lb_emit_call(wrapper_proc, context_provider_proc_value, get_context_args);
+					lbAddr  context_addr = lb_addr(lb_address_from_load_or_generate_local(wrapper_proc, context));
+					lb_push_context_onto_stack(wrapper_proc, context_addr);
+				}
+
+
+				auto method_call_args = array_make<lbValue>(temporary_allocator(), method_param_count + (isize)method_param_offset);
+
+				if (!md.ac.objc_is_class_method) {
+					method_call_args[0] = lbValue {
+						wrapper_proc->raw_input_parameters[0],
+						class_ptr_type,
+					};
+				}
+
+				for (isize i = 0; i < method_param_count; i++) {
+					method_call_args[i+method_param_offset] = lbValue {
+						wrapper_proc->raw_input_parameters[i+2],
+						method_type->Proc.params->Tuple.variables[i+method_param_offset]->type,
+					};
+				}
+				lbValue method_proc_value = lb_find_procedure_value_from_entity(m, md.proc_entity);
+
+				// Call real procedure for method from here, passing the parameters expected, if any.
+				lbValue return_value = lb_emit_call(wrapper_proc, method_proc_value, method_call_args);
+
+				if (wrapper_results_tuple != nullptr) {
+					auto &result_var = method_type->Proc.results->Tuple.variables[0];
+					return_value = lb_emit_conv(wrapper_proc, return_value, result_var->type);
+					lb_build_return_stmt_internal(wrapper_proc, return_value, result_var->token.pos);
+				}
+			}
+			lb_end_procedure_body(wrapper_proc);
+
+
+			// Add the method to the class
+			String method_encoding = str_lit("v");
+			// TODO (harold): Checker must ensure that objc_methods have a single return value or none!
+			GB_ASSERT(method_type->Proc.result_count <= 1);
+			if (method_type->Proc.result_count != 0) {
+				method_encoding = lb_get_objc_type_encoding(method_type->Proc.results->Tuple.variables[0]->type, temporary_allocator());
+			}
+
+			if (!md.ac.objc_is_class_method) {
+				method_encoding = concatenate_strings(temporary_allocator(), method_encoding, str_lit("@:"));
+			} else {
+				method_encoding = concatenate_strings(temporary_allocator(), method_encoding, str_lit("#:"));
+			}
+
+			for (i32 i = method_param_offset; i < method_param_count; i++) {
+				Type *param_type = method_type->Proc.params->Tuple.variables[i]->type;
+				String param_encoding = lb_get_objc_type_encoding(param_type, temporary_allocator());
+
+				method_encoding = concatenate_strings(temporary_allocator(), method_encoding, param_encoding);
+			}
+
+			// Emit method registration
+			lbAddr* sel_address = string_map_get(&m->objc_selectors, md.ac.objc_selector);
+			GB_ASSERT(sel_address);
+			lbValue selector_value = lb_addr_load(p, *sel_address);
+
+			args.count = 4;
+			args[0] = class_value;    // Class
+			args[1] = selector_value; // SEL
+			args[2] = lbValue { wrapper_proc->value, wrapper_proc->type };
+			args[3] = lb_const_value(m, t_cstring, exact_value_string(method_encoding));
+
+			// TODO(harold): Emit check BOOL result and panic if false.
+			lb_emit_runtime_call(p, "class_addMethod", args);
+
+		} // End methods
+
+		// Add ivar if we have one
+		if (ivar_type != nullptr) {
+			// Register a single ivar for this class
+			Type *ivar_base = ivar_type->Named.base;
+
+			const i64 size      = type_size_of(ivar_base);
+			const i64 alignment = type_align_of(ivar_base);
+			// TODO(harold): Checker: Alignment must be compatible with ivar rules. Or we should increase the alignment if needed.
+
+			// TODO(harold): Should we pass the actual type encoding? Might not be ideal for obfuscation.
+			String ivar_name  = str_lit("__$ivar");
+			String ivar_types = str_lit("{= }");	//lb_get_objc_type_encoding(ivar_type, temporary_allocator());// str_lit("{= }");
+			args.count = 5;
+			args[0] = class_value;
+			args[1] = lb_const_value(m, t_cstring, exact_value_string(ivar_name));
+			args[2] = lb_const_value(m, t_uint, exact_value_u64((u64)size));
+			args[3] = lb_const_value(m, t_u8, exact_value_u64((u64)alignment));
+			args[4] = lb_const_value(m, t_cstring, exact_value_string(ivar_types));
+			lb_emit_runtime_call(p, "class_addIvar", args);
+		}
+
+		// Complete the class registration
+		args.count = 1;
+		args[0] = class_value;
+		lb_emit_runtime_call(p, "objc_registerClassPair", args);
+	}
 
 	// Register ivar offsets for any `objc_ivar_get` expressions emitted.
 	Type *ptr_u32 = alloc_type_pointer(t_u32);