Remove `#relative` types from the compiler

18 files changed, 31 insertions, 602 deletions

diff --git a/base/runtime/core.odin b/base/runtime/core.odin
index a5a3a4d8c..e47f3ecbc 100644
--- a/base/runtime/core.odin
+++ b/base/runtime/core.odin
@@ -171,14 +171,6 @@ Type_Info_Simd_Vector :: struct {
 	elem_size:  int,
 	count:      int,
 }
-Type_Info_Relative_Pointer :: struct {
-	pointer:      ^Type_Info, // ^T
-	base_integer: ^Type_Info,
-}
-Type_Info_Relative_Multi_Pointer :: struct {
-	pointer:      ^Type_Info, // [^]T
-	base_integer: ^Type_Info,
-}
 Type_Info_Matrix :: struct {
 	elem:         ^Type_Info,
 	elem_size:    int,
@@ -241,8 +233,6 @@ Type_Info :: struct {
 		Type_Info_Map,
 		Type_Info_Bit_Set,
 		Type_Info_Simd_Vector,
-		Type_Info_Relative_Pointer,
-		Type_Info_Relative_Multi_Pointer,
 		Type_Info_Matrix,
 		Type_Info_Soa_Pointer,
 		Type_Info_Bit_Field,
@@ -275,8 +265,6 @@ Typeid_Kind :: enum u8 {
 	Map,
 	Bit_Set,
 	Simd_Vector,
-	Relative_Pointer,
-	Relative_Multi_Pointer,
 	Matrix,
 	Soa_Pointer,
 	Bit_Field,
diff --git a/base/runtime/print.odin b/base/runtime/print.odin
index 45f6f01ef..c28fd593d 100644
--- a/base/runtime/print.odin
+++ b/base/runtime/print.odin
@@ -486,18 +486,6 @@ print_type :: #force_no_inline proc "contextless" (ti: ^Type_Info) {
 		print_u64(u64(info.count))
 		print_byte(']')
 		print_type(info.elem)
-
-	case Type_Info_Relative_Pointer:
-		print_string("#relative(")
-		print_type(info.base_integer)
-		print_string(") ")
-		print_type(info.pointer)
-
-	case Type_Info_Relative_Multi_Pointer:
-		print_string("#relative(")
-		print_type(info.base_integer)
-		print_string(") ")
-		print_type(info.pointer)
 		
 	case Type_Info_Matrix:
 		print_string("matrix[")
diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin
index dd5c2c6a2..49e9f2e6d 100644
--- a/core/fmt/fmt.odin
+++ b/core/fmt/fmt.odin
@@ -3002,18 +3002,6 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 	case runtime.Type_Info_Bit_Set:
 		fmt_bit_set(fi, v, verb = verb)
 
-	case runtime.Type_Info_Relative_Pointer:
-		ptr := reflect.relative_pointer_to_absolute_raw(v.data, info.base_integer.id)
-		absolute_ptr := any{ptr, info.pointer.id}
-
-		fmt_value(fi, absolute_ptr, verb)
-
-	case runtime.Type_Info_Relative_Multi_Pointer:
-		ptr := reflect.relative_pointer_to_absolute_raw(v.data, info.base_integer.id)
-		absolute_ptr := any{ptr, info.pointer.id}
-
-		fmt_value(fi, absolute_ptr, verb)
-
 	case runtime.Type_Info_Matrix:
 		fmt_matrix(fi, v, verb, info)
 
diff --git a/core/reflect/reflect.odin b/core/reflect/reflect.odin
index d547b67ed..7f79acb77 100644
--- a/core/reflect/reflect.odin
+++ b/core/reflect/reflect.odin
@@ -31,8 +31,6 @@ Type_Info_Enum                   :: runtime.Type_Info_Enum
 Type_Info_Map                    :: runtime.Type_Info_Map
 Type_Info_Bit_Set                :: runtime.Type_Info_Bit_Set
 Type_Info_Simd_Vector            :: runtime.Type_Info_Simd_Vector
-Type_Info_Relative_Pointer       :: runtime.Type_Info_Relative_Pointer
-Type_Info_Relative_Multi_Pointer :: runtime.Type_Info_Relative_Multi_Pointer
 Type_Info_Matrix                 :: runtime.Type_Info_Matrix
 Type_Info_Soa_Pointer            :: runtime.Type_Info_Soa_Pointer
 Type_Info_Bit_Field              :: runtime.Type_Info_Bit_Field
@@ -67,8 +65,6 @@ Type_Kind :: enum {
 	Map,
 	Bit_Set,
 	Simd_Vector,
-	Relative_Pointer,
-	Relative_Multi_Pointer,
 	Matrix,
 	Soa_Pointer,
 	Bit_Field,
@@ -80,35 +76,33 @@ type_kind :: proc(T: typeid) -> Type_Kind {
 	ti := type_info_of(T)
 	if ti != nil {
 		switch _ in ti.variant {
-		case Type_Info_Named:                  return .Named
-		case Type_Info_Integer:                return .Integer
-		case Type_Info_Rune:                   return .Rune
-		case Type_Info_Float:                  return .Float
-		case Type_Info_Complex:                return .Complex
-		case Type_Info_Quaternion:             return .Quaternion
-		case Type_Info_String:                 return .String
-		case Type_Info_Boolean:                return .Boolean
-		case Type_Info_Any:                    return .Any
-		case Type_Info_Type_Id:                return .Type_Id
-		case Type_Info_Pointer:                return .Pointer
-		case Type_Info_Multi_Pointer:          return .Multi_Pointer
-		case Type_Info_Procedure:              return .Procedure
-		case Type_Info_Array:                  return .Array
-		case Type_Info_Enumerated_Array:       return .Enumerated_Array
-		case Type_Info_Dynamic_Array:          return .Dynamic_Array
-		case Type_Info_Slice:                  return .Slice
-		case Type_Info_Parameters:             return .Tuple
-		case Type_Info_Struct:                 return .Struct
-		case Type_Info_Union:                  return .Union
-		case Type_Info_Enum:                   return .Enum
-		case Type_Info_Map:                    return .Map
-		case Type_Info_Bit_Set:                return .Bit_Set
-		case Type_Info_Simd_Vector:            return .Simd_Vector
-		case Type_Info_Relative_Pointer:       return .Relative_Pointer
-		case Type_Info_Relative_Multi_Pointer: return .Relative_Multi_Pointer
-		case Type_Info_Matrix:                 return .Matrix
-		case Type_Info_Soa_Pointer:            return .Soa_Pointer
-		case Type_Info_Bit_Field:              return .Bit_Field
+		case Type_Info_Named:            return .Named
+		case Type_Info_Integer:          return .Integer
+		case Type_Info_Rune:             return .Rune
+		case Type_Info_Float:            return .Float
+		case Type_Info_Complex:          return .Complex
+		case Type_Info_Quaternion:       return .Quaternion
+		case Type_Info_String:           return .String
+		case Type_Info_Boolean:          return .Boolean
+		case Type_Info_Any:              return .Any
+		case Type_Info_Type_Id:          return .Type_Id
+		case Type_Info_Pointer:          return .Pointer
+		case Type_Info_Multi_Pointer:    return .Multi_Pointer
+		case Type_Info_Procedure:        return .Procedure
+		case Type_Info_Array:            return .Array
+		case Type_Info_Enumerated_Array: return .Enumerated_Array
+		case Type_Info_Dynamic_Array:    return .Dynamic_Array
+		case Type_Info_Slice:            return .Slice
+		case Type_Info_Parameters:       return .Tuple
+		case Type_Info_Struct:           return .Struct
+		case Type_Info_Union:            return .Union
+		case Type_Info_Enum:             return .Enum
+		case Type_Info_Map:              return .Map
+		case Type_Info_Bit_Set:          return .Bit_Set
+		case Type_Info_Simd_Vector:      return .Simd_Vector
+		case Type_Info_Matrix:           return .Matrix
+		case Type_Info_Soa_Pointer:      return .Soa_Pointer
+		case Type_Info_Bit_Field:        return .Bit_Field
 		}
 
 	}
@@ -1489,21 +1483,6 @@ as_string :: proc(a: any) -> (value: string, valid: bool) {
 }
 
 @(require_results)
-relative_pointer_to_absolute :: proc(a: any) -> rawptr {
-	if a == nil { return nil }
-	a := a
-	ti := runtime.type_info_core(type_info_of(a.id))
-	a.id = ti.id
-
-	#partial switch info in ti.variant {
-	case Type_Info_Relative_Pointer:
-		return relative_pointer_to_absolute_raw(a.data, info.base_integer.id)
-	}
-	return nil
-}
-
-
-@(require_results)
 relative_pointer_to_absolute_raw :: proc(data: rawptr, base_integer_id: typeid) -> rawptr {
 	_handle :: proc(ptr: ^$T) -> rawptr where intrinsics.type_is_integer(T) {
 		if ptr^ == 0 {
@@ -1564,10 +1543,6 @@ as_pointer :: proc(a: any) -> (value: rawptr, valid: bool) {
 		case cstring: value = rawptr(v)
 		case: valid = false
 		}
-
-	case Type_Info_Relative_Pointer:
-		valid = true
-		value = relative_pointer_to_absolute_raw(a.data, info.base_integer.id)
 	}
 
 	return
@@ -1677,8 +1652,6 @@ equal :: proc(a, b: any, including_indirect_array_recursion := false, recursion_
 		Type_Info_Bit_Set,
 		Type_Info_Enum,
 		Type_Info_Simd_Vector,
-		Type_Info_Relative_Pointer,
-		Type_Info_Relative_Multi_Pointer,
 		Type_Info_Soa_Pointer,
 		Type_Info_Matrix:
 		return runtime.memory_compare(a.data, b.data, t.size) == 0
diff --git a/core/reflect/types.odin b/core/reflect/types.odin
index 4f0674dc8..cb31a27e2 100644
--- a/core/reflect/types.odin
+++ b/core/reflect/types.odin
@@ -158,14 +158,6 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 	case Type_Info_Simd_Vector:
 		y := b.variant.(Type_Info_Simd_Vector) or_return
 		return x.count == y.count && x.elem == y.elem
-
-	case Type_Info_Relative_Pointer:
-		y := b.variant.(Type_Info_Relative_Pointer) or_return
-		return x.base_integer == y.base_integer && x.pointer == y.pointer
-
-	case Type_Info_Relative_Multi_Pointer:
-		y := b.variant.(Type_Info_Relative_Multi_Pointer) or_return
-		return x.base_integer == y.base_integer && x.pointer == y.pointer
 		
 	case Type_Info_Matrix:
 		y := b.variant.(Type_Info_Matrix) or_return
@@ -392,18 +384,6 @@ is_simd_vector :: proc(info: ^Type_Info) -> bool {
 	_, ok := type_info_base(info).variant.(Type_Info_Simd_Vector)
 	return ok
 }
-@(require_results)
-is_relative_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false }
-	_, ok := type_info_base(info).variant.(Type_Info_Relative_Pointer)
-	return ok
-}
-@(require_results)
-is_relative_multi_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false }
-	_, ok := type_info_base(info).variant.(Type_Info_Relative_Multi_Pointer)
-	return ok
-}
 
 
 @(require_results)
@@ -736,18 +716,6 @@ write_type_writer :: #force_no_inline proc(w: io.Writer, ti: ^Type_Info, n_writt
 		io.write_i64(w, i64(info.count), 10, &n) or_return
 		io.write_byte(w, ']',                &n) or_return
 		write_type(w, info.elem,             &n) or_return
-
-	case Type_Info_Relative_Pointer:
-		io.write_string(w, "#relative(", &n) or_return
-		write_type(w, info.base_integer, &n) or_return
-		io.write_string(w, ") ",         &n) or_return
-		write_type(w, info.pointer,      &n) or_return
-
-	case Type_Info_Relative_Multi_Pointer:
-		io.write_string(w, "#relative(", &n) or_return
-		write_type(w, info.base_integer, &n) or_return
-		io.write_string(w, ") ",         &n) or_return
-		write_type(w, info.pointer,      &n) or_return
 		
 	case Type_Info_Matrix:
 		if info.layout == .Row_Major {
diff --git a/examples/demo/demo.odin b/examples/demo/demo.odin
index b234ba4f3..36d1359ca 100644
--- a/examples/demo/demo.odin
+++ b/examples/demo/demo.odin
@@ -2052,22 +2052,6 @@ explicit_context_definition :: proc "c" () {
 	dummy_procedure()
 }
 
-relative_data_types :: proc() {
-	fmt.println("\n#relative data types")
-
-	x: int = 123
-	ptr: #relative(i16) ^int
-	ptr = &x
-	fmt.println(ptr^)
-
-	arr := [3]int{1, 2, 3}
-	multi_ptr: #relative(i16) [^]int
-	multi_ptr = &arr[0]
-	fmt.println(multi_ptr)
-	fmt.println(multi_ptr[:3])
-	fmt.println(multi_ptr[1])
-}
-
 or_else_operator :: proc() {
 	fmt.println("\n#'or_else'")
 	{
@@ -2634,7 +2618,6 @@ main :: proc() {
 		constant_literal_expressions()
 		union_maybe()
 		explicit_context_definition()
-		relative_data_types()
 		or_else_operator()
 		or_return_operator()
 		or_break_and_or_continue_operators()
diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 05f491690..cb4647f33 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -897,20 +897,6 @@ gb_internal i64 check_distance_between_types(CheckerContext *c, Operand *operand
 		}
 	}
 
-	if (is_type_relative_pointer(dst)) {
-		i64 score = check_distance_between_types(c, operand, dst->RelativePointer.pointer_type, allow_array_programming);
-		if (score >= 0) {
-			return score+2;
-		}
-	}
-
-	if (is_type_relative_multi_pointer(dst)) {
-		i64 score = check_distance_between_types(c, operand, dst->RelativeMultiPointer.pointer_type, allow_array_programming);
-		if (score >= 0) {
-			return score+2;
-		}
-	}
-
 	if (is_type_proc(dst)) {
 		if (are_types_identical(src, dst)) {
 			return 3;
@@ -1052,12 +1038,6 @@ gb_internal AstPackage *get_package_of_type(Type *type) {
 		case Type_DynamicArray:
 			type = type->DynamicArray.elem;
 			continue;
-		case Type_RelativePointer:
-			type = type->RelativePointer.pointer_type;
-			continue;
-		case Type_RelativeMultiPointer:
-			type = type->RelativeMultiPointer.pointer_type;
-			continue;
 		}
 		return nullptr;
 	}
@@ -8230,17 +8210,6 @@ gb_internal bool check_set_index_data(Operand *o, Type *t, bool indirection, i64
 		}
 		return true;
 
-	case Type_RelativeMultiPointer:
-		{
-			Type *pointer_type = base_type(t->RelativeMultiPointer.pointer_type);
-			GB_ASSERT(pointer_type->kind == Type_MultiPointer);
-			o->type = pointer_type->MultiPointer.elem;
-			if (o->mode != Addressing_Constant) {
-				o->mode = Addressing_Variable;
-			}
-		}
-		return true;
-
 	case Type_DynamicArray:
 		o->type = t->DynamicArray.elem;
 		if (o->mode != Addressing_Constant) {
@@ -10623,8 +10592,6 @@ gb_internal ExprKind check_index_expr(CheckerContext *c, Operand *o, Ast *node,
 			// Okay
 		} else if (is_type_string(t)) {
 			// Okay
-		} else if (is_type_relative_multi_pointer(t)) {
-			// Okay
 		} else if (is_type_matrix(t)) {
 			// Okay
 		} else {
@@ -10779,11 +10746,6 @@ gb_internal ExprKind check_slice_expr(CheckerContext *c, Operand *o, Ast *node,
 		}
 		break;
 
-	case Type_RelativeMultiPointer:
-		valid = true;
-		o->type = type_deref(o->type);
-		break;
-
 	case Type_EnumeratedArray:
 		{
 			gbString str = expr_to_string(o->expr);
@@ -10860,16 +10822,6 @@ gb_internal ExprKind check_slice_expr(CheckerContext *c, Operand *o, Ast *node,
 			x[i:n] -> []T
 		*/
 		o->type = alloc_type_slice(t->MultiPointer.elem);
-	} else if (t->kind == Type_RelativeMultiPointer && se->high != nullptr) {
-		/*
-			x[:]   -> [^]T
-			x[i:]  -> [^]T
-			x[:n]  -> []T
-			x[i:n] -> []T
-		*/
-		Type *pointer_type = base_type(t->RelativeMultiPointer.pointer_type);
-		GB_ASSERT(pointer_type->kind == Type_MultiPointer);
-		o->type = alloc_type_slice(pointer_type->MultiPointer.elem);
 	}
 
 
@@ -11230,22 +11182,6 @@ gb_internal ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast
  			} else if (t->kind == Type_SoaPointer) {
 				o->mode = Addressing_SoaVariable;
 				o->type = type_deref(t);
- 			} else if (t->kind == Type_RelativePointer) {
- 				if (o->mode != Addressing_Variable) {
- 					gbString str = expr_to_string(o->expr);
- 					gbString typ = type_to_string(o->type);
- 					error(o->expr, "Cannot dereference relative pointer '%s' of type '%s' as it does not have a variable addressing mode", str, typ);
- 					gb_string_free(typ);
- 					gb_string_free(str);
- 				}
-
- 				// NOTE(bill): This is required because when dereferencing, the original type has been lost
-				add_type_info_type(c, o->type);
-
- 				Type *ptr_type = base_type(t->RelativePointer.pointer_type);
- 				GB_ASSERT(ptr_type->kind == Type_Pointer);
-				o->mode = Addressing_Variable;
-				o->type = ptr_type->Pointer.elem;
  			} else {
  				gbString str = expr_to_string(o->expr);
  				gbString typ = type_to_string(o->type);
diff --git a/src/check_type.cpp b/src/check_type.cpp
index bbeff9ca7..84e7fb249 100644
--- a/src/check_type.cpp
+++ b/src/check_type.cpp
@@ -3517,41 +3517,8 @@ gb_internal bool check_type_internal(CheckerContext *ctx, Ast *e, Type **type, T
 	case_end;
 
 	case_ast_node(rt, RelativeType, e);
-		GB_ASSERT(rt->tag->kind == Ast_CallExpr);
-		ast_node(ce, CallExpr, rt->tag);
-
-		Type *base_integer = nullptr;
-
-		if (ce->args.count != 1) {
-			error(rt->type, "#relative expected 1 type argument, got %td", ce->args.count);
-		} else {
-			base_integer = check_type(ctx, ce->args[0]);
-			if (!is_type_integer(base_integer)) {
-				error(rt->type, "#relative base types must be an integer");
-				base_integer = nullptr;
-			} else if (type_size_of(base_integer) > 64) {
-				error(rt->type, "#relative base integer types be less than or equal to 64-bits");
-				base_integer = nullptr;
-			}
-		}
-
-		Type *relative_type = nullptr;
-		Type *base_type = check_type(ctx, rt->type);
-		if (!is_type_pointer(base_type) && !is_type_multi_pointer(base_type)) {
-			error(rt->type, "#relative types can only be a pointer or multi-pointer");
-			relative_type = base_type;
-		} else if (base_integer == nullptr) {
-			relative_type = base_type;
-		} else {
-			if (is_type_pointer(base_type)) {
-				relative_type = alloc_type_relative_pointer(base_type, base_integer);
-			} else if (is_type_multi_pointer(base_type)) {
-				relative_type = alloc_type_relative_multi_pointer(base_type, base_integer);
-			}
-		}
-		GB_ASSERT(relative_type != nullptr);
-
-		*type = relative_type;
+		error(e, "#relative types have been removed from the compiler. Prefer \"core:relative\".");
+		*type = t_invalid;
 		set_base_type(named_type, *type);
 		return true;
 	case_end;
diff --git a/src/checker.cpp b/src/checker.cpp
index 76f996648..b7cf343f8 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -2186,16 +2186,6 @@ gb_internal void add_type_info_type_internal(CheckerContext *c, Type *t) {
 		add_type_info_type_internal(c, bt->SimdVector.elem);
 		break;
 
-	case Type_RelativePointer:
-		add_type_info_type_internal(c, bt->RelativePointer.pointer_type);
-		add_type_info_type_internal(c, bt->RelativePointer.base_integer);
-		break;
-
-	case Type_RelativeMultiPointer:
-		add_type_info_type_internal(c, bt->RelativeMultiPointer.pointer_type);
-		add_type_info_type_internal(c, bt->RelativeMultiPointer.base_integer);
-		break;
-
 	case Type_Matrix:
 		add_type_info_type_internal(c, bt->Matrix.elem);
 		break;
@@ -2441,16 +2431,6 @@ gb_internal void add_min_dep_type_info(Checker *c, Type *t) {
 		add_min_dep_type_info(c, bt->SimdVector.elem);
 		break;
 
-	case Type_RelativePointer:
-		add_min_dep_type_info(c, bt->RelativePointer.pointer_type);
-		add_min_dep_type_info(c, bt->RelativePointer.base_integer);
-		break;
-
-	case Type_RelativeMultiPointer:
-		add_min_dep_type_info(c, bt->RelativeMultiPointer.pointer_type);
-		add_min_dep_type_info(c, bt->RelativeMultiPointer.base_integer);
-		break;
-
 	case Type_Matrix:
 		add_min_dep_type_info(c, bt->Matrix.elem);
 		break;
@@ -3075,8 +3055,6 @@ gb_internal void init_core_type_info(Checker *c) {
 	t_type_info_map              = find_core_type(c, str_lit("Type_Info_Map"));
 	t_type_info_bit_set          = find_core_type(c, str_lit("Type_Info_Bit_Set"));
 	t_type_info_simd_vector      = find_core_type(c, str_lit("Type_Info_Simd_Vector"));
-	t_type_info_relative_pointer = find_core_type(c, str_lit("Type_Info_Relative_Pointer"));
-	t_type_info_relative_multi_pointer = find_core_type(c, str_lit("Type_Info_Relative_Multi_Pointer"));
 	t_type_info_matrix           = find_core_type(c, str_lit("Type_Info_Matrix"));
 	t_type_info_soa_pointer      = find_core_type(c, str_lit("Type_Info_Soa_Pointer"));
 	t_type_info_bit_field        = find_core_type(c, str_lit("Type_Info_Bit_Field"));
@@ -3105,8 +3083,6 @@ gb_internal void init_core_type_info(Checker *c) {
 	t_type_info_map_ptr              = alloc_type_pointer(t_type_info_map);
 	t_type_info_bit_set_ptr          = alloc_type_pointer(t_type_info_bit_set);
 	t_type_info_simd_vector_ptr      = alloc_type_pointer(t_type_info_simd_vector);
-	t_type_info_relative_pointer_ptr = alloc_type_pointer(t_type_info_relative_pointer);
-	t_type_info_relative_multi_pointer_ptr = alloc_type_pointer(t_type_info_relative_multi_pointer);
 	t_type_info_matrix_ptr           = alloc_type_pointer(t_type_info_matrix);
 	t_type_info_soa_pointer_ptr      = alloc_type_pointer(t_type_info_soa_pointer);
 	t_type_info_bit_field_ptr        = alloc_type_pointer(t_type_info_bit_field);
diff --git a/src/docs_format.cpp b/src/docs_format.cpp
index ca6ecb5c2..6378971d0 100644
--- a/src/docs_format.cpp
+++ b/src/docs_format.cpp
@@ -79,8 +79,7 @@ enum OdinDocTypeKind : u32 {
 	OdinDocType_SOAStructFixed       = 17,
 	OdinDocType_SOAStructSlice       = 18,
 	OdinDocType_SOAStructDynamic     = 19,
-	OdinDocType_RelativePointer      = 20,
-	OdinDocType_RelativeMultiPointer = 21,
+
 	OdinDocType_MultiPointer         = 22,
 	OdinDocType_Matrix               = 23,
 	OdinDocType_SoaPointer           = 24,
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index 835dfdff1..341b3fa6b 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -776,24 +776,6 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 		doc_type.types = odin_doc_type_as_slice(w, type->SimdVector.elem);
 		// TODO(bill):
 		break;
-	case Type_RelativePointer:
-		doc_type.kind = OdinDocType_RelativePointer;
-		{
-			OdinDocTypeIndex types[2] = {};
-			types[0] = odin_doc_type(w, type->RelativePointer.pointer_type);
-			types[1] = odin_doc_type(w, type->RelativePointer.base_integer);
-			doc_type.types = odin_write_slice(w, types, gb_count_of(types));
-		}
-		break;
-	case Type_RelativeMultiPointer:
-		doc_type.kind = OdinDocType_RelativeMultiPointer;
-		{
-			OdinDocTypeIndex types[2] = {};
-			types[0] = odin_doc_type(w, type->RelativeMultiPointer.pointer_type);
-			types[1] = odin_doc_type(w, type->RelativeMultiPointer.base_integer);
-			doc_type.types = odin_write_slice(w, types, gb_count_of(types));
-		}
-		break;
 		
 	case Type_Matrix:
 		doc_type.kind = OdinDocType_Matrix;
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index 68f95cb03..464efa325 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -75,7 +75,6 @@ enum lbAddrKind {
 	lbAddr_Context,
 	lbAddr_SoaVariable,
 
-	lbAddr_RelativePointer,
 
 	lbAddr_Swizzle,
 	lbAddr_SwizzleLarge,
@@ -104,9 +103,6 @@ struct lbAddr {
 			Ast *node;
 		} index_set;
 		struct {
-			bool deref;
-		} relative;
-		struct {
 			Type *type;
 			u8 count;      // 2, 3, or 4 components
 			u8 indices[4];
diff --git a/src/llvm_backend_debug.cpp b/src/llvm_backend_debug.cpp
index 5cc79dcc8..464f7065c 100644
--- a/src/llvm_backend_debug.cpp
+++ b/src/llvm_backend_debug.cpp
@@ -920,17 +920,6 @@ gb_internal LLVMMetadataRef lb_debug_type_internal(lbModule *m, Type *type) {
 				elem, subscripts, gb_count_of(subscripts));
 		}
 
-	case Type_RelativePointer: {
-		LLVMMetadataRef base_integer = lb_debug_type(m, type->RelativePointer.base_integer);
-		gbString name = type_to_string(type, temporary_allocator());
-		return LLVMDIBuilderCreateTypedef(m->debug_builder, base_integer, name, gb_string_length(name), nullptr, 0, nullptr, cast(u32)(8*type_align_of(type)));
-	}
-	case Type_RelativeMultiPointer: {
-		LLVMMetadataRef base_integer = lb_debug_type(m, type->RelativeMultiPointer.base_integer);
-		gbString name = type_to_string(type, temporary_allocator());
-		return LLVMDIBuilderCreateTypedef(m->debug_builder, base_integer, name, gb_string_length(name), nullptr, 0, nullptr, cast(u32)(8*type_align_of(type)));
-	}
-
 	case Type_Matrix: {
 		LLVMMetadataRef subscripts[1] = {};
 		subscripts[0] = LLVMDIBuilderGetOrCreateSubrange(m->debug_builder,
diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp
index 8ad44035d..80c469ae6 100644
--- a/src/llvm_backend_expr.cpp
+++ b/src/llvm_backend_expr.cpp
@@ -4200,30 +4200,6 @@ gb_internal lbAddr lb_build_addr_index_expr(lbProcedure *p, Ast *expr) {
 		return lb_addr(v);
 	}
 
-	case Type_RelativeMultiPointer: {
-		lbAddr rel_ptr_addr = {};
-		if (deref) {
-			lbValue rel_ptr_ptr = lb_build_expr(p, ie->expr);
-			rel_ptr_addr = lb_addr(rel_ptr_ptr);
-		} else {
-			rel_ptr_addr = lb_build_addr(p, ie->expr);
-		}
-		lbValue rel_ptr = lb_relative_pointer_to_pointer(p, rel_ptr_addr);
-
-		lbValue index = lb_build_expr(p, ie->index);
-		index = lb_emit_conv(p, index, t_int);
-		lbValue v = {};
-
-		Type *pointer_type = base_type(t->RelativeMultiPointer.pointer_type);
-		GB_ASSERT(pointer_type->kind == Type_MultiPointer);
-		Type *elem = pointer_type->MultiPointer.elem;
-
-		LLVMValueRef indices[1] = {index.value};
-		v.value = LLVMBuildGEP2(p->builder, lb_type(p->module, elem), rel_ptr.value, indices, 1, "");
-		v.type = alloc_type_pointer(elem);
-		return lb_addr(v);
-	}
-
 	case Type_DynamicArray: {
 		lbValue dynamic_array = {};
 		dynamic_array = lb_build_expr(p, ie->expr);
@@ -4333,13 +4309,6 @@ gb_internal lbAddr lb_build_addr_slice_expr(lbProcedure *p, Ast *expr) {
 		return slice;
 	}
 
-	case Type_RelativePointer:
-		GB_PANIC("TODO(bill): Type_RelativePointer should be handled above already on the lb_addr_load");
-		break;
-	case Type_RelativeMultiPointer:
-		GB_PANIC("TODO(bill): Type_RelativeMultiPointer should be handled above already on the lb_addr_load");
-		break;
-
 	case Type_DynamicArray: {
 		Type *elem_type = type->DynamicArray.elem;
 		Type *slice_type = alloc_type_slice(elem_type);
@@ -5343,11 +5312,7 @@ gb_internal lbAddr lb_build_addr_internal(lbProcedure *p, Ast *expr) {
 
 	case_ast_node(de, DerefExpr, expr);
 		Type *t = type_of_expr(de->expr);
-		if (is_type_relative_pointer(t)) {
-			lbAddr addr = lb_build_addr(p, de->expr);
-			addr.relative.deref = true;
-			return addr;
-		} else if (is_type_soa_pointer(t)) {
+		if (is_type_soa_pointer(t)) {
 			lbValue value = lb_build_expr(p, de->expr);
 			lbValue ptr = lb_emit_struct_ev(p, value, 0);
 			lbValue idx = lb_emit_struct_ev(p, value, 1);
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 686724f6a..9dc603993 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -409,14 +409,6 @@ gb_internal lbModule *lb_module_of_entity(lbGenerator *gen, Entity *e) {
 
 gb_internal lbAddr lb_addr(lbValue addr) {
 	lbAddr v = {lbAddr_Default, addr};
-	if (addr.type != nullptr && is_type_relative_pointer(type_deref(addr.type))) {
-		GB_ASSERT(is_type_pointer(addr.type));
-		v.kind = lbAddr_RelativePointer;
-	} else if (addr.type != nullptr && is_type_relative_multi_pointer(type_deref(addr.type))) {
-		GB_ASSERT(is_type_pointer(addr.type) ||
-		          is_type_multi_pointer(addr.type));
-		v.kind = lbAddr_RelativePointer;
-	}
 	return v;
 }
 
@@ -501,42 +493,6 @@ gb_internal Type *lb_addr_type(lbAddr const &addr) {
 	return type_deref(addr.addr.type);
 }
 
-
-gb_internal lbValue lb_relative_pointer_to_pointer(lbProcedure *p, lbAddr const &addr) {
-	GB_ASSERT(addr.kind == lbAddr_RelativePointer);
-
-	Type *t = base_type(lb_addr_type(addr));
-	GB_ASSERT(is_type_relative_pointer(t) || is_type_relative_multi_pointer(t));
-
-	Type *pointer_type = nullptr;
-	Type *base_integer = nullptr;
-	if (t->kind == Type_RelativePointer) {
-		pointer_type = t->RelativePointer.pointer_type;
-		base_integer = t->RelativePointer.base_integer;
-	} else if (t->kind == Type_RelativeMultiPointer) {
-		pointer_type = t->RelativeMultiPointer.pointer_type;
-		base_integer = t->RelativeMultiPointer.base_integer;
-	}
-
-	lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
-	lbValue offset = lb_emit_conv(p, ptr, alloc_type_pointer(base_integer));
-	offset = lb_emit_load(p, offset);
-
-	if (!is_type_unsigned(base_integer)) {
-		offset = lb_emit_conv(p, offset, t_i64);
-	}
-	offset = lb_emit_conv(p, offset, t_uintptr);
-	lbValue absolute_ptr = lb_emit_arith(p, Token_Add, ptr, offset, t_uintptr);
-	absolute_ptr = lb_emit_conv(p, absolute_ptr, pointer_type);
-
-	lbValue cond = lb_emit_comp(p, Token_CmpEq, offset, lb_const_nil(p->module, base_integer));
-
-	// NOTE(bill): nil check
-	lbValue nil_ptr = lb_const_nil(p->module, pointer_type);
-	lbValue final_ptr = lb_emit_select(p, cond, nil_ptr, absolute_ptr);
-	return final_ptr;
-}
-
 gb_internal lbValue lb_make_soa_pointer(lbProcedure *p, Type *type, lbValue const &addr, lbValue const &index) {
 	lbAddr v = lb_add_local_generated(p, type, false);
 	lbValue ptr = lb_emit_struct_ep(p, v.addr, 0);
@@ -557,9 +513,6 @@ gb_internal lbValue lb_addr_get_ptr(lbProcedure *p, lbAddr const &addr) {
 	case lbAddr_Map:
 		return lb_internal_dynamic_map_get_ptr(p, addr.addr, addr.map.key);
 
-	case lbAddr_RelativePointer:
-		return lb_relative_pointer_to_pointer(p, addr);
-
 	case lbAddr_SoaVariable:
 		{
 			Type *soa_ptr_type = alloc_type_soa_pointer(lb_addr_type(addr));
@@ -584,9 +537,6 @@ gb_internal lbValue lb_addr_get_ptr(lbProcedure *p, lbAddr const &addr) {
 
 gb_internal lbValue lb_build_addr_ptr(lbProcedure *p, Ast *expr) {
 	lbAddr addr = lb_build_addr(p, expr);
-	if (addr.kind == lbAddr_RelativePointer) {
-		return addr.addr;
-	}
 	return lb_addr_get_ptr(p, addr);
 }
 
@@ -819,10 +769,6 @@ gb_internal void lb_addr_store(lbProcedure *p, lbAddr addr, lbValue value) {
 		value.value = LLVMConstNull(lb_type(p->module, t));
 	}
 
-	if (addr.kind == lbAddr_RelativePointer && addr.relative.deref) {
-		addr = lb_addr(lb_address_from_load(p, lb_addr_load(p, addr)));
-	}
-
 	if (addr.kind == lbAddr_BitField) {
 		lbValue dst = addr.addr;
 		if (is_type_endian_big(addr.bitfield.type)) {
@@ -860,44 +806,6 @@ gb_internal void lb_addr_store(lbProcedure *p, lbAddr addr, lbValue value) {
 			lb_emit_runtime_call(p, "__write_bits", args);
 		}
 		return;
-	} else if (addr.kind == lbAddr_RelativePointer) {
-		Type *rel_ptr = base_type(lb_addr_type(addr));
-		GB_ASSERT(rel_ptr->kind == Type_RelativePointer ||
-		          rel_ptr->kind == Type_RelativeMultiPointer);
-		Type *pointer_type = nullptr;
-		Type *base_integer = nullptr;
-
-		if (rel_ptr->kind == Type_RelativePointer) {
-			pointer_type = rel_ptr->RelativePointer.pointer_type;
-			base_integer = rel_ptr->RelativePointer.base_integer;
-		} else if (rel_ptr->kind == Type_RelativeMultiPointer) {
-			pointer_type = rel_ptr->RelativeMultiPointer.pointer_type;
-			base_integer = rel_ptr->RelativeMultiPointer.base_integer;
-		}
-
-		value = lb_emit_conv(p, value, pointer_type);
-
-		GB_ASSERT(is_type_pointer(addr.addr.type));
-		lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
-		lbValue val_ptr = lb_emit_conv(p, value, t_uintptr);
-		lbValue offset = {};
-		offset.value = LLVMBuildSub(p->builder, val_ptr.value, ptr.value, "");
-		offset.type = t_uintptr;
-
-		if (!is_type_unsigned(base_integer)) {
-			offset = lb_emit_conv(p, offset, t_i64);
-		}
-		offset = lb_emit_conv(p, offset, base_integer);
-
-		lbValue offset_ptr = lb_emit_conv(p, addr.addr, alloc_type_pointer(base_integer));
-		offset = lb_emit_select(p,
-			lb_emit_comp(p, Token_CmpEq, val_ptr, lb_const_nil(p->module, t_uintptr)),
-			lb_const_nil(p->module, base_integer),
-			offset
-		);
-		LLVMBuildStore(p->builder, offset.value, offset_ptr.value);
-		return;
-
 	} else if (addr.kind == lbAddr_Map) {
 		lb_internal_dynamic_map_set(p, addr.addr, addr.map.type, addr.map.key, value, p->curr_stmt);
 		return;
@@ -1246,46 +1154,6 @@ gb_internal lbValue lb_addr_load(lbProcedure *p, lbAddr const &addr) {
 		}
 
 		return r;
-	} else if (addr.kind == lbAddr_RelativePointer) {
-		Type *rel_ptr = base_type(lb_addr_type(addr));
-		Type *base_integer = nullptr;
-		Type *pointer_type = nullptr;
-		GB_ASSERT(rel_ptr->kind == Type_RelativePointer ||
-		          rel_ptr->kind == Type_RelativeMultiPointer);
-
-		if (rel_ptr->kind == Type_RelativePointer) {
-			base_integer = rel_ptr->RelativePointer.base_integer;
-			pointer_type = rel_ptr->RelativePointer.pointer_type;
-		} else if (rel_ptr->kind == Type_RelativeMultiPointer) {
-			base_integer = rel_ptr->RelativeMultiPointer.base_integer;
-			pointer_type = rel_ptr->RelativeMultiPointer.pointer_type;
-		}
-
-		lbValue ptr = lb_emit_conv(p, addr.addr, t_uintptr);
-		lbValue offset = lb_emit_conv(p, ptr, alloc_type_pointer(base_integer));
-		offset = lb_emit_load(p, offset);
-
-
-		if (!is_type_unsigned(base_integer)) {
-			offset = lb_emit_conv(p, offset, t_i64);
-		}
-		offset = lb_emit_conv(p, offset, t_uintptr);
-		lbValue absolute_ptr = lb_emit_arith(p, Token_Add, ptr, offset, t_uintptr);
-		absolute_ptr = lb_emit_conv(p, absolute_ptr, pointer_type);
-
-		lbValue cond = lb_emit_comp(p, Token_CmpEq, offset, lb_const_nil(p->module, base_integer));
-
-		// NOTE(bill): nil check
-		lbValue nil_ptr = lb_const_nil(p->module, pointer_type);
-		lbValue final_ptr = {};
-		final_ptr.type = absolute_ptr.type;
-		final_ptr.value = LLVMBuildSelect(p->builder, cond.value, nil_ptr.value, absolute_ptr.value, "");
-
-		if (rel_ptr->kind == Type_RelativeMultiPointer) {
-			return final_ptr;
-		}
-		return lb_emit_load(p, final_ptr);
-
 	} else if (addr.kind == lbAddr_Map) {
 		Type *map_type = base_type(type_deref(addr.addr.type));
 		GB_ASSERT(map_type->kind == Type_Map);
@@ -2378,13 +2246,6 @@ gb_internal LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 
 	case Type_SimdVector:
 		return LLVMVectorType(lb_type(m, type->SimdVector.elem), cast(unsigned)type->SimdVector.count);
-
-	case Type_RelativePointer:
-		return lb_type_internal(m, type->RelativePointer.base_integer);
-	case Type_RelativeMultiPointer:
-		return lb_type_internal(m, type->RelativeMultiPointer.base_integer);
-
-
 		
 	case Type_Matrix:
 		{
diff --git a/src/llvm_backend_type.cpp b/src/llvm_backend_type.cpp
index f3fcc8de4..6c12b37be 100644
--- a/src/llvm_backend_type.cpp
+++ b/src/llvm_backend_type.cpp
@@ -61,8 +61,6 @@ gb_internal u64 lb_typeid_kind(lbModule *m, Type *type, u64 id=0) {
 	case Type_Proc:            kind = Typeid_Procedure;        break;
 	case Type_BitSet:          kind = Typeid_Bit_Set;          break;
 	case Type_SimdVector:      kind = Typeid_Simd_Vector;      break;
-	case Type_RelativePointer: kind = Typeid_Relative_Pointer; break;
-	case Type_RelativeMultiPointer: kind = Typeid_Relative_Multi_Pointer; break;
 	case Type_SoaPointer:      kind = Typeid_SoaPointer;       break;
 	case Type_BitField:        kind = Typeid_Bit_Field;        break;
 	}
@@ -950,30 +948,6 @@ gb_internal void lb_setup_type_info_data_giant_array(lbModule *m, i64 global_typ
 			}
 			break;
 
-		case Type_RelativePointer:
-			{
-				tag_type = t_type_info_relative_pointer;
-				LLVMValueRef vals[2] = {
-					get_type_info_ptr(m, t->RelativePointer.pointer_type),
-					get_type_info_ptr(m, t->RelativePointer.base_integer),
-				};
-
-				variant_value = llvm_const_named_struct(m, tag_type, vals, gb_count_of(vals));
-			}
-			break;
-
-		case Type_RelativeMultiPointer:
-			{
-				tag_type = t_type_info_relative_multi_pointer;
-				LLVMValueRef vals[2] = {
-					get_type_info_ptr(m, t->RelativeMultiPointer.pointer_type),
-					get_type_info_ptr(m, t->RelativeMultiPointer.base_integer),
-				};
-
-				variant_value = llvm_const_named_struct(m, tag_type, vals, gb_count_of(vals));
-			}
-			break;
-
 		case Type_Matrix:
 			{
 				tag_type = t_type_info_matrix;
diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp
index e6049da84..a2a0ba4cc 100644
--- a/src/llvm_backend_utility.cpp
+++ b/src/llvm_backend_utility.cpp
@@ -1131,10 +1131,6 @@ gb_internal lbValue lb_emit_struct_ep(lbProcedure *p, lbValue s, i32 index) {
 	Type *t = base_type(type_deref(s.type));
 	Type *result_type = nullptr;
 
-	if (is_type_relative_pointer(t)) {
-		s = lb_addr_get_ptr(p, lb_addr(s));
-	}
-
 	if (is_type_struct(t)) {
 		result_type = get_struct_field_type(t, index);
 	} else if (is_type_union(t)) {
@@ -1440,8 +1436,6 @@ gb_internal lbValue lb_emit_deep_field_gep(lbProcedure *p, lbValue e, Selection
 			e = lb_emit_array_epi(p, e, index);
 		} else if (type->kind == Type_Map) {
 			e = lb_emit_struct_ep(p, e, index);
-		} else if (type->kind == Type_RelativePointer) {
-			e = lb_emit_struct_ep(p, e, index);
 		} else {
 			GB_PANIC("un-gep-able type %s", type_to_string(type));
 		}
diff --git a/src/types.cpp b/src/types.cpp
index b49bce7d4..c51df7261 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -272,14 +272,6 @@ struct TypeProc {
 		Type *elem;                                       \
 		Type *generic_count;                              \
 	})                                                        \
-	TYPE_KIND(RelativePointer, struct {                       \
-		Type *pointer_type;                               \
-		Type *base_integer;                               \
-	})                                                        \
-	TYPE_KIND(RelativeMultiPointer, struct {                  \
-		Type *pointer_type;                               \
-		Type *base_integer;                               \
-	})                                                        \
 	TYPE_KIND(Matrix, struct {                                \
 		Type *elem;                                       \
 		i64   row_count;                                  \
@@ -367,8 +359,6 @@ enum Typeid_Kind : u8 {
 	Typeid_Map,
 	Typeid_Bit_Set,
 	Typeid_Simd_Vector,
-	Typeid_Relative_Pointer,
-	Typeid_Relative_Multi_Pointer,
 	Typeid_Matrix,
 	Typeid_SoaPointer,
 	Typeid_Bit_Field,
@@ -678,8 +668,6 @@ gb_global Type *t_type_info_enum                 = nullptr;
 gb_global Type *t_type_info_map                  = nullptr;
 gb_global Type *t_type_info_bit_set              = nullptr;
 gb_global Type *t_type_info_simd_vector          = nullptr;
-gb_global Type *t_type_info_relative_pointer     = nullptr;
-gb_global Type *t_type_info_relative_multi_pointer = nullptr;
 gb_global Type *t_type_info_matrix               = nullptr;
 gb_global Type *t_type_info_soa_pointer          = nullptr;
 gb_global Type *t_type_info_bit_field            = nullptr;
@@ -708,8 +696,6 @@ gb_global Type *t_type_info_enum_ptr             = nullptr;
 gb_global Type *t_type_info_map_ptr              = nullptr;
 gb_global Type *t_type_info_bit_set_ptr          = nullptr;
 gb_global Type *t_type_info_simd_vector_ptr      = nullptr;
-gb_global Type *t_type_info_relative_pointer_ptr = nullptr;
-gb_global Type *t_type_info_relative_multi_pointer_ptr = nullptr;
 gb_global Type *t_type_info_matrix_ptr           = nullptr;
 gb_global Type *t_type_info_soa_pointer_ptr      = nullptr;
 gb_global Type *t_type_info_bit_field_ptr        = nullptr;
@@ -1118,24 +1104,6 @@ gb_internal Type *alloc_type_bit_field() {
 	return t;
 }
 
-gb_internal Type *alloc_type_relative_pointer(Type *pointer_type, Type *base_integer) {
-	GB_ASSERT(is_type_pointer(pointer_type));
-	GB_ASSERT(is_type_integer(base_integer));
-	Type *t = alloc_type(Type_RelativePointer);
-	t->RelativePointer.pointer_type = pointer_type;
-	t->RelativePointer.base_integer = base_integer;
-	return t;
-}
-
-gb_internal Type *alloc_type_relative_multi_pointer(Type *pointer_type, Type *base_integer) {
-	GB_ASSERT(is_type_multi_pointer(pointer_type));
-	GB_ASSERT(is_type_integer(base_integer));
-	Type *t = alloc_type(Type_RelativeMultiPointer);
-	t->RelativeMultiPointer.pointer_type = pointer_type;
-	t->RelativeMultiPointer.base_integer = base_integer;
-	return t;
-}
-
 gb_internal Type *alloc_type_named(String name, Type *base, Entity *type_name) {
 	Type *t = alloc_type(Type_Named);
 	t->Named.name = name;
@@ -1227,8 +1195,6 @@ gb_internal Type *type_deref(Type *t, bool allow_multi_pointer) {
 		switch (bt->kind) {
 		case Type_Pointer:
 			return bt->Pointer.elem;
-		case Type_RelativePointer:
-			return type_deref(bt->RelativePointer.pointer_type);
 		case Type_SoaPointer:
 			{
 				Type *elem = base_type(bt->SoaPointer.elem);
@@ -1667,15 +1633,6 @@ gb_internal bool is_type_generic(Type *t) {
 	return t->kind == Type_Generic;
 }
 
-gb_internal bool is_type_relative_pointer(Type *t) {
-	t = base_type(t);
-	return t->kind == Type_RelativePointer;
-}
-gb_internal bool is_type_relative_multi_pointer(Type *t) {
-	t = base_type(t);
-	return t->kind == Type_RelativeMultiPointer;
-}
-
 gb_internal bool is_type_u8_slice(Type *t) {
 	t = base_type(t);
 	if (t->kind == Type_Slice) {
@@ -2118,8 +2075,6 @@ gb_internal bool is_type_indexable(Type *t) {
 		return true;
 	case Type_EnumeratedArray:
 		return true;
-	case Type_RelativeMultiPointer:
-		return true;
 	case Type_Matrix:
 		return true;
 	}
@@ -2137,8 +2092,6 @@ gb_internal bool is_type_sliceable(Type *t) {
 		return true;
 	case Type_EnumeratedArray:
 		return false;
-	case Type_RelativeMultiPointer:
-		return true;
 	case Type_Matrix:
 		return false;
 	}
@@ -2345,27 +2298,7 @@ gb_internal bool is_type_polymorphic(Type *t, bool or_specialized=false) {
 			return true;
 		}
 		break;
-
-	case Type_RelativeMultiPointer:
-		if (is_type_polymorphic(t->RelativeMultiPointer.pointer_type, or_specialized)) {
-			return true;
-		}
-		if (t->RelativeMultiPointer.base_integer != nullptr &&
-		    is_type_polymorphic(t->RelativeMultiPointer.base_integer, or_specialized)) {
-			return true;
-		}
-		break;
-	case Type_RelativePointer:
-		if (is_type_polymorphic(t->RelativePointer.pointer_type, or_specialized)) {
-			return true;
-		}
-		if (t->RelativePointer.base_integer != nullptr &&
-		    is_type_polymorphic(t->RelativePointer.base_integer, or_specialized)) {
-			return true;
-		}
-		break;
 	}
-
 	return false;
 }
 
@@ -2407,10 +2340,6 @@ gb_internal bool type_has_nil(Type *t) {
 			}
 		}
 		return false;
-
-	case Type_RelativePointer:
-	case Type_RelativeMultiPointer:
-		return true;
 	}
 	return false;
 }
@@ -2579,10 +2508,6 @@ gb_internal bool is_type_load_safe(Type *type) {
 		}
 		return true;
 
-	case Type_RelativePointer:
-	case Type_RelativeMultiPointer:
-		return true;
-
 	case Type_Pointer:
 	case Type_MultiPointer:
 	case Type_Slice:
@@ -3945,11 +3870,6 @@ gb_internal i64 type_align_of_internal(Type *t, TypePath *path) {
 	case Type_Matrix: 
 		return matrix_align_of(t, path);
 
-	case Type_RelativePointer:
-		return type_align_of_internal(t->RelativePointer.base_integer, path);
-	case Type_RelativeMultiPointer:
-		return type_align_of_internal(t->RelativeMultiPointer.base_integer, path);
-
 	case Type_SoaPointer:
 		return build_context.int_size;
 	}
@@ -4242,11 +4162,6 @@ gb_internal i64 type_size_of_internal(Type *t, TypePath *path) {
 
 	case Type_BitField:
 		return type_size_of_internal(t->BitField.backing_type, path);
-
-	case Type_RelativePointer:
-		return type_size_of_internal(t->RelativePointer.base_integer, path);
-	case Type_RelativeMultiPointer:
-		return type_size_of_internal(t->RelativeMultiPointer.base_integer, path);
 	}
 
 	// Catch all
@@ -4872,19 +4787,6 @@ gb_internal gbString write_type_to_string(gbString str, Type *type, bool shortha
 		str = gb_string_append_fmt(str, "#simd[%d]", cast(int)type->SimdVector.count);
 		str = write_type_to_string(str, type->SimdVector.elem);
 		break;
-
-	case Type_RelativePointer:
-		str = gb_string_append_fmt(str, "#relative(");
-		str = write_type_to_string(str, type->RelativePointer.base_integer);
-		str = gb_string_append_fmt(str, ") ");
-		str = write_type_to_string(str, type->RelativePointer.pointer_type);
-		break;
-	case Type_RelativeMultiPointer:
-		str = gb_string_append_fmt(str, "#relative(");
-		str = write_type_to_string(str, type->RelativePointer.base_integer);
-		str = gb_string_append_fmt(str, ") ");
-		str = write_type_to_string(str, type->RelativePointer.pointer_type);
-		break;
 		
 	case Type_Matrix:
 		if (type->Matrix.is_row_major) {