Merge pull request #5064 from harold-b/hb/objc-classes

Add support for Objective-C class implementation
2026-06-05 10:14:05 +00:00 · 2025-05-08 12:58:33 +01:00
parent 4a709086a4 14e25c0f2a
commit 92df892f25
15 changed files with 1186 additions and 89 deletions
--- a/base/intrinsics/intrinsics.odin
+++ b/base/intrinsics/intrinsics.odin
@@ -357,15 +357,18 @@ x86_xgetbv :: proc(cx: u32) -> (eax, edx: u32) ---
 objc_object   :: struct{}
 objc_selector :: struct{}
 objc_class    :: struct{}
+objc_ivar     :: struct{}
+
 objc_id    :: ^objc_object
 objc_SEL   :: ^objc_selector
 objc_Class :: ^objc_class
+objc_Ivar  :: ^objc_ivar

 objc_find_selector     :: proc($name: string) -> objc_SEL   ---
 objc_register_selector :: proc($name: string) -> objc_SEL   ---
 objc_find_class        :: proc($name: string) -> objc_Class ---
 objc_register_class    :: proc($name: string) -> objc_Class ---
-
+objc_ivar_get          :: proc(self: ^$T) -> ^$U ---

 valgrind_client_request :: proc(default: uintptr, request: uintptr, a0, a1, a2, a3, a4: uintptr) -> uintptr ---

--- a/base/runtime/procs_darwin.odin
+++ b/base/runtime/procs_darwin.odin
@@ -2,21 +2,34 @@
 package runtime

@(priority_index=-1e6)
-foreign import "system:Foundation.framework"
+foreign import ObjC "system:objc"

 import "base:intrinsics"

-objc_id :: ^intrinsics.objc_object
+objc_id    :: ^intrinsics.objc_object
 objc_Class :: ^intrinsics.objc_class
-objc_SEL :: ^intrinsics.objc_selector
+objc_SEL   :: ^intrinsics.objc_selector
+objc_Ivar  :: ^intrinsics.objc_ivar
+objc_BOOL  :: bool

-foreign Foundation {
-	objc_lookUpClass :: proc "c" (name: cstring) -> objc_Class ---
+
+objc_IMP :: proc "c" (object: objc_id, sel: objc_SEL, #c_vararg args: ..any) -> objc_id
+
+foreign ObjC {
 	sel_registerName :: proc "c" (name: cstring) -> objc_SEL ---
-	objc_allocateClassPair :: proc "c" (superclass: objc_Class, name: cstring, extraBytes: uint) -> objc_Class ---

 	objc_msgSend        :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) ---
 	objc_msgSend_fpret  :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> f64 ---
 	objc_msgSend_fp2ret :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> complex128 ---
 	objc_msgSend_stret  :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) ---
+
+	objc_lookUpClass          :: proc "c" (name: cstring) -> objc_Class ---
+	objc_allocateClassPair    :: proc "c" (superclass: objc_Class, name: cstring, extraBytes: uint) -> objc_Class ---
+	objc_registerClassPair    :: proc "c" (cls : objc_Class) ---
+	class_addMethod           :: proc "c" (cls: objc_Class, name: objc_SEL, imp: objc_IMP, types: cstring) -> objc_BOOL ---
+	class_addIvar             :: proc "c" (cls: objc_Class, name: cstring, size: uint, alignment: u8, types: cstring) -> objc_BOOL ---
+	class_getInstanceVariable :: proc "c" (cls : objc_Class, name: cstring) -> objc_Ivar ---
+	class_getInstanceSize     :: proc "c" (cls : objc_Class) -> uint ---
+	ivar_getOffset            :: proc "c" (v: objc_Ivar) -> uintptr ---
 }
+
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -223,9 +223,9 @@ gb_internal void add_objc_proc_type(CheckerContext *c, Ast *call, Type *return_t
 	data.kind = kind;
 	data.proc_type = alloc_type_proc(scope, params, param_types.count, results, results->Tuple.variables.count, false, ProcCC_CDecl);

-	mutex_lock(&c->info->objc_types_mutex);
+	mutex_lock(&c->info->objc_objc_msgSend_mutex);
 	map_set(&c->info->objc_msgSend_types, call, data);
-	mutex_unlock(&c->info->objc_types_mutex);
+	mutex_unlock(&c->info->objc_objc_msgSend_mutex);

 	try_to_add_package_dependency(c, "runtime", "objc_msgSend");
 	try_to_add_package_dependency(c, "runtime", "objc_msgSend_fpret");
@@ -387,6 +387,59 @@ gb_internal bool check_builtin_objc_procedure(CheckerContext *c, Operand *operan
 		try_to_add_package_dependency(c, "runtime", "objc_allocateClassPair");
 		return true;
 	} break;
+
+	case BuiltinProc_objc_ivar_get:
+	{
+		Type *self_type = nullptr;
+
+		Operand self = {};
+		check_expr_or_type(c, &self, ce->args[0]);
+
+		if (!is_operand_value(self) || !check_is_assignable_to(c, &self, t_objc_id)) {
+			gbString e = expr_to_string(self.expr);
+			gbString t = type_to_string(self.type);
+			error(self.expr, "'%.*s' expected a type or value derived from intrinsics.objc_object, got '%s' of type %s", LIT(builtin_name), e, t);
+			gb_string_free(t);
+			gb_string_free(e);
+			return false;
+		} else if (!is_type_pointer(self.type)) {
+			gbString e = expr_to_string(self.expr);
+			gbString t = type_to_string(self.type);
+			error(self.expr, "'%.*s' expected a pointer of a value derived from intrinsics.objc_object, got '%s' of type %s", LIT(builtin_name), e, t);
+			gb_string_free(t);
+			gb_string_free(e);
+			return false;
+		}
+
+		self_type = type_deref(self.type);
+
+		if (!(self_type->kind == Type_Named &&
+			self_type->Named.type_name != nullptr &&
+			self_type->Named.type_name->TypeName.objc_class_name != "")) {
+			gbString t = type_to_string(self_type);
+			error(self.expr, "'%.*s' expected a named type with the attribute @(objc_class=<string>) , got type %s", LIT(builtin_name), t);
+			gb_string_free(t);
+			return false;
+		}
+
+		Type *ivar_type = self_type->Named.type_name->TypeName.objc_ivar;
+		if (ivar_type == nullptr) {
+			gbString t = type_to_string(self_type);
+			error(self.expr, "'%.*s' requires that type %s have the attribute @(objc_ivar=<ivar_type_name>).", LIT(builtin_name), t);
+			gb_string_free(t);
+			return false;
+		}
+
+		if (type_hint != nullptr && type_hint->kind == Type_Pointer && type_hint->Pointer.elem == ivar_type) {
+			operand->type = type_hint;
+		} else {
+			operand->type = alloc_type_pointer(ivar_type);
+		}
+
+		operand->mode = Addressing_Value;
+		return true;
+
+	} break;
 	}
 }

@@ -2167,7 +2220,8 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
 	case BuiltinProc_objc_find_selector: 
 	case BuiltinProc_objc_find_class: 
 	case BuiltinProc_objc_register_selector: 
-	case BuiltinProc_objc_register_class: 
+	case BuiltinProc_objc_register_class:
+	case BuiltinProc_objc_ivar_get:
 		return check_builtin_objc_procedure(c, operand, call, id, type_hint);

 	case BuiltinProc___entry_point:
--- a/src/check_decl.cpp
+++ b/src/check_decl.cpp
@@ -524,12 +524,90 @@ gb_internal void check_type_decl(CheckerContext *ctx, Entity *e, Ast *init_expr,
 	if (decl != nullptr) {
 		AttributeContext ac = {};
 		check_decl_attributes(ctx, decl->attributes, type_decl_attribute, &ac);
+
 		if (e->kind == Entity_TypeName && ac.objc_class != "") {
+
 			e->TypeName.objc_class_name = ac.objc_class;

+			if (ac.objc_is_implementation) {
+				e->TypeName.objc_is_implementation = ac.objc_is_implementation;
+				e->TypeName.objc_superclass        = ac.objc_superclass;
+				e->TypeName.objc_ivar              = ac.objc_ivar;
+				e->TypeName.objc_context_provider  = ac.objc_context_provider;
+
+				mutex_lock(&ctx->info->objc_class_name_mutex);
+				bool class_exists = string_set_update(&ctx->info->obcj_class_name_set, ac.objc_class);
+				mutex_unlock(&ctx->info->objc_class_name_mutex);
+				if (class_exists) {
+					error(e->token, "@(objc_class) name '%.*s' has already been used elsewhere", LIT(ac.objc_class));
+				}
+
+				mpsc_enqueue(&ctx->info->objc_class_implementations, e);
+
+				GB_ASSERT(e->TypeName.objc_ivar == nullptr || e->TypeName.objc_ivar->kind == Type_Named);
+
+				// Enqueue the contex_provider proc to be checked after it is resolved
+				if (e->TypeName.objc_context_provider != nullptr) {
+					mpsc_enqueue(&ctx->checker->procs_with_objc_context_provider_to_check, e);
+				}
+
+				// TODO(harold): I think there's a Check elsewhere in the checker for checking cycles.
+				//					See about moving this to the right location.
+				// Ensure superclass hierarchy are all Objective-C classes and does not cycle
+
+				// NOTE(harold): We check for superclass unconditionally (before checking if super is null)
+				//				 because this should be the case 99.99% of the time. Not subclassing something that
+				//				 is, or is the child of, NSObject means the objc runtime messaging will not properly work on this type.
+				TypeSet super_set{};
+				type_set_init(&super_set, 8);
+				defer (type_set_destroy(&super_set));
+
+				type_set_update(&super_set, e->type);
+
+				Type *super = ac.objc_superclass;
+				while (super != nullptr) {
+					if (type_set_update(&super_set, super)) {
+						error(e->token, "@(objc_superclass) Superclass hierarchy cycle encountered");
+						break;
+					}
+
+					check_single_global_entity(ctx->checker, super->Named.type_name, super->Named.type_name->decl_info);
+
+					if (super->kind != Type_Named) {
+						error(e->token, "@(objc_superclass) Referenced type must be a named struct");
+						break;
+					}
+
+					Type* named_type = base_named_type(super);
+					GB_ASSERT(named_type->kind == Type_Named);
+
+					if (!is_type_objc_object(named_type)) {
+						error(e->token, "@(objc_superclass) Superclass '%.*s' must be an Objective-C class", LIT(named_type->Named.name));
+						break;
+					}
+
+					if (named_type->Named.type_name->TypeName.objc_class_name == "") {
+						error(e->token, "@(objc_superclass) Superclass '%.*s' must have a valid @(objc_class) attribute", LIT(named_type->Named.name));
+						break;
+					}
+
+					super = named_type->Named.type_name->TypeName.objc_superclass;
+				}
+			} else {
+				if (ac.objc_superclass != nullptr) {
+					error(e->token, "@(objc_superclass) may only be applied when the @(obj_implement) attribute is also applied");
+				} else if (ac.objc_ivar != nullptr) {
+					error(e->token, "@(objc_ivar) may only be applied when the @(obj_implement) attribute is also applied");
+				} else if (ac.objc_context_provider != nullptr) {
+					error(e->token, "@(objc_context_provider) may only be applied when the @(obj_implement) attribute is also applied");
+				}
+			}
+
 			if (type_size_of(e->type) > 0) {
 				error(e->token, "@(objc_class) marked type must be of zero size");
 			}
+		} else if (ac.objc_is_implementation) {
+			error(e->token, "@(objc_implement) may only be applied when the @(objc_class) attribute is also applied");
 		}
 	}

@@ -922,7 +1000,7 @@ gb_internal String handle_link_name(CheckerContext *ctx, Token token, String lin
 }


-gb_internal void check_objc_methods(CheckerContext *ctx, Entity *e, AttributeContext const &ac) {
+gb_internal void check_objc_methods(CheckerContext *ctx, Entity *e, AttributeContext &ac) {
 	if (!(ac.objc_name.len || ac.objc_is_class_method || ac.objc_type)) {
 		return;
 	}
@@ -934,48 +1012,107 @@ gb_internal void check_objc_methods(CheckerContext *ctx, Entity *e, AttributeCon
 		error(e->token, "@(objc_name) is required with @(objc_type)");
 	} else {
 		Type *t = ac.objc_type;
-		if (t->kind == Type_Named) {
-			Entity *tn = t->Named.type_name;

-			GB_ASSERT(tn->kind == Entity_TypeName);
+		GB_ASSERT(t->kind == Type_Named);	// NOTE(harold): This is already checked for at the attribute resolution stage.
+		Entity *tn = t->Named.type_name;

-			if (tn->scope != e->scope) {
-				error(e->token, "@(objc_name) attribute may only be applied to procedures and types within the same scope");
-			} else {
-				mutex_lock(&global_type_name_objc_metadata_mutex);
-				defer (mutex_unlock(&global_type_name_objc_metadata_mutex));
+		GB_ASSERT(tn->kind == Entity_TypeName);

-				if (!tn->TypeName.objc_metadata) {
-					tn->TypeName.objc_metadata = create_type_name_obj_c_metadata();
-				}
-				auto *md = tn->TypeName.objc_metadata;
-				mutex_lock(md->mutex);
-				defer (mutex_unlock(md->mutex));
+		if (tn->scope != e->scope) {
+			error(e->token, "@(objc_name) attribute may only be applied to procedures and types within the same scope");
+		} else {

-				if (!ac.objc_is_class_method) {
-					bool ok = true;
-					for (TypeNameObjCMetadataEntry const &entry : md->value_entries) {
-						if (entry.name == ac.objc_name) {
-							error(e->token, "Previous declaration of @(objc_name=\"%.*s\")", LIT(ac.objc_name));
-							ok = false;
-							break;
-						}
-					}
-					if (ok) {
-						array_add(&md->value_entries, TypeNameObjCMetadataEntry{ac.objc_name, e});
-					}
+			// Enable implementation by default if the class is an implementer too and
+			// @objc_implement was not set to false explicitly in this proc.
+			bool implement = tn->TypeName.objc_is_implementation;
+			if (ac.objc_is_disabled_implement) {
+				implement = false;
+			}
+
+			if (implement) {
+				GB_ASSERT(e->kind == Entity_Procedure);
+
+				auto &proc = e->type->Proc;
+				Type *first_param = proc.param_count > 0 ? proc.params->Tuple.variables[0]->type : t_untyped_nil;
+
+				if (!tn->TypeName.objc_is_implementation) {
+					error(e->token, "@(objc_is_implement) attribute may only be applied to procedures whose class also have @(objc_is_implement) applied");
+				} else if (!ac.objc_is_class_method && !(first_param->kind == Type_Pointer && internal_check_is_assignable_to(t, first_param->Pointer.elem))) {
+					error(e->token, "Objective-C instance methods implementations require the first parameter to be a pointer to the class type set by @(objc_type)");
+				} else if (proc.calling_convention == ProcCC_Odin && !tn->TypeName.objc_context_provider) {
+					error(e->token, "Objective-C methods with Odin calling convention can only be used with classes that have @(objc_context_provider) set");
+				} else if (ac.objc_is_class_method && proc.calling_convention != ProcCC_CDecl) {
+					error(e->token, "Objective-C class methods (objc_is_class_method=true) that have @objc_is_implementation can only use \"c\" calling convention");
+				} else if (proc.result_count > 1) {
+					error(e->token, "Objective-C method implementations may return at most 1 value");
 				} else {
-					bool ok = true;
-					for (TypeNameObjCMetadataEntry const &entry : md->type_entries) {
-						if (entry.name == ac.objc_name) {
-							error(e->token, "Previous declaration of @(objc_name=\"%.*s\")", LIT(ac.objc_name));
-							ok = false;
-							break;
-						}
+					// Always export unconditionally
+					// NOTE(harold): This means check_objc_methods() MUST be called before
+					//				 e->Procedure.is_export is set in check_proc_decl()!
+					if (ac.is_export) {
+						error(e->token, "Explicit export not allowed when @(objc_implement) is set. It set exported implicitly");
 					}
-					if (ok) {
-						array_add(&md->type_entries, TypeNameObjCMetadataEntry{ac.objc_name, e});
+					if (ac.link_name != "") {
+						error(e->token, "Explicit linkage not allowed when @(objc_implement) is set. It set to \"strong\" implicitly");
 					}
+
+					ac.is_export = true;
+					ac.linkage   = STR_LIT("strong");
+
+					auto method = ObjcMethodData{ ac, e };
+					method.ac.objc_selector = ac.objc_selector != "" ? ac.objc_selector : ac.objc_name;
+
+					CheckerInfo *info = ctx->info;
+					mutex_lock(&info->objc_method_mutex);
+					defer (mutex_unlock(&info->objc_method_mutex));
+
+					Array<ObjcMethodData>* method_list = map_get(&info->objc_method_implementations, t);
+					if (method_list) {
+						array_add(method_list, method);
+					} else {
+						auto list = array_make<ObjcMethodData>(permanent_allocator(), 1, 8);
+						list[0] = method;
+
+						map_set(&info->objc_method_implementations, t, list);
+					}
+				}
+			} else if (ac.objc_selector != "") {
+				error(e->token, "@(objc_selector) may only be applied to procedures that are Objective-C implementations.");
+			}
+
+			mutex_lock(&global_type_name_objc_metadata_mutex);
+			defer (mutex_unlock(&global_type_name_objc_metadata_mutex));
+
+			if (!tn->TypeName.objc_metadata) {
+				tn->TypeName.objc_metadata = create_type_name_obj_c_metadata();
+			}
+			auto *md = tn->TypeName.objc_metadata;
+			mutex_lock(md->mutex);
+			defer (mutex_unlock(md->mutex));
+
+			if (!ac.objc_is_class_method) {
+				bool ok = true;
+				for (TypeNameObjCMetadataEntry const &entry : md->value_entries) {
+					if (entry.name == ac.objc_name) {
+						error(e->token, "Previous declaration of @(objc_name=\"%.*s\")", LIT(ac.objc_name));
+						ok = false;
+						break;
+					}
+				}
+				if (ok) {
+					array_add(&md->value_entries, TypeNameObjCMetadataEntry{ac.objc_name, e});
+				}
+			} else {
+				bool ok = true;
+				for (TypeNameObjCMetadataEntry const &entry : md->type_entries) {
+					if (entry.name == ac.objc_name) {
+						error(e->token, "Previous declaration of @(objc_name=\"%.*s\")", LIT(ac.objc_name));
+						ok = false;
+						break;
+					}
+				}
+				if (ok) {
+					array_add(&md->type_entries, TypeNameObjCMetadataEntry{ac.objc_name, e});
 				}
 			}
 		}
@@ -1145,6 +1282,9 @@ gb_internal void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) {
 		break;
 	}

+	// NOTE(harold): For Objective-C method implementations, this must happen after
+	//				 check_objc_methods() is called as it re-sets ac.is_export to true unconditionally.
+	//				 The same is true for the linkage, set below.
 	e->Procedure.entry_point_only = ac.entry_point_only;
 	e->Procedure.is_export = ac.is_export;

@@ -1245,6 +1385,7 @@ gb_internal void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) {
 		}
 	}

+	// NOTE(harold): See export/linkage note above(where is_export is assigned) regarding Objective-C method implementations
 	bool is_foreign = e->Procedure.is_foreign;
 	bool is_export  = e->Procedure.is_export;
 	
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -1351,10 +1351,12 @@ gb_internal void init_universal(void) {
 		t_objc_object   = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_object"),   alloc_type_struct_complete());
 		t_objc_selector = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_selector"), alloc_type_struct_complete());
 		t_objc_class    = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_class"),    alloc_type_struct_complete());
+		t_objc_ivar     = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_ivar"),     alloc_type_struct_complete());

 		t_objc_id       = alloc_type_pointer(t_objc_object);
 		t_objc_SEL      = alloc_type_pointer(t_objc_selector);
 		t_objc_Class    = alloc_type_pointer(t_objc_class);
+		t_objc_Ivar     = alloc_type_pointer(t_objc_ivar);
 	}
 }

@@ -1387,6 +1389,10 @@ gb_internal void init_checker_info(CheckerInfo *i) {
 	array_init(&i->defineables, a);

 	map_init(&i->objc_msgSend_types);
+	mpsc_init(&i->objc_class_implementations, a);
+	string_set_init(&i->obcj_class_name_set, 0);
+	map_init(&i->objc_method_implementations);
+
 	string_map_init(&i->load_file_cache);
 	array_init(&i->all_procedures, heap_allocator());

@@ -1497,6 +1503,8 @@ gb_internal void init_checker(Checker *c) {

 	TIME_SECTION("init proc queues");
 	mpsc_init(&c->procs_with_deferred_to_check, a); //, 1<<10);
+	mpsc_init(&c->procs_with_objc_context_provider_to_check, a);
+

 	// NOTE(bill): 1 Mi elements should be enough on average
 	array_init(&c->procs_to_check, heap_allocator(), 0, 1<<20);
@@ -3662,6 +3670,33 @@ gb_internal DECL_ATTRIBUTE_PROC(proc_decl_attribute) {
 			}
 		}
 		return true;
+	} else if (name == "objc_implement") {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind == ExactValue_Bool) {
+			ac->objc_is_implementation = ev.value_bool;
+
+			if (!ac->objc_is_implementation) {
+				ac->objc_is_disabled_implement = true;
+			}
+		} else if (ev.kind == ExactValue_Invalid) {
+			ac->objc_is_implementation = true;
+		} else {
+			error(elem, "Expected a boolean value, or no value, for '%.*s'", LIT(name));
+		}
+
+		return true;
+	} else if (name == "objc_selector") {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind == ExactValue_String) {
+			if (string_is_valid_identifier(ev.value_string)) {
+				ac->objc_selector = ev.value_string;
+			} else {
+				error(elem, "Invalid identifier for '%.*s', got '%.*s'", LIT(name), LIT(ev.value_string));
+			}
+		} else {
+			error(elem, "Expected a string value for '%.*s'", LIT(name));
+		}
+		return true;
 	} else if (name == "require_target_feature") {
 		ExactValue ev = check_decl_attribute_value(c, value);
 		if (ev.kind == ExactValue_String) {
@@ -3907,6 +3942,51 @@ gb_internal DECL_ATTRIBUTE_PROC(type_decl_attribute) {
 			ac->objc_class = ev.value_string;
 		}
 		return true;
+	} else if (name == "objc_implement") {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind == ExactValue_Bool) {
+			ac->objc_is_implementation = ev.value_bool;
+		} else if (ev.kind == ExactValue_Invalid) {
+			ac->objc_is_implementation = true;
+		} else {
+			error(elem, "Expected a boolean value, or no value, for '%.*s'", LIT(name));
+		}
+		return true;
+	} else if (name == "objc_superclass") {
+		Type *objc_superclass = check_type(c, value);
+
+		if (objc_superclass != nullptr) {
+			ac->objc_superclass = objc_superclass;
+		} else {
+			error(value, "'%.*s' expected a named type", LIT(name));
+		}
+		return true;
+	} else if (name == "objc_ivar") {
+		Type *objc_ivar = check_type(c, value);
+
+		if (objc_ivar != nullptr && objc_ivar->kind == Type_Named) {
+			ac->objc_ivar = objc_ivar;
+		} else {
+			error(value, "'%.*s' expected a named type", LIT(name));
+		}
+		return true;
+	} else if (name == "objc_context_provider") {
+		Operand o = {};
+		check_expr(c, &o, value);
+		Entity *e = entity_of_node(o.expr);
+
+		if (e != nullptr) {
+			if (ac->objc_context_provider != nullptr) {
+				error(elem, "Previous usage of a 'objc_context_provider' attribute");
+			}
+			if (e->kind != Entity_Procedure) {
+				error(elem, "'objc_context_provider' must refer to a procedure");
+			} else {
+				ac->objc_context_provider = e;
+			}
+
+			return true;
+		}
 	}
 	return false;
 }
@@ -6395,6 +6475,44 @@ gb_internal void check_deferred_procedures(Checker *c) {

 }

+gb_internal void check_objc_context_provider_procedures(Checker *c) {
+	for (Entity *e = nullptr; mpsc_dequeue(&c->procs_with_objc_context_provider_to_check, &e); /**/) {
+		GB_ASSERT(e->kind == Entity_TypeName);
+
+		Entity *proc_entity = e->TypeName.objc_context_provider;
+		GB_ASSERT(proc_entity->kind == Entity_Procedure);
+
+		auto &proc = proc_entity->type->Proc;
+
+		Type *return_type = proc.result_count != 1 ? t_untyped_nil : base_named_type(proc.results->Tuple.variables[0]->type);
+		if (return_type != t_context) {
+			error(proc_entity->token, "The @(objc_context_provider) procedure must only return a context.");
+		}
+
+		const char *self_param_err = "The @(objc_context_provider) procedure must take as a parameter a single pointer to the @(objc_type) value.";
+		if (proc.param_count != 1) {
+			error(proc_entity->token, self_param_err);
+		}
+
+		Type *self_param = base_type(proc.params->Tuple.variables[0]->type);
+		if (self_param->kind != Type_Pointer) {
+			error(proc_entity->token, self_param_err);
+		}
+
+		Type *self_type = base_named_type(self_param->Pointer.elem);
+		if (!internal_check_is_assignable_to(self_type, e->type) &&
+			!(e->TypeName.objc_ivar && internal_check_is_assignable_to(self_type, e->TypeName.objc_ivar))) {
+			error(proc_entity->token, self_param_err);
+		}
+		if (proc.calling_convention != ProcCC_CDecl && proc.calling_convention != ProcCC_Contextless) {
+			error(e->token, self_param_err);
+		}
+		if (proc.is_polymorphic) {
+			error(e->token, self_param_err);
+		}
+	}
+}
+
 gb_internal void check_unique_package_names(Checker *c) {
 	ERROR_BLOCK();

@@ -6555,6 +6673,7 @@ gb_internal void check_update_dependency_tree_for_procedures(Checker *c) {
 	}
 }

+
 gb_internal void check_parsed_files(Checker *c) {
 	TIME_SECTION("map full filepaths to scope");
 	add_type_info_type(&c->builtin_ctx, t_invalid);
@@ -6664,6 +6783,9 @@ gb_internal void check_parsed_files(Checker *c) {
 	TIME_SECTION("check deferred procedures");
 	check_deferred_procedures(c);

+	TIME_SECTION("check objc context provider procedures");
+	check_objc_context_provider_procedures(c);
+
 	TIME_SECTION("calculate global init order");
 	calculate_global_init_order(c);

--- a/src/checker.hpp
+++ b/src/checker.hpp
@@ -149,8 +149,14 @@ struct AttributeContext {

 	String  objc_class;
 	String  objc_name;
-	bool    objc_is_class_method;
+	String  objc_selector;
 	Type *  objc_type;
+	Type *  objc_superclass;
+	Type *  objc_ivar;
+	Entity *objc_context_provider;
+	bool    objc_is_class_method;
+	bool    objc_is_implementation;     // This struct or proc provides a class/method implementation, not a binding to an existing type.
+	bool    objc_is_disabled_implement; // This means the method explicitly set @objc_implement to false so it won't be inferred from the class' attribute.

 	String require_target_feature; // required by the target micro-architecture
 	String enable_target_feature;  // will be enabled for the procedure only
@@ -366,6 +372,11 @@ struct ObjcMsgData {
 	Type *proc_type;
 };

+struct ObjcMethodData {
+	AttributeContext ac;
+	Entity *proc_entity;
+};
+
 enum LoadFileTier {
 	LoadFileTier_Invalid,
 	LoadFileTier_Exists,
@@ -477,9 +488,17 @@ struct CheckerInfo {

 	MPSCQueue<Ast *> intrinsics_entry_point_usage;

-	BlockingMutex objc_types_mutex;
+	BlockingMutex objc_objc_msgSend_mutex;
 	PtrMap<Ast *, ObjcMsgData> objc_msgSend_types;

+	BlockingMutex objc_class_name_mutex;
+	StringSet obcj_class_name_set;
+	MPSCQueue<Entity *> objc_class_implementations;
+
+	BlockingMutex objc_method_mutex;
+	PtrMap<Type *, Array<ObjcMethodData>> objc_method_implementations;
+
+
 	BlockingMutex load_file_mutex;
 	StringMap<LoadFileCache *> load_file_cache;

@@ -556,6 +575,7 @@ struct Checker {
 	CheckerContext builtin_ctx;

 	MPSCQueue<Entity *> procs_with_deferred_to_check;
+	MPSCQueue<Entity *> procs_with_objc_context_provider_to_check;
 	Array<ProcInfo *> procs_to_check;

 	BlockingMutex nested_proc_lits_mutex;
--- a/src/checker_builtin_procs.hpp
+++ b/src/checker_builtin_procs.hpp
@@ -338,6 +338,7 @@ BuiltinProc__type_end,
 	BuiltinProc_objc_find_class,
 	BuiltinProc_objc_register_selector,
 	BuiltinProc_objc_register_class,
+	BuiltinProc_objc_ivar_get,

 	BuiltinProc_constant_utf16_cstring,

@@ -686,6 +687,7 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
 	{STR_LIT("objc_find_class"),        1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("objc_register_selector"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics, false, true},
 	{STR_LIT("objc_register_class"),    1, false, Expr_Expr, BuiltinProcPkg_intrinsics, false, true},
+	{STR_LIT("objc_ivar_get"),          1, false, Expr_Expr, BuiltinProcPkg_intrinsics, false, true},

 	{STR_LIT("constant_utf16_cstring"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics},

--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -235,6 +235,10 @@ struct Entity {
 			Type * type_parameter_specialization;
 			String ir_mangled_name;
 			bool   is_type_alias;
+			bool   objc_is_implementation;
+			Type*  objc_superclass;
+			Type*  objc_ivar;
+			Entity*objc_context_provider;
 			String objc_class_name;
 			TypeNameObjCMetadata *objc_metadata;
 		} TypeName;
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -1173,6 +1173,344 @@ gb_internal lbProcedure *lb_create_objc_names(lbModule *main_module) {
 	return p;
 }

+String lb_get_objc_type_encoding(Type *t, 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.int_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");
+
+		case Basic_complex32:		return str_lit("{complex32=ss}");	// No f16 encoding, so fallback to i16, as above in Basic_f16*
+		case Basic_complex64:		return str_lit("{complex64=ff}");
+		case Basic_complex128:		return str_lit("{complex128=dd}");
+		case Basic_quaternion64:    return str_lit("{quaternion64=ssss}");
+		case Basic_quaternion128:   return str_lit("{quaternion128=ffff}");
+		case Basic_quaternion256:   return str_lit("{quaternion256=dddd}");
+
+		case Basic_int:
+			return str_lit(INT_SIZE_ENCODING);
+		case Basic_uint:
+			return build_context.metrics.int_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.int_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, 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(temporary_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, pointer_depth);
+					s = gb_string_append_length(s, field_type.text, field_type.len);
+				}
+			} else {
+				for( auto& v : base->Union.variants ) {
+					String variant_type = lb_get_objc_type_encoding(v, pointer_depth);
+					s = gb_string_append_length(s, variant_type.text, variant_type.len);
+				}
+			}
+		}
+
+		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, pointer_depth +1);
+		// Special case for Objective-C Objects
+		if (pointer_depth == 0 && pointee == "@") {
+			return pointee;
+		}
+
+		return concatenate_strings(temporary_allocator(), str_lit("^"), pointee);
+	}
+
+	case Type_MultiPointer:
+		return concatenate_strings(temporary_allocator(), str_lit("^"), lb_get_objc_type_encoding(t->Pointer.elem, pointer_depth +1));
+
+	case Type_Array: {
+		String type_str = lb_get_objc_type_encoding(t->Array.elem, pointer_depth);
+
+		gbString s = gb_string_make_reserve(temporary_allocator(), type_str.len + 8);
+		s = gb_string_append_fmt(s, "[%lld%.*s]", t->Array.count, LIT(type_str));
+		return make_string_c(s);
+	}
+
+	case Type_EnumeratedArray: {
+		String type_str = lb_get_objc_type_encoding(t->EnumeratedArray.elem, pointer_depth);
+
+		gbString s = gb_string_make_reserve(temporary_allocator(), type_str.len + 8);
+		s = gb_string_append_fmt(s, "[%lld%.*s]", t->EnumeratedArray.count, LIT(type_str));
+		return make_string_c(s);
+	}
+
+	case Type_Slice: {
+		String type_str = lb_get_objc_type_encoding(t->Slice.elem, pointer_depth);
+		gbString s = gb_string_make_reserve(temporary_allocator(), type_str.len + 8);
+		s = gb_string_append_fmt(s, "{slice=^%.*s%s}", LIT(type_str), INT_SIZE_ENCODING);
+		return make_string_c(s);
+	}
+
+	case Type_DynamicArray: {
+		String type_str = lb_get_objc_type_encoding(t->DynamicArray.elem, pointer_depth);
+		gbString s = gb_string_make_reserve(temporary_allocator(), type_str.len + 8);
+		s = gb_string_append_fmt(s, "{dynamic=^%.*s%s%sAllocator={?^v}}", LIT(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, pointer_depth);
+	case Type_Tuple:
+		// NOTE(harold): Is this type allowed here?
+		return str_lit("?");
+	case Type_Proc:
+		return str_lit("?");
+	case Type_BitSet:
+		return lb_get_objc_type_encoding(t->BitSet.underlying, pointer_depth);
+
+	case Type_SimdVector: {
+		String type_str = lb_get_objc_type_encoding(t->SimdVector.elem, pointer_depth);
+		gbString s = gb_string_make_reserve(temporary_allocator(), type_str.len + 5);
+		gb_string_append_fmt(s, "[%lld%.*s]", t->SimdVector.count, LIT(type_str));
+		return make_string_c(s);
+	}
+
+	case Type_Matrix: {
+		String type_str = lb_get_objc_type_encoding(t->Matrix.elem, pointer_depth);
+		gbString s = gb_string_make_reserve(temporary_allocator(), type_str.len + 5);
+		i64 element_count = t->Matrix.column_count * t->Matrix.row_count;
+		gb_string_append_fmt(s, "[%lld%.*s]", element_count, LIT(type_str));
+		return make_string_c(s);
+	}
+
+	case Type_BitField:
+		return lb_get_objc_type_encoding(t->BitField.backing_type, pointer_depth);
+	case Type_SoaPointer: {
+		gbString s = gb_string_make_reserve(temporary_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");
+	return str_lit("");
+}
+
+struct lbObjCGlobalClass {
+	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
+) {
+	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 = lb_const_nil(m, t_objc_Class);
+
+		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_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) {
 	if (p == nullptr) {
 		return;
@@ -1186,38 +1524,329 @@ gb_internal void lb_finalize_objc_names(lbGenerator *gen, lbProcedure *p) {
 	string_set_init(&handled);
 	defer (string_set_destroy(&handled));

-	auto args = array_make<lbValue>(temporary_allocator(), 1);
+	auto args        = array_make<lbValue>(temporary_allocator(), 3, 8);
+	auto class_impls = array_make<lbObjCGlobalClass>(temporary_allocator(), 0, 16);
+
+	// Register all class implementations unconditionally, even if not statically referenced
+	for (Entity *e = {}; mpsc_dequeue(&gen->info->objc_class_implementations, &e); /**/) {
+		GB_ASSERT(e->kind == Entity_TypeName && e->TypeName.objc_is_implementation);
+		lb_handle_objc_find_or_register_class(p, e->TypeName.objc_class_name, e->type);
+	}
+
+	// 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
+	// require their superclasses to be 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);

-	auto register_thing = [&handled, &m, &args](lbProcedure *p, lbObjCGlobal const &g, char const *call) {
-		if (!string_set_update(&handled, g.name)) {
-			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));
-			}
-
-			args[0] = lb_const_value(m, t_cstring, exact_value_string(g.name));
-			lbValue ptr = lb_emit_runtime_call(p, call, args);
-			lb_addr_store(p, addr, ptr);
-		}
-	};
-
-	for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_classes, &g); /**/) {
-		register_thing(p, g, "objc_lookUpClass");
+	// 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); /**/) {
-		register_thing(p, g, "sel_registerName");
+		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);
+
+
+	PtrMap<Type *, lbObjCGlobal> ivar_map{};
+	map_init(&ivar_map, gen->objc_ivars.count);
+
+	for (lbObjCGlobal g = {}; mpsc_dequeue(&gen->objc_ivars, &g); /**/) {
+		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;
+
+		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{};
+
+		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));
+
+			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;
+		}
+
+		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);
+
+			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;
+
+			isize method_param_count  = method_type->Proc.param_count;
+			isize method_param_offset = 0;
+
+			if (!md.ac.objc_is_class_method) {
+				GB_ASSERT(method_param_count >= 1);
+				method_param_count -= 1;
+				method_param_offset = 1;
+			}
+
+			for (isize 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_results_tuple = nullptr;
+
+			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);
+
+			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 wrapper
+			LLVMSetLinkage(wrapper_proc->value, LLVMExternalLinkage);
+			lb_begin_procedure_body(wrapper_proc);
+			{
+				if (method_type->Proc.calling_convention == ProcCC_Odin) {
+					GB_ASSERT(context_provider);
+
+					// 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 objc_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 + 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);
+			}
+
+			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 (isize 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);
+
+				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;
+
+			// @note(harold): The alignment is supposed to be passed as log2(alignment): https://developer.apple.com/documentation/objectivec/class_addivar(_:_:_:_:_:)?language=objc
+			const i64 size      = type_size_of(ivar_base);
+			const i64 alignment = (i64)floor_log2((u64)type_align_of(ivar_base));
+
+			// NOTE(harold): I've opted to not emit the type encoding for ivars in order to keep the data private.
+			//               If there is desire in the future to emit the type encoding for introspection through the Obj-C runtime,
+			//               then perhaps an option can be added for it then.
+			// 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);
+			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.
+	for (auto const& kv : ivar_map) {
+		lbObjCGlobal const& g = kv.value;
+		lbAddr ivar_addr = {};
+		lbValue *found = string_map_get(&m->members, g.global_name);
+
+		if (found) {
+			ivar_addr = lb_addr(*found);
+			GB_ASSERT(ivar_addr.addr.type == t_int_ptr);
+		} else {
+			// Defined in an external package, define it now in the main package
+			LLVMTypeRef t = lb_type(m, t_int);
+
+			lbValue global{};
+			global.value = LLVMAddGlobal(m->mod, t, g.global_name);
+			global.type  = t_int_ptr;
+
+			LLVMSetInitializer(global.value, LLVMConstInt(t, 0, true));
+
+			ivar_addr = lb_addr(global);
+		}
+
+		String class_name = g.class_impl_type->Named.type_name->TypeName.objc_class_name;
+		lbValue class_value = string_map_must_get(&global_class_map, class_name).class_value;
+
+		args.count = 2;
+		args[0] = class_value;
+		args[1] = lb_const_value(m, t_cstring, exact_value_string(str_lit("__$ivar")));
+		lbValue ivar = lb_emit_runtime_call(p, "class_getInstanceVariable", args);
+
+		args.count = 1;
+		args[0] = ivar;
+		lbValue ivar_offset     = lb_emit_runtime_call(p, "ivar_getOffset", args);
+		lbValue ivar_offset_int = lb_emit_conv(p, ivar_offset, t_int);
+
+		lb_addr_store(p, ivar_addr, ivar_offset_int);
 	}

 	lb_end_procedure_body(p);
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -196,6 +196,7 @@ struct lbModule {

 	StringMap<lbAddr> objc_classes;
 	StringMap<lbAddr> objc_selectors;
+	StringMap<lbAddr> objc_ivars;

 	PtrMap<u64/*type hash*/, lbAddr> map_cell_info_map; // address of runtime.Map_Info
 	PtrMap<u64/*type hash*/, lbAddr> map_info_map;      // address of runtime.Map_Cell_Info
@@ -219,6 +220,7 @@ struct lbObjCGlobal {
 	gbString  global_name;
 	String    name;
 	Type *    type;
+	Type *    class_impl_type;  // This is set when the class has the objc_implement attribute set to true.
 };

 struct lbGenerator : LinkerData {
@@ -240,6 +242,7 @@ struct lbGenerator : LinkerData {
 	MPSCQueue<lbEntityCorrection> entities_to_correct_linkage;
 	MPSCQueue<lbObjCGlobal> objc_selectors;
 	MPSCQueue<lbObjCGlobal> objc_classes;
+	MPSCQueue<lbObjCGlobal> objc_ivars;
 };


--- a/src/llvm_backend_expr.cpp
+++ b/src/llvm_backend_expr.cpp
@@ -5154,8 +5154,6 @@ gb_internal lbAddr lb_build_addr_internal(lbProcedure *p, Ast *expr) {
 				return lb_build_addr(p, unparen_expr(se->selector));
 			}

-
-			Type *type = base_type(tav.type);
 			if (tav.mode == Addressing_Type) { // Addressing_Type
 				Selection sel = lookup_field(tav.type, selector, true);
 				if (sel.pseudo_field) {
@@ -5190,18 +5188,29 @@ gb_internal lbAddr lb_build_addr_internal(lbProcedure *p, Ast *expr) {
 				return lb_addr_swizzle(a, type, swizzle_count, swizzle_indices);
 			}

-			Selection sel = lookup_field(type, selector, false);
+			Selection sel = lookup_field(tav.type, selector, false);
 			GB_ASSERT(sel.entity != nullptr);
-			if (sel.pseudo_field) {
-				GB_ASSERT(sel.entity->kind == Entity_Procedure || sel.entity->kind == Entity_ProcGroup);
+			if (sel.pseudo_field && (sel.entity->kind == Entity_Procedure || sel.entity->kind == Entity_ProcGroup)) {
 				Entity *e = entity_of_node(sel_node);
 				GB_ASSERT(e->kind == Entity_Procedure);
 				return lb_addr(lb_find_value_from_entity(p->module, e));
 			}

-			if (sel.is_bit_field) {
-				lbAddr addr = lb_build_addr(p, se->expr);
+			lbAddr addr = lb_build_addr(p, se->expr);

+			// NOTE(harold): Only allow ivar pseudo field access on indirect selectors.
+			//				 It is incoherent otherwise as Objective-C objects are zero-sized.
+			Type *deref_type = type_deref(tav.type);
+			if (tav.type->kind == Type_Pointer && deref_type->kind == Type_Named && deref_type->Named.type_name->TypeName.objc_ivar) {
+				// NOTE(harold): We need to load the ivar from the current address and
+				//				 replace addr with the loaded ivar addr to apply the selector load properly.
+				addr = lb_addr(lb_emit_load(p, addr.addr));
+
+				lbValue ivar_ptr = lb_handle_objc_ivar_for_objc_object_pointer(p, addr.addr);
+				addr = lb_addr(ivar_ptr);
+			}
+
+			if (sel.is_bit_field) {
 				Selection sub_sel = sel;
 				sub_sel.index.count -= 1;

@@ -5227,7 +5236,6 @@ gb_internal lbAddr lb_build_addr_internal(lbProcedure *p, Ast *expr) {
 			}

 			{
-				lbAddr addr = lb_build_addr(p, se->expr);
 				if (addr.kind == lbAddr_Map) {
 					lbValue v = lb_addr_load(p, addr);
 					lbValue a = lb_address_from_load_or_generate_local(p, v);
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -101,6 +101,7 @@ gb_internal void lb_init_module(lbModule *m, Checker *c) {

 	string_map_init(&m->objc_classes);
 	string_map_init(&m->objc_selectors);
+	string_map_init(&m->objc_ivars);

 	map_init(&m->map_info_map, 0);
 	map_init(&m->map_cell_info_map, 0);
@@ -173,6 +174,7 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 	mpsc_init(&gen->entities_to_correct_linkage, heap_allocator());
 	mpsc_init(&gen->objc_selectors, heap_allocator());
 	mpsc_init(&gen->objc_classes, heap_allocator());
+	mpsc_init(&gen->objc_ivars, heap_allocator());

 	return true;
 }
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -3374,6 +3374,7 @@ gb_internal lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValu
 	case BuiltinProc_objc_find_class:        return lb_handle_objc_find_class(p, expr);
 	case BuiltinProc_objc_register_selector: return lb_handle_objc_register_selector(p, expr);
 	case BuiltinProc_objc_register_class:    return lb_handle_objc_register_class(p, expr);
+	case BuiltinProc_objc_ivar_get:          return lb_handle_objc_ivar_get(p, expr);


 	case BuiltinProc_constant_utf16_cstring:
--- a/src/llvm_backend_utility.cpp
+++ b/src/llvm_backend_utility.cpp
@@ -2125,7 +2125,7 @@ gb_internal lbAddr lb_handle_objc_find_or_register_selector(lbProcedure *p, Stri
 	return addr;
 }

-gb_internal lbAddr lb_handle_objc_find_or_register_class(lbProcedure *p, String const &name) {
+gb_internal lbAddr lb_handle_objc_find_or_register_class(lbProcedure *p, String const &name, Type *class_impl_type) {
 	lbModule *m = p->module;
 	lbAddr *found = string_map_get(&m->objc_classes, name);
 	if (found) {
@@ -2148,13 +2148,75 @@ gb_internal lbAddr lb_handle_objc_find_or_register_class(lbProcedure *p, String
 	} else {
 		LLVMSetLinkage(g.value, LLVMExternalLinkage);
 	}
-	mpsc_enqueue(&m->gen->objc_classes, lbObjCGlobal{m, global_name, name, t_objc_Class});
+	mpsc_enqueue(&m->gen->objc_classes, lbObjCGlobal{m, global_name, name, t_objc_Class, class_impl_type});

 	lbAddr addr = lb_addr(g);
 	string_map_set(&m->objc_classes, name, addr);
 	return addr;
 }

+gb_internal lbAddr lb_handle_objc_find_or_register_ivar(lbModule *m, Type *self_type) {
+
+	String name = self_type->Named.type_name->TypeName.objc_class_name;
+	GB_ASSERT(name != "");
+
+	lbAddr *found = string_map_get(&m->objc_ivars, name);
+	if (found) {
+		return *found;
+	}
+
+	lbModule *default_module = &m->gen->default_module;
+
+	gbString global_name = gb_string_make(permanent_allocator(), "__$objc_ivar::");
+	global_name = gb_string_append_length(global_name, name.text, name.len);
+
+	// Create a global variable to store offset of the ivar in an instance of an object
+	LLVMTypeRef t = lb_type(m, t_int);
+
+	lbValue g = {};
+	g.value = LLVMAddGlobal(m->mod, t, global_name);
+	g.type  = t_int_ptr;
+
+	if (default_module == m) {
+		LLVMSetInitializer(g.value, LLVMConstInt(t, 0, true));
+		lb_add_member(m, make_string_c(global_name), g);
+	} else {
+		LLVMSetLinkage(g.value, LLVMExternalLinkage);
+	}
+
+	mpsc_enqueue(&m->gen->objc_ivars, lbObjCGlobal{m, global_name, name, t_int, self_type});
+
+	lbAddr addr = lb_addr(g);
+	string_map_set(&m->objc_ivars, name, addr);
+	return addr;
+}
+
+gb_internal lbValue lb_handle_objc_ivar_for_objc_object_pointer(lbProcedure *p, lbValue self) {
+	GB_ASSERT(self.type->kind == Type_Pointer && self.type->Pointer.elem->kind == Type_Named);
+
+	Type *self_type = self.type->Pointer.elem;
+
+	lbValue self_uptr = lb_emit_conv(p, self, t_uintptr);
+
+	lbValue ivar_offset      = lb_addr_load(p, lb_handle_objc_find_or_register_ivar(p->module, self_type));
+	lbValue ivar_offset_uptr = lb_emit_conv(p, ivar_offset, t_uintptr);
+
+
+	lbValue ivar_uptr = lb_emit_arith(p, Token_Add, self_uptr, ivar_offset_uptr, t_uintptr);
+
+	Type *ivar_type = self_type->Named.type_name->TypeName.objc_ivar;
+	return lb_emit_conv(p, ivar_uptr, alloc_type_pointer(ivar_type));
+}
+
+gb_internal lbValue lb_handle_objc_ivar_get(lbProcedure *p, Ast *expr) {
+	ast_node(ce, CallExpr, expr);
+
+	GB_ASSERT(ce->args[0]->tav.type->kind == Type_Pointer);
+	lbValue self = lb_build_expr(p, ce->args[0]);
+
+	return lb_handle_objc_ivar_for_objc_object_pointer(p, self);
+}
+
 gb_internal lbValue lb_handle_objc_find_selector(lbProcedure *p, Ast *expr) {
 	ast_node(ce, CallExpr, expr);

@@ -2188,7 +2250,7 @@ gb_internal lbValue lb_handle_objc_find_class(lbProcedure *p, Ast *expr) {
 	auto tav = ce->args[0]->tav;
 	GB_ASSERT(tav.value.kind == ExactValue_String);
 	String name = tav.value.value_string;
-	return lb_addr_load(p, lb_handle_objc_find_or_register_class(p, name));
+	return lb_addr_load(p, lb_handle_objc_find_or_register_class(p, name, nullptr));
 }

 gb_internal lbValue lb_handle_objc_register_class(lbProcedure *p, Ast *expr) {
@@ -2198,7 +2260,7 @@ gb_internal lbValue lb_handle_objc_register_class(lbProcedure *p, Ast *expr) {
 	auto tav = ce->args[0]->tav;
 	GB_ASSERT(tav.value.kind == ExactValue_String);
 	String name = tav.value.value_string;
-	lbAddr dst = lb_handle_objc_find_or_register_class(p, name);
+	lbAddr dst = lb_handle_objc_find_or_register_class(p, name, nullptr);

 	auto args = array_make<lbValue>(permanent_allocator(), 3);
 	args[0] = lb_const_nil(m, t_objc_Class);
@@ -2220,7 +2282,9 @@ gb_internal lbValue lb_handle_objc_id(lbProcedure *p, Ast *expr) {
 		GB_ASSERT(e->kind == Entity_TypeName);
 		String name = e->TypeName.objc_class_name;

-		return lb_addr_load(p, lb_handle_objc_find_or_register_class(p, name));
+		Type *class_impl_type = e->TypeName.objc_is_implementation ? type : nullptr;
+
+		return lb_addr_load(p, lb_handle_objc_find_or_register_class(p, name, class_impl_type));
 	}

 	return lb_build_expr(p, expr);
@@ -2266,9 +2330,6 @@ gb_internal lbValue lb_handle_objc_send(lbProcedure *p, Ast *expr) {
 	return lb_emit_call(p, the_proc, args);
 }

-
-
-
 gb_internal LLVMAtomicOrdering llvm_atomic_ordering_from_odin(ExactValue const &value) {
 	GB_ASSERT(value.kind == ExactValue_Integer);
 	i64 v = exact_value_to_i64(value);
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -729,10 +729,12 @@ gb_global Type *t_map_set_proc = nullptr;
 gb_global Type *t_objc_object   = nullptr;
 gb_global Type *t_objc_selector = nullptr;
 gb_global Type *t_objc_class    = nullptr;
+gb_global Type *t_objc_ivar     = nullptr;

 gb_global Type *t_objc_id    = nullptr;
 gb_global Type *t_objc_SEL   = nullptr;
 gb_global Type *t_objc_Class = nullptr;
+gb_global Type *t_objc_Ivar  = nullptr;

 enum OdinAtomicMemoryOrder : i32 {
 	OdinAtomicMemoryOrder_relaxed = 0, // unordered
@@ -872,6 +874,29 @@ gb_internal Type *base_type(Type *t) {
 	return t;
 }

+gb_internal Type *base_named_type(Type *t) {
+	if (t->kind != Type_Named) {
+		return t_invalid;
+	}
+
+	Type *prev_named = t;
+	t = t->Named.base;
+	for (;;) {
+		if (t == nullptr) {
+			break;
+		}
+		if (t->kind != Type_Named) {
+			break;
+		}
+		if (t == t->Named.base) {
+			return t_invalid;
+		}
+		prev_named = t;
+		t = t->Named.base;
+	}
+	return prev_named;
+}
+
 gb_internal Type *base_enum_type(Type *t) {
 	Type *bt = base_type(t);
 	if (bt != nullptr &&
@@ -3327,6 +3352,15 @@ gb_internal Selection lookup_field_with_selection(Type *type_, String field_name
 					}
 				}
 			}
+
+			Type *objc_ivar_type = e->TypeName.objc_ivar;
+			if (objc_ivar_type != nullptr) {
+				sel = lookup_field_with_selection(objc_ivar_type, field_name, false, sel, allow_blank_ident);
+				if (sel.entity != nullptr) {
+					sel.pseudo_field = true;
+					return sel;
+				}
+			}
 		}

 		if (is_type_polymorphic(type)) {