diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h
index 2f3961fc0..0546a7633 100644
--- a/tools/qfcc/include/type.h
+++ b/tools/qfcc/include/type.h
@@ -84,7 +84,7 @@ typedef struct type_s {
 		struct algebra_s *algebra;
 		struct multivector_s *multivec;
 		ty_alias_t  alias;
-	} t;
+	};
 	struct type_s *next;
 	int         freeable;
 	int         allocated;
diff --git a/tools/qfcc/source/algebra.c b/tools/qfcc/source/algebra.c
index b6e7a85f7..e3cac8ff8 100644
--- a/tools/qfcc/source/algebra.c
+++ b/tools/qfcc/source/algebra.c
@@ -327,7 +327,7 @@ algebra_init (algebra_t *a)
 		}
 	}
 	auto type = algebra_mvec_type (a, (1 << a->layout.count) - 1);
-	a->mvec_sym = type->t.multivec->mvec_sym;
+	a->mvec_sym = type->multivec->mvec_sym;
 }
 
 bool
@@ -406,7 +406,7 @@ algebra_type (const type_t *type, const expr_t *params)
 	t->meta = ty_algebra;
 	t->type = ev_invalid;
 	t->alignment = (dim > 1 ? 4 : 2) * type->alignment;
-	t->t.algebra = algebra;
+	t->algebra = algebra;
 	algebra->algebra_type = t;
 	return find_type (t);
 }
@@ -435,7 +435,7 @@ algebra_subtype (const type_t *type, attribute_t *attr)
 		}
 		return algebra_mvec_type (algebra, mask);
 	}
-	auto symtab = algebra->mvec_sym->type->t.symtab;
+	auto symtab = algebra->mvec_sym->type->symtab;
 	auto field = symtab_lookup (symtab, attr->name);
 	if (field) {
 		return field->type;
@@ -524,7 +524,7 @@ algebra_mvec_type (algebra_t *algebra, pr_uint_t group_mask)
 			.alignment = algebra_alignment (algebra->type, components),
 			.width = components,
 			.meta = ty_algebra,
-			.t.algebra = (algebra_t *) mvec,
+			.algebra = (algebra_t *) mvec,
 			.freeable = true,
 			.allocated = true,
 		};
@@ -662,7 +662,7 @@ algebra_scope (const type_t *type, symtab_t *curscope)
 		return scope;
 	}
 	scope->procsymbol = algebra_symbol;
-	scope->procsymbol_data = unalias_type (type)->t.algebra;
+	scope->procsymbol_data = unalias_type (type)->algebra;
 	return scope;
 }
 
@@ -671,9 +671,9 @@ algebra_get (const type_t *type)
 {
 	type = unalias_type (type);
 	if (type->type == ev_invalid) {
-		return type->t.algebra;
+		return type->algebra;
 	} else {
-		return type->t.multivec->algebra;
+		return type->multivec->algebra;
 	}
 }
 
@@ -700,11 +700,11 @@ void
 algebra_print_type_str (dstring_t *str, const type_t *type)
 {
 	if (type->type == ev_invalid) {
-		auto a = type->t.algebra;
+		auto a = type->algebra;
 		dasprintf (str, " algebra(%s(%d,%d,%d))", a->type->name,
 				   a->plus, a->minus, a->zero);
 	} else if (type->type == ev_float || type->type == ev_double) {
-		auto m = type->t.multivec;
+		auto m = type->multivec;
 		auto a = m->algebra;
 		dasprintf (str, " algebra(%s(%d,%d,%d):%04x)", a->type->name,
 				   a->plus, a->minus, a->zero, m->group_mask);
@@ -717,12 +717,12 @@ void
 algebra_encode_type (dstring_t *encoding, const type_t *type)
 {
 	if (type->type == ev_invalid) {
-		auto a = type->t.algebra;
+		auto a = type->algebra;
 		dasprintf (encoding, "{∧");
 		encode_type (encoding, a->type);
 		dasprintf (encoding, "(%d,%d,%d)}", a->plus, a->minus, a->zero);
 	} else if (type->type == ev_float || type->type == ev_double) {
-		auto m = type->t.multivec;
+		auto m = type->multivec;
 		auto a = m->algebra;
 		dasprintf (encoding, "{∧");
 		encode_type (encoding, a->type);
@@ -737,10 +737,10 @@ int
 algebra_type_size (const type_t *type)
 {
 	if (type->type == ev_invalid) {
-		auto a = type->t.algebra;
+		auto a = type->algebra;
 		return a->num_components * type_size (a->type);
 	} else if (type->type == ev_float || type->type == ev_double) {
-		auto m = type->t.multivec;
+		auto m = type->multivec;
 		int  size = 0;
 		if (m->group_mask & (m->group_mask - 1)) {
 			if (!m->mvec_sym) {
@@ -762,7 +762,7 @@ algebra_type_width (const type_t *type)
 	if (type->type == ev_invalid) {
 		return 0;
 	} else if (type->type == ev_float || type->type == ev_double) {
-		auto m = type->t.multivec;
+		auto m = type->multivec;
 		return m->num_components;
 	} else {
 		internal_error (0, "invalid algebra type");
@@ -793,7 +793,7 @@ algebra_type_assignable (const type_t *dst, const type_t *src)
 		if (src->meta != ty_algebra) {
 			return 0;
 		}
-		if (src->t.multivec->algebra != dst->t.algebra) {
+		if (src->multivec->algebra != dst->algebra) {
 			return 0;
 		}
 		// the multivec is a member of the destination algebra
@@ -801,10 +801,10 @@ algebra_type_assignable (const type_t *dst, const type_t *src)
 	}
 	if (!is_algebra (src)) {
 		if (is_scalar (src)) {
-			auto algebra = dst->t.multivec->algebra;
+			auto algebra = dst->multivec->algebra;
 			auto layout = &algebra->layout;
 			int group = layout->group_map[layout->mask_map[0]][0];
-			if (dst->t.multivec->group_mask & (1u << group)) {
+			if (dst->multivec->group_mask & (1u << group)) {
 				// the source scalar is a member of the destination
 				// multi-vector
 				return 1;
@@ -812,10 +812,10 @@ algebra_type_assignable (const type_t *dst, const type_t *src)
 		}
 		return 0;
 	}
-	if (dst->t.multivec->algebra != src->t.multivec->algebra) {
+	if (dst->multivec->algebra != src->multivec->algebra) {
 		return 0;
 	}
-	if (src->t.multivec->group_mask & ~dst->t.multivec->group_mask) {
+	if (src->multivec->group_mask & ~dst->multivec->group_mask) {
 		return 0;
 	}
 	// the source multi-vector is a subset of the destinatin multi-vector
@@ -826,7 +826,7 @@ const type_t *
 algebra_base_type (const type_t *type)
 {
 	if (type->type == ev_invalid) {
-		return type->t.algebra->type;
+		return type->algebra->type;
 	}
 	return ev_types[type->type];
 }
@@ -837,9 +837,9 @@ algebra_struct_type (const type_t *type)
 	symbol_t   *sym = 0;
 
 	if (type->type == ev_invalid) {
-		sym = type->t.algebra->mvec_sym;
+		sym = type->algebra->mvec_sym;
 	} else {
-		sym = type->t.multivec->mvec_sym;
+		sym = type->multivec->mvec_sym;
 	}
 	return sym ? sym->type : 0;
 }
@@ -861,7 +861,7 @@ is_mono_grade (const type_t *type)
 	}
 	auto alg = algebra_get (type);
 	auto layout = &alg->layout;
-	auto multivec = type->t.multivec;
+	auto multivec = type->multivec;
 	int  grade = -1;
 	for (int i = 0; i < layout->count; i++) {
 		pr_uint_t   mask = 1u << i;
@@ -892,7 +892,7 @@ algebra_get_grade (const type_t *type)
 	}
 	auto alg = algebra_get (type);
 	auto layout = &alg->layout;
-	auto multivec = type->t.multivec;
+	auto multivec = type->multivec;
 	for (int i = 0; i < layout->count; i++) {
 		pr_uint_t   mask = 1u << i;
 		if (mask & multivec->group_mask) {
diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c
index 8f6ec54d9..4c30e6b86 100644
--- a/tools/qfcc/source/class.c
+++ b/tools/qfcc/source/class.c
@@ -415,10 +415,10 @@ is_id (const type_t *type)
 	// a qualified obj_object struct
 	if (type->type != ev_ptr)
 		return 0;
-	if (!is_struct (type->t.fldptr.type))
+	if (!is_struct (type->fldptr.type))
 		return 0;
 	// if the the symtabs match, then type is id in disguise
-	if (type->t.fldptr.type->t.symtab == type_object.t.symtab)
+	if (type->fldptr.type->symtab == type_object.symtab)
 		return 1;
 	return 0;
 }
@@ -447,7 +447,7 @@ is_classptr (const type_t *type)
 		return 1;
 	if (type->type != ev_ptr)
 		return 0;
-	type = type->t.fldptr.type;
+	type = type->fldptr.type;
 	if (is_class (type))
 		return 1;
 	return 0;
@@ -481,9 +481,9 @@ static protocollist_t *
 obj_get_class_protos (const type_t *type)
 {
 	if (is_ptr (type))
-		type = type->t.fldptr.type;
+		type = type->fldptr.type;
 	if (is_class (type))
-		return type->t.class->protocols;
+		return type->class->protocols;
 	return 0;
 }
 
@@ -491,7 +491,7 @@ static protocollist_t *
 obj_get_protos (const type_t *type)
 {
 	if (is_ptr (type))
-		type = type->t.fldptr.type;
+		type = type->fldptr.type;
 	return type->protos;
 }
 
@@ -499,9 +499,9 @@ static category_t *
 obj_get_categories (const type_t *type)
 {
 	if (is_ptr (type))
-		type = type->t.fldptr.type;
+		type = type->fldptr.type;
 	if (is_class (type))
-		return type->t.class->categories;
+		return type->class->categories;
 	return 0;
 }
 
@@ -520,9 +520,9 @@ obj_classname (const type_t *type)
 		dstring_copystr (str, "Class");
 	} else {
 		if (is_ptr (type))
-			type = type->t.fldptr.type;
+			type = type->fldptr.type;
 		if (is_class (type))
-			dstring_copystr (str, type->t.class->name);
+			dstring_copystr (str, type->class->name);
 	}
 	if ((protos = obj_get_protos (type)))
 		print_protocollist (str, protos);
@@ -595,9 +595,9 @@ obj_types_assignable (const type_t *dst, const type_t *src)
 		return 1;
 
 	// check dst is a base class of src
-	dst_class = dst->t.fldptr.type->t.class;
-	if (src->t.fldptr.type->meta == ty_class) {
-		src_class = src->t.fldptr.type->t.class;
+	dst_class = dst->fldptr.type->class;
+	if (src->fldptr.type->meta == ty_class) {
+		src_class = src->fldptr.type->class;
 	}
 	//printf ("%s %s\n", dst_class->name, src_class->name);
 	while (dst_class != src_class && src_class) {
@@ -714,7 +714,7 @@ get_class (symbol_t *sym, int create)
 	new.type = ev_invalid;
 	new.name = c->name;
 	new.meta = ty_class;
-	new.t.class = c;
+	new.class = c;
 	c->type = find_type (&new);
 	if (sym)
 		sym->type = c->type;
@@ -913,7 +913,7 @@ begin_class (class_t *class)
 		// root class of the hierachy.
 		// NOTE: type_class is not actually a class
 		EMIT_DEF (space, meta->ivars,
-				  emit_ivars (type_class.t.symtab, "Class"));
+				  emit_ivars (type_class.symtab, "Class"));
 	} else {
 		meta->ivars = 0;
 	}
@@ -1254,7 +1254,7 @@ class_message_response (const type_t *clstype, int class_msg, const expr_t *sel)
 		return 0;
 	}
 	if (is_id (clstype)) {
-		protocollist_t *protos = clstype->t.fldptr.type->protos;
+		protocollist_t *protos = clstype->fldptr.type->protos;
 		if (protos) {
 			if ((m = protocollist_find_method (protos, selector, !class_msg))) {
 				return m;
@@ -1267,9 +1267,9 @@ class_message_response (const type_t *clstype, int class_msg, const expr_t *sel)
 		}
 	} else {
 		if (is_class (clstype)) {
-			class = clstype->t.class;
-		} else if (is_class (clstype->t.fldptr.type)) {
-			class = clstype->t.fldptr.type->t.class;
+			class = clstype->class;
+		} else if (is_class (clstype->fldptr.type)) {
+			class = clstype->fldptr.type->class;
 		}
 		if (class && !is_object(class->type)) {
 			if (!class->interface_declared) {
@@ -1503,7 +1503,7 @@ emit_symtab_ref_cnt (def_t *def, void *data, int index)
 		internal_error (0, "%s: expected int def", __FUNCTION__);
 	D_INT (def) = 0;
 	if (da->refs)
-		D_INT (def) = da->refs->type->t.array.size;
+		D_INT (def) = da->refs->type->array.size;
 }
 
 static void
diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c
index c1d34b07a..6d42339fb 100644
--- a/tools/qfcc/source/def.c
+++ b/tools/qfcc/source/def.c
@@ -155,7 +155,7 @@ new_def (const char *name, const type_t *type, defspace_t *space,
 	if (is_class (type)
 		|| (is_array (type) && is_class(dereference_type (type)))) {
 		error (0, "statically allocated instance of class %s",
-			   type->t.class->name);
+			   type->class->name);
 		return def;
 	}
 
@@ -300,7 +300,7 @@ def_to_ddef (def_t *def, ddef_t *ddef, int aux)
 	const type_t *type = unalias_type (def->type);
 
 	if (aux)
-		type = type->t.fldptr.type;	// aux is true only for fields
+		type = type->fldptr.type;	// aux is true only for fields
 	ddef->type = type->type;
 	ddef->ofs = def->offset;
 	ddef->name = ReuseString (def->name);
diff --git a/tools/qfcc/source/dot_type.c b/tools/qfcc/source/dot_type.c
index 474c9c3ef..bcef94b88 100644
--- a/tools/qfcc/source/dot_type.c
+++ b/tools/qfcc/source/dot_type.c
@@ -56,7 +56,7 @@ static void
 print_pointer (dstring_t *dstr, const type_t *t, int level, int id)
 {
 	int         indent = level * 2 + 2;
-	auto aux = t->t.fldptr.type;
+	auto aux = t->fldptr.type;
 
 	dot_print_type (dstr, aux, level, id);
 	dasprintf (dstr, "%*st_%p -> \"t_%p\";\n", indent, "", t, aux);
@@ -81,7 +81,7 @@ static void
 print_function (dstring_t *dstr, const type_t *t, int level, int id)
 {
 	int         indent = level * 2 + 2;
-	const ty_func_t *func = &t->t.func;
+	const ty_func_t *func = &t->func;
 	const type_t *ret = func->ret_type;
 	const type_t *param;
 
@@ -132,7 +132,7 @@ static void
 print_struct (dstring_t *dstr, const type_t *t, int level, int id)
 {
 	int         indent = level * 2 + 2;
-	const symtab_t *symtab = t->t.symtab;
+	const symtab_t *symtab = t->symtab;
 	const symbol_t *sym;
 	int         pnum;
 	static const char *struct_type_names[3] = {"struct", "union", "enum"};
@@ -189,17 +189,16 @@ static void
 print_array (dstring_t *dstr, const type_t *t, int level, int id)
 {
 	int         indent = level * 2 + 2;
-	auto type = t->t.array.type;
+	auto type = t->array.type;
 
 	dot_print_type (dstr, type, level, id);
 	dasprintf (dstr, "%*st_%p -> \"t_%p\";\n", indent, "", t, type);
-	if (t->t.array.base) {
+	if (t->array.base) {
 		dasprintf (dstr, "%*st_%p [label=\"[%d..%d]\"];\n", indent, "", t,
-				   t->t.array.base,
-				   t->t.array.base + t->t.array.size - 1);
+				   t->array.base, t->array.base + t->array.size - 1);
 	} else {
 		dasprintf (dstr, "%*st_%p [label=\"[%d]\"];\n", indent, "", t,
-				   t->t.array.size);
+				   t->array.size);
 	}
 }
 
@@ -208,15 +207,15 @@ print_class (dstring_t *dstr, const type_t *t, int level, int id)
 {
 	int         indent = level * 2 + 2;
 	dasprintf (dstr, "%*st_%p [label=\"class '%s'\"];\n", indent, "", t,
-			   t->t.class->name);
+			   t->class->name);
 }
 
 static void
 print_alias (dstring_t *dstr, const type_t *t, int level, int id)
 {
 	int         indent = level * 2 + 2;
-	auto aux = t->t.alias.aux_type;
-	auto full = t->t.alias.full_type;
+	auto aux = t->alias.aux_type;
+	auto full = t->alias.full_type;
 
 	dot_print_type (dstr, aux, level, id);
 	dot_print_type (dstr, full, level, id);
diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c
index 51019fca3..0c8a5c2dc 100644
--- a/tools/qfcc/source/emit.c
+++ b/tools/qfcc/source/emit.c
@@ -92,7 +92,7 @@ get_value_def (const expr_t *expr, ex_value_t *value, const type_t *type)
 	}
 	if (is_ptr (type) && value->pointer.tempop && !value->pointer.def) {
 		value->pointer.def = get_tempop_def (expr, value->pointer.tempop,
-											 type->t.fldptr.type);
+											 type->fldptr.type);
 	}
 	def = emit_value (value, 0);
 	if (type != def->type)
diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c
index adb24a0f6..e261a9262 100644
--- a/tools/qfcc/source/expr.c
+++ b/tools/qfcc/source/expr.c
@@ -1466,7 +1466,7 @@ get_name (const expr_t *e)
 symbol_t *
 get_struct_field (const type_t *t1, const expr_t *e1, const expr_t *e2)
 {
-	symtab_t   *strct = t1->t.symtab;
+	symtab_t   *strct = t1->symtab;
 	symbol_t   *sym = get_name (e2);
 	symbol_t   *field;
 
@@ -1527,15 +1527,15 @@ field_expr (const expr_t *e1, const expr_t *e2)
 				return e2;
 			if (t2->type == ev_field) {
 				e = new_binary_expr ('.', e1, e2);
-				e->expr.type = t2->t.fldptr.type;
+				e->expr.type = t2->fldptr.type;
 				return e;
 			}
 		}
 	} else if (is_ptr (t1)) {
-		if (is_struct (t1->t.fldptr.type) || is_union (t1->t.fldptr.type)) {
+		if (is_struct (t1->fldptr.type) || is_union (t1->fldptr.type)) {
 			symbol_t   *field;
 
-			field = get_struct_field (t1->t.fldptr.type, e1, e2);
+			field = get_struct_field (t1->fldptr.type, e1, e2);
 			if (!field)
 				return e1;
 
@@ -1546,8 +1546,8 @@ field_expr (const expr_t *e1, const expr_t *e2)
 			}
 			e1 = cast_expr (pointer_type (field->type), e1);
 			return unary_expr ('.', e1);
-		} else if (is_class (t1->t.fldptr.type)) {
-			class_t    *class = t1->t.fldptr.type->t.class;
+		} else if (is_class (t1->fldptr.type)) {
+			class_t    *class = t1->fldptr.type->class;
 			symbol_t   *sym = e2->symbol;//FIXME need to check
 			symbol_t   *ivar;
 			int         protected = class_access (current_class, class);
@@ -2115,7 +2115,7 @@ bitnot_expr:
 					return error (e, "invalid type for unary .");
 				scoped_src_loc (e);
 				auto new = new_unary_expr ('.', e);
-				new->expr.type = get_type (e)->t.fldptr.type;
+				new->expr.type = get_type (e)->fldptr.type;
 				return new;
 			}
 		case '+':
@@ -2169,24 +2169,24 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
 		return error (fexpr, "more than %d parameters", PR_MAX_PARAMS);
 	}
 
-	if (ftype->t.func.num_params < -1) {
-		if (-arg_count > ftype->t.func.num_params + 1) {
+	if (ftype->func.num_params < -1) {
+		if (-arg_count > ftype->func.num_params + 1) {
 			if (!options.traditional)
 				return error (fexpr, "too few arguments");
 			if (options.warnings.traditional)
 				warning (fexpr, "too few arguments");
 		}
-		param_count = -ftype->t.func.num_params - 1;
-	} else if (ftype->t.func.num_params >= 0) {
-		if (arg_count > ftype->t.func.num_params) {
+		param_count = -ftype->func.num_params - 1;
+	} else if (ftype->func.num_params >= 0) {
+		if (arg_count > ftype->func.num_params) {
 			return error (fexpr, "too many arguments");
-		} else if (arg_count < ftype->t.func.num_params) {
+		} else if (arg_count < ftype->func.num_params) {
 			if (!options.traditional)
 				return error (fexpr, "too few arguments");
 			if (options.warnings.traditional)
 				warning (fexpr, "too few arguments");
 		}
-		param_count = ftype->t.func.num_params;
+		param_count = ftype->func.num_params;
 	}
 
 	const type_t *arg_types[arg_count + 1];
@@ -2197,7 +2197,7 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
 
 		if (e->type == ex_compound) {
 			if (i < param_count) {
-				t = ftype->t.func.param_types[i];
+				t = ftype->func.param_types[i];
 			} else {
 				return error (e, "cannot pass compound initializer "
 							  "through ...");
@@ -2219,16 +2219,16 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
 		}
 		if (i < param_count) {
 			if (e->type == ex_nil)
-				e = convert_nil (e, t = ftype->t.func.param_types[i]);
+				e = convert_nil (e, t = ftype->func.param_types[i]);
 			if (e->type == ex_bool)
-				e = convert_from_bool (e, ftype->t.func.param_types[i]);
+				e = convert_from_bool (e, ftype->func.param_types[i]);
 			if (e->type == ex_error)
 				return e;
-			if (!type_assignable (ftype->t.func.param_types[i], t)) {
+			if (!type_assignable (ftype->func.param_types[i], t)) {
 				err = param_mismatch (e, i + 1, fexpr->symbol->name,
-									  ftype->t.func.param_types[i], t);
+									  ftype->func.param_types[i], t);
 			}
-			t = ftype->t.func.param_types[i];
+			t = ftype->func.param_types[i];
 		} else {
 			if (e->type == ex_nil)
 				e = convert_nil (e, t = type_nil);
@@ -2261,8 +2261,8 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
 	}
 
 	bool        emit_args = false;
-	if (ftype->t.func.num_params < 0) {
-		emit_args = !ftype->t.func.no_va_list;
+	if (ftype->func.num_params < 0) {
+		emit_args = !ftype->func.no_va_list;
 	}
 	scoped_src_loc (fexpr);
 	call = new_block_expr (0);
@@ -2314,7 +2314,7 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
 							  arg_exprs[arg_expr_count - 1][0]);
 		append_expr (call, e);
 	}
-	auto ret_type = ftype->t.func.ret_type;
+	auto ret_type = ftype->func.ret_type;
 	call->block.result = call_expr (fexpr, args, ret_type);
 	return call;
 }
@@ -2430,7 +2430,7 @@ const expr_t *
 return_expr (function_t *f, const expr_t *e)
 {
 	const type_t *t;
-	const type_t *ret_type = unalias_type (f->type->t.func.ret_type);
+	const type_t *ret_type = unalias_type (f->type->func.ret_type);
 
 	e = convert_name (e);
 	if (!e) {
@@ -2500,7 +2500,7 @@ return_expr (function_t *f, const expr_t *e)
 	} else {
 		if (ret_type != t) {
 			e = cast_expr ((type_t *) ret_type, e);//FIXME cast
-			t = f->sym->type->t.func.ret_type;
+			t = f->sym->type->func.ret_type;
 		}
 	}
 	if (e->type == ex_vector) {
@@ -2515,7 +2515,7 @@ return_expr (function_t *f, const expr_t *e)
 const expr_t *
 at_return_expr (function_t *f, const expr_t *e)
 {
-	const type_t *ret_type = unalias_type (f->type->t.func.ret_type);
+	const type_t *ret_type = unalias_type (f->type->func.ret_type);
 
 	if (!is_void(ret_type)) {
 		return error (e, "use of @return in non-void function");
@@ -2528,7 +2528,7 @@ at_return_expr (function_t *f, const expr_t *e)
 	}
 	const expr_t *call_expr = e->block.result->branch.target;
 	const auto call_type = get_type (call_expr);
-	if (!is_func (call_type) && !call_type->t.func.void_return) {
+	if (!is_func (call_type) && !call_type->func.void_return) {
 		return error (e, "@return function not void_return");
 	}
 	expr_t     *ret_expr = new_return_expr (e);
@@ -2651,10 +2651,10 @@ array_expr (const expr_t *array, const expr_t *index)
 	if (is_int_val (index))
 		ind = expr_int (index);
 	if (is_array (array_type)
-		&& array_type->t.array.size
+		&& array_type->array.size
 		&& is_constant (index)
-		&& (ind < array_type->t.array.base
-			|| ind - array_type->t.array.base >= array_type->t.array.size)) {
+		&& (ind < array_type->array.base
+			|| ind - array_type->array.base >= array_type->array.size)) {
 		return error (index, "array index out of bounds");
 	}
 	if (is_nonscalar (array_type)
@@ -2664,9 +2664,9 @@ array_expr (const expr_t *array, const expr_t *index)
 	}
 	if (is_array (array_type)) {
 		ele_type = dereference_type (array_type);
-		base = new_int_expr (array_type->t.array.base, false);
+		base = new_int_expr (array_type->array.base, false);
 	} else if (is_ptr (array_type)) {
-		ele_type = array_type->t.fldptr.type;
+		ele_type = array_type->fldptr.type;
 		base = new_int_expr (0, false);
 	} else {
 		ele_type = ev_types[array_type->type];
@@ -2735,7 +2735,7 @@ offset_pointer_expr (const expr_t *pointer, const expr_t *offset)
 		if (pointer->address.offset) {
 			offset = binary_expr ('+', pointer->address.offset, offset);
 		}
-		ptr = new_address_expr (ptr_type->t.fldptr.type,
+		ptr = new_address_expr (ptr_type->fldptr.type,
 								pointer->address.lvalue, offset);
 		return ptr;
 	} else {
@@ -3059,8 +3059,8 @@ think_expr (symbol_t *think_sym)
 	sym = symtab_lookup (current_symtab, "think");
 	if (sym && sym->sy_type == sy_var && sym->type
 		&& sym->type->type == ev_field
-		&& sym->type->t.fldptr.type->type == ev_func) {
-		think_sym->type = sym->type->t.fldptr.type;
+		&& sym->type->fldptr.type->type == ev_func) {
+		think_sym->type = sym->type->fldptr.type;
 	} else {
 		think_sym->type = &type_func;
 	}
diff --git a/tools/qfcc/source/expr_algebra.c b/tools/qfcc/source/expr_algebra.c
index 4ebc308d7..22b213a44 100644
--- a/tools/qfcc/source/expr_algebra.c
+++ b/tools/qfcc/source/expr_algebra.c
@@ -53,7 +53,7 @@ get_group (const type_t *type, algebra_t *algebra)
 	}
 	pr_uint_t group_mask = (1u << layout->count) - 1;
 	if (type->type != ev_invalid) {
-		group_mask = type->t.multivec->group_mask;
+		group_mask = type->multivec->group_mask;
 	}
 	if (group_mask & (group_mask - 1)) {
 		internal_error (0, "multi-group mult-vector");
@@ -72,7 +72,7 @@ get_group_mask (const type_t *type, algebra_t *algebra)
 		if (type->type == ev_invalid) {
 			return (1 << algebra->layout.count) - 1;
 		}
-		return type->t.multivec->group_mask;
+		return type->multivec->group_mask;
 	}
 }
 
@@ -246,11 +246,11 @@ get_mvec_struct (const type_t *type)
 {
 	symbol_t   *sym = 0;
 	if (type->type == ev_invalid) {
-		sym = type->t.algebra->mvec_sym;
+		sym = type->algebra->mvec_sym;
 	} else {
-		sym = type->t.multivec->mvec_sym;
+		sym = type->multivec->mvec_sym;
 	}
-	return sym ? sym->type->t.symtab : 0;
+	return sym ? sym->type->symtab : 0;
 }
 
 static symbol_t *
@@ -309,7 +309,7 @@ mvec_expr (const expr_t *expr, algebra_t *algebra)
 	auto layout = &algebra->layout;
 	pr_uint_t group_mask = (1u << layout->count) - 1;
 	if (mvtype->type != ev_invalid) {
-		group_mask = mvtype->t.multivec->group_mask;
+		group_mask = mvtype->multivec->group_mask;
 	}
 	if (!(group_mask & (group_mask - 1))) {
 		return expr;
@@ -346,7 +346,7 @@ mvec_scatter (const expr_t **components, const expr_t *mvec, algebra_t *algebra)
 			if (type->type == ev_invalid) {
 				internal_error (mvec, "full algebra in mvec_scatter");
 			}
-			pr_uint_t mask = type->t.multivec->group_mask;
+			pr_uint_t mask = type->multivec->group_mask;
 			if (mask & (mask - 1)) {
 				internal_error (mvec, "bare multivector in mvec_scatter");
 			}
@@ -361,7 +361,7 @@ mvec_scatter (const expr_t **components, const expr_t *mvec, algebra_t *algebra)
 		if (!is_algebra (ct)) {
 			group = layout->group_map[layout->mask_map[0]][0];
 		} else if (ct->meta == ty_algebra && ct->type != ev_invalid) {
-			pr_uint_t mask = ct->t.multivec->group_mask;
+			pr_uint_t mask = ct->multivec->group_mask;
 			if (mask & (mask - 1)) {
 				internal_error (mvec, "multivector in multivec expression");
 			}
@@ -3023,7 +3023,7 @@ algebra_field_expr (const expr_t *mvec, const expr_t *field_name)
 	auto mvec_struct = get_mvec_struct (mvec_type);
 	auto field = mvec_struct ? symtab_lookup (mvec_struct, field_sym->name) : 0;
 	if (!field) {
-		mvec_struct = algebra->mvec_sym->type->t.symtab;
+		mvec_struct = algebra->mvec_sym->type->symtab;
 		field = symtab_lookup (mvec_struct, field_sym->name);
 		if (field) {
 			debug (field_name, "'%s' not in sub-type '%s' of '%s', "
diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c
index 68febbc14..9b417938f 100644
--- a/tools/qfcc/source/expr_assign.c
+++ b/tools/qfcc/source/expr_assign.c
@@ -366,7 +366,7 @@ assign_expr (const expr_t *dst, const expr_t *src)
 	if (is_ptr (dst_type) && is_array (src_type)) {
 		// assigning an array to a pointer is the same as taking the address of
 		// the array but using the type of the array elements
-		src = address_expr (src, src_type->t.fldptr.type);
+		src = address_expr (src, src_type->fldptr.type);
 		src_type = get_type (src);
 	}
 	if (src->type == ex_bool) {
diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c
index feca35607..406986568 100644
--- a/tools/qfcc/source/expr_binary.c
+++ b/tools/qfcc/source/expr_binary.c
@@ -924,7 +924,7 @@ pointer_arithmetic (int op, const expr_t *e1, const expr_t *e2)
 		}
 		e1 = cast_expr (&type_int, e1);
 		e2 = cast_expr (&type_int, e2);
-		psize = new_int_expr (type_size (t1->t.fldptr.type), false);
+		psize = new_int_expr (type_size (t1->fldptr.type), false);
 		return binary_expr ('/', binary_expr ('-', e1, e2), psize);
 	} else if (is_ptr (t1)) {
 		offset = cast_expr (&type_int, e2);
@@ -936,7 +936,7 @@ pointer_arithmetic (int op, const expr_t *e1, const expr_t *e2)
 		ptype = t2;
 	}
 	// op is known to be + or -
-	psize = new_int_expr (type_size (ptype->t.fldptr.type), false);
+	psize = new_int_expr (type_size (ptype->fldptr.type), false);
 	offset = unary_expr (op, binary_expr ('*', offset, psize));
 	return offset_pointer_expr (ptr, offset);
 }
diff --git a/tools/qfcc/source/expr_cast.c b/tools/qfcc/source/expr_cast.c
index b8db7eed4..516945c4d 100644
--- a/tools/qfcc/source/expr_cast.c
+++ b/tools/qfcc/source/expr_cast.c
@@ -130,7 +130,7 @@ cast_expr (const type_t *dstType, const expr_t *e)
 		return cast_error (e, srcType, dstType);
 	}
 	if (is_array (srcType)) {
-		return address_expr (e, dstType->t.fldptr.type);
+		return address_expr (e, dstType->fldptr.type);
 	}
 	if (is_short (srcType)) {
 		e = new_int_expr (expr_short (e), false);
diff --git a/tools/qfcc/source/expr_compound.c b/tools/qfcc/source/expr_compound.c
index bac59f77b..b74150d03 100644
--- a/tools/qfcc/source/expr_compound.c
+++ b/tools/qfcc/source/expr_compound.c
@@ -108,7 +108,7 @@ designator_field (const designator_t *des, const type_t *type)
 		error (des->index, "designator index in non-array");
 		return 0;
 	}
-	symtab_t   *symtab = type->t.symtab;
+	symtab_t   *symtab = type->symtab;
 	symbol_t   *sym = des->field->symbol;
 	symbol_t   *field = symtab_lookup (symtab, sym->name);
 	if (!field) {
@@ -161,12 +161,12 @@ get_designated_offset (const type_t *type, const designator_t *des)
 		offset = field->offset;
 		ele_type = field->type;
 	} else if (is_array (type)) {
-		int         array_size = type->t.array.size;
+		int         array_size = type->array.size;
 		ele_type = dereference_type (type);
 		offset = designator_index (des, type_size (ele_type), array_size);
 	} else if (is_nonscalar (type)) {
 		ele_type = ev_types[type->type];
-		if (type->t.symtab && des->field) {
+		if (type->symtab && des->field) {
 			field = designator_field (des, type);
 			offset = field->offset;
 		} else {
@@ -220,8 +220,8 @@ build_element_chain (element_chain_t *element_chain, const type_t *type,
 		}
 		type = t;
 	} else if (is_struct (type) || is_union (type)
-			   || (is_nonscalar (type) && type->t.symtab)) {
-		state.field = type->t.symtab->symbols;
+			   || (is_nonscalar (type) && type->symtab)) {
+		state.field = type->symtab->symbols;
 		while (state.field && skip_field (state.field)) {
 			state.field = state.field->next;
 		}
diff --git a/tools/qfcc/source/expr_obj.c b/tools/qfcc/source/expr_obj.c
index 36dbf66e1..4e21f76f5 100644
--- a/tools/qfcc/source/expr_obj.c
+++ b/tools/qfcc/source/expr_obj.c
@@ -99,13 +99,13 @@ selector_expr (keywordarg_t *selector)
 	selector = (keywordarg_t *) reverse_params ((param_t *) selector);
 	selector_name (sel_id, selector);
 	index = selector_index (sel_id->str);
-	index *= type_size (type_SEL.t.fldptr.type);
+	index *= type_size (type_SEL.fldptr.type);
 	sel_sym = make_symbol ("_OBJ_SELECTOR_TABLE_PTR", &type_SEL,
 						   pr.near_data, sc_static);
 	if (!sel_sym->table) {
 		symtab_addsymbol (pr.symtab, sel_sym);
 		sel_table = make_symbol ("_OBJ_SELECTOR_TABLE",
-								 array_type (type_SEL.t.fldptr.type, 0),
+								 array_type (type_SEL.fldptr.type, 0),
 								 pr.far_data, sc_extern);
 		if (!sel_table->table)
 			symtab_addsymbol (pr.symtab, sel_table);
@@ -211,7 +211,7 @@ message_expr (const expr_t *receiver, keywordarg_t *message)
 		} else if (receiver->symbol->sy_type == sy_class) {
 			class_t    *class;
 			rec_type = receiver->symbol->type;
-			class = rec_type->t.class;
+			class = rec_type->class;
 			class_msg = 1;
 			receiver = new_symbol_expr (class_pointer_symbol (class));
 		}
@@ -226,7 +226,7 @@ message_expr (const expr_t *receiver, keywordarg_t *message)
 	return_type = &type_id;
 	method = class_message_response (rec_type, class_msg, selector);
 	if (method)
-		return_type = method->type->t.func.ret_type;
+		return_type = method->type->func.ret_type;
 
 	scoped_src_loc (receiver);
 	expr_t     *args = new_list_expr (0);
diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c
index 62c997a72..928b33b30 100644
--- a/tools/qfcc/source/function.c
+++ b/tools/qfcc/source/function.c
@@ -278,7 +278,7 @@ parse_generic_function (const char *name, specifier_t spec)
 	// fake parameter for the return type
 	param_t ret_param = {
 		.next = spec.sym->params,
-		.type = spec.sym->type->t.func.ret_type,
+		.type = spec.sym->type->func.ret_type,
 		.type_expr = spec.type_expr,
 	};
 	int num_params = 0;
@@ -448,8 +448,8 @@ parse_params (const type_t *return_type, param_t *parms)
 	new->alignment = 1;
 	new->width = 1;
 	new->columns = 1;
-	new->t.func.ret_type = return_type;
-	new->t.func.num_params = 0;
+	new->func.ret_type = return_type;
+	new->func.num_params = 0;
 
 	for (p = parms; p; p = p->next) {
 		if (p->type) {
@@ -457,21 +457,21 @@ parse_params (const type_t *return_type, param_t *parms)
 		}
 	}
 	if (count) {
-		new->t.func.param_types = malloc (count * sizeof (type_t));
+		new->func.param_types = malloc (count * sizeof (type_t));
 	}
 	for (p = parms; p; p = p->next) {
 		if (!p->selector && !p->type && !p->name) {
 			if (p->next)
 				internal_error (0, 0);
-			new->t.func.num_params = -(new->t.func.num_params + 1);
+			new->func.num_params = -(new->func.num_params + 1);
 		} else if (p->type) {
 			if (is_class (p->type)) {
 				error (0, "cannot use an object as a parameter (forgot *?)");
 				p->type = &type_id;
 			}
 			auto ptype = unalias_type (p->type);
-			new->t.func.param_types[new->t.func.num_params] = ptype;
-			new->t.func.num_params++;
+			new->func.param_types[new->func.num_params] = ptype;
+			new->func.num_params++;
 		}
 	}
 	return new;
@@ -596,8 +596,8 @@ func_compare (const void *a, const void *b)
 	overloaded_function_t *fb = *(overloaded_function_t **) b;
 	const type_t *ta = fa->type;
 	const type_t *tb = fb->type;
-	int         na = ta->t.func.num_params;
-	int         nb = tb->t.func.num_params;
+	int         na = ta->func.num_params;
+	int         nb = tb->func.num_params;
 	int         ret, i;
 
 	if (na < 0)
@@ -606,10 +606,10 @@ func_compare (const void *a, const void *b)
 		nb = ~nb;
 	if (na != nb)
 		return nb - na;
-	if ((ret = (tb->t.func.num_params - ta->t.func.num_params)))
+	if ((ret = (tb->func.num_params - ta->func.num_params)))
 		return ret;
 	for (i = 0; i < na && i < nb; i++) {
-		auto diff = tb->t.func.param_types[i] - ta->t.func.param_types[i];
+		auto diff = tb->func.param_types[i] - ta->func.param_types[i];
 		if (diff) {
 			return diff < 0 ? -1 : 1;
 		}
@@ -663,8 +663,8 @@ find_generic_function (const expr_t *fexpr, genfunc_t **genfuncs,
 	for (auto gf = genfuncs; *gf; gf++, num_funcs++) continue;
 	unsigned costs[num_funcs] = {};
 
-	int num_params = call_type->t.func.num_params;
-	auto call_params = call_type->t.func.param_types;
+	int num_params = call_type->func.num_params;
+	auto call_params = call_type->func.param_types;
 	for (int j = 0; j < num_funcs; j++) {
 		auto g = genfuncs[j];
 		if (g->num_params != num_params) {
@@ -742,7 +742,7 @@ find_generic_function (const expr_t *fexpr, genfunc_t **genfuncs,
 	type_t ftype = {
 		.type = ev_func,
 
-		.t.func = {
+		.func = {
 			.ret_type = return_type,
 			.num_params = num_params,
 			.param_types = param_types,
@@ -791,7 +791,7 @@ find_function (const expr_t *fexpr, const expr_t *params)
 
 	type_t call_type = {
 		.type = ev_func,
-		.t.func = {
+		.func = {
 			.num_params = num_params,
 			.param_types = arg_types,
 		},
@@ -813,7 +813,7 @@ find_function (const expr_t *fexpr, const expr_t *params)
 			return fexpr;
 		}
 	}
-	call_type.t.func.ret_type = funcs[0]->type->t.func.ret_type;
+	call_type.func.ret_type = funcs[0]->type->func.ret_type;
 	dummy.type = find_type (&call_type);
 
 	qsort (funcs, func_count, sizeof (void *), func_compare);
@@ -831,9 +831,9 @@ find_function (const expr_t *fexpr, const expr_t *params)
 	}
 	for (int i = 0; i < func_count; i++) {
 		auto f = (overloaded_function_t *) funcs[i];
-		parm_count = f->type->t.func.num_params;
-		if ((parm_count >= 0 && parm_count != call_type.t.func.num_params)
-			|| (parm_count < 0 && ~parm_count > call_type.t.func.num_params)) {
+		parm_count = f->type->func.num_params;
+		if ((parm_count >= 0 && parm_count != call_type.func.num_params)
+			|| (parm_count < 0 && ~parm_count > call_type.func.num_params)) {
 			funcs[i] = 0;
 			continue;
 		}
@@ -841,8 +841,8 @@ find_function (const expr_t *fexpr, const expr_t *params)
 			parm_count = ~parm_count;
 		int j;
 		for (j = 0; j < parm_count; j++) {
-			if (!type_assignable (f->type->t.func.param_types[j],
-								  call_type.t.func.param_types[j])) {
+			if (!type_assignable (f->type->func.param_types[j],
+								  call_type.func.param_types[j])) {
 				funcs[i] = 0;
 				break;
 			}
@@ -899,14 +899,14 @@ check_function (symbol_t *fsym)
 	param_t    *p;
 	int         i;
 
-	if (!type_size (fsym->type->t.func.ret_type)) {
+	if (!type_size (fsym->type->func.ret_type)) {
 		error (0, "return type is an incomplete type");
-		//fsym->type->t.func.type = &type_void;//FIXME better type?
+		//fsym->type->func.type = &type_void;//FIXME better type?
 	}
-	if (value_too_large (fsym->type->t.func.ret_type)) {
+	if (value_too_large (fsym->type->func.ret_type)) {
 		error (0, "return value too large to be passed by value (%d)",
 			   type_size (&type_param));
-		//fsym->type->t.func.type = &type_void;//FIXME better type?
+		//fsym->type->func.type = &type_void;//FIXME better type?
 	}
 	for (p = params, i = 0; p; p = p->next, i++) {
 		if (!p->selector && !p->type && !p->name)
@@ -934,7 +934,7 @@ build_v6p_scope (symbol_t *fsym)
 	symtab_t   *parameters = fsym->func->parameters;
 	symtab_t   *locals = fsym->func->locals;
 
-	if (fsym->func->type->t.func.num_params < 0) {
+	if (fsym->func->type->func.num_params < 0) {
 		args = new_symbol_type (".args", &type_va_list);
 		initialize_def (args, 0, parameters->space, sc_param, locals);
 	}
@@ -1129,7 +1129,7 @@ static void
 build_function (symbol_t *fsym)
 {
 	const type_t *func_type = fsym->func->type;
-	if (func_type->t.func.num_params > PR_MAX_PARAMS) {
+	if (func_type->func.num_params > PR_MAX_PARAMS) {
 		error (0, "too many params");
 	}
 }
@@ -1327,7 +1327,7 @@ int
 function_parms (function_t *f, byte *parm_size)
 {
 	int         count, i;
-	auto func = &f->sym->type->t.func;
+	auto func = &f->sym->type->func;
 
 	if (func->num_params >= 0)
 		count = func->num_params;
diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c
index ac9dcfca1..0854fa719 100644
--- a/tools/qfcc/source/method.c
+++ b/tools/qfcc/source/method.c
@@ -496,7 +496,7 @@ get_selector (const expr_t *sel)
 		return 0;
 	}
 	_sel.index = expr_short (sel->address.offset);
-	_sel.index /= type_size (type_SEL.t.fldptr.type);
+	_sel.index /= type_size (type_SEL.fldptr.type);
 	return (selector_t *) Hash_FindElement (sel_index_hash, &_sel);
 }
 
@@ -512,7 +512,7 @@ emit_selectors (void)
 	if (!sel_index)
 		return 0;
 
-	sel_type = array_type (type_SEL.t.fldptr.type, sel_index);
+	sel_type = array_type (type_SEL.fldptr.type, sel_index);
 	sel_sym = make_symbol ("_OBJ_SELECTOR_TABLE", sel_type,
 						   pr.far_data, sc_static);
 	if (!sel_sym->table)
@@ -707,25 +707,25 @@ method_check_params (method_t *method, const expr_t *args)
 	const expr_t *err = 0;
 	auto mtype = method->type;
 
-	if (mtype->t.func.num_params == -1)
+	if (mtype->func.num_params == -1)
 		return 0;
 
-	if (mtype->t.func.num_params >= 0)
-		param_count = mtype->t.func.num_params;
+	if (mtype->func.num_params >= 0)
+		param_count = mtype->func.num_params;
 	else
-		param_count = -mtype->t.func.num_params - 1;
+		param_count = -mtype->func.num_params - 1;
 
 	int count = list_count (&args->list);
 	if (count < param_count)
 		return error (args, "too few arguments");
-	if (mtype->t.func.num_params >= 0 && count > mtype->t.func.num_params)
+	if (mtype->func.num_params >= 0 && count > mtype->func.num_params)
 		return error (args, "too many arguments");
 
 	const expr_t *arg_list[count];
 	list_scatter_rev (&args->list, arg_list);
 	for (i = 2; i < count; i++) {
 		const expr_t *e = arg_list[i];
-		const type_t *arg_type = i < param_count ? mtype->t.func.param_types[i]
+		const type_t *arg_type = i < param_count ? mtype->func.param_types[i]
 												 : nullptr;
 		if (e->type == ex_compound) {
 			scoped_src_loc (e);
diff --git a/tools/qfcc/source/obj_type.c b/tools/qfcc/source/obj_type.c
index 033dd2369..b4d7239e9 100644
--- a/tools/qfcc/source/obj_type.c
+++ b/tools/qfcc/source/obj_type.c
@@ -106,14 +106,13 @@ qfo_encode_func (const type_t *type, defspace_t *space)
 	def_t      *def;
 	int         i;
 
-	param_count = type->t.func.num_params;
+	param_count = type->func.num_params;
 	if (param_count < 0)
 		param_count = ~param_count;
 	param_type_defs = alloca (param_count * sizeof (def_t *));
-	return_type_def = qfo_encode_type (type->t.func.ret_type, space);
+	return_type_def = qfo_encode_type (type->func.ret_type, space);
 	for (i = 0; i < param_count; i++)
-		param_type_defs[i] = qfo_encode_type (type->t.func.param_types[i],
-											  space);
+		param_type_defs[i] = qfo_encode_type (type->func.param_types[i], space);
 	size = field_offset (qfot_func_t, param_types[param_count]);
 
 	def = qfo_new_encoding (type, size, space);
@@ -121,7 +120,7 @@ qfo_encode_func (const type_t *type, defspace_t *space)
 	func = &enc->func;
 	func->type = ev_func;
 	ENC_DEF (func->return_type, return_type_def);
-	func->num_params = type->t.func.num_params;
+	func->num_params = type->func.num_params;
 	for (i = 0; i < param_count; i++)
 		ENC_DEF (func->param_types[i], param_type_defs[i]);
 	return def;
@@ -134,7 +133,7 @@ qfo_encode_fldptr (const type_t *type, defspace_t *space)
 	def_t      *def;
 	def_t      *type_def;
 
-	type_def = qfo_encode_type (type->t.fldptr.type, space);
+	type_def = qfo_encode_type (type->fldptr.type, space);
 	def = qfo_new_encoding (type, sizeof (enc->fldptr), space);
 	enc = D_POINTER (qfot_type_t, def);
 	enc->fldptr.type = type->type;
@@ -178,11 +177,11 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
 	sy = sy_var;
 	if (type->meta == ty_enum)
 		sy = sy_const;
-	if (!type->t.symtab) {
+	if (!type->symtab) {
 		def = new_def (type->encoding, 0, pr.type_data, sc_extern);
 		return def;
 	}
-	for (num_fields = 0, sym = type->t.symtab->symbols; sym; sym = sym->next) {
+	for (num_fields = 0, sym = type->symtab->symbols; sym; sym = sym->next) {
 		if (sym->sy_type != sy)
 			continue;
 		num_fields++;
@@ -198,7 +197,7 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
 	((type_t *)type)->type_def = def;	// avoid infinite recursion
 
 	field_types = alloca (num_fields * sizeof (def_t *));
-	for (i = 0, sym = type->t.symtab->symbols; sym; sym = sym->next) {
+	for (i = 0, sym = type->symtab->symbols; sym; sym = sym->next) {
 		if (sym->sy_type != sy)
 			continue;
 		if (i == num_fields)
@@ -211,7 +210,7 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
 		i++;
 	}
 
-	for (i = 0, sym = type->t.symtab->symbols; sym; sym = sym->next) {
+	for (i = 0, sym = type->symtab->symbols; sym; sym = sym->next) {
 		if (sym->sy_type != sy)
 			continue;
 		if (i == num_fields)
@@ -235,13 +234,13 @@ qfo_encode_array (const type_t *type, defspace_t *space)
 	def_t      *def;
 	def_t      *array_type_def;
 
-	array_type_def = qfo_encode_type (type->t.array.type, space);
+	array_type_def = qfo_encode_type (type->array.type, space);
 
 	def = qfo_new_encoding (type, sizeof (enc->array), space);
 	enc = D_POINTER (qfot_type_t, def);
 	ENC_DEF (enc->array.type, array_type_def);
-	enc->array.base = type->t.array.base;
-	enc->array.size = type->t.array.size;
+	enc->array.base = type->array.base;
+	enc->array.size = type->array.size;
 	return def;
 }
 
@@ -253,7 +252,7 @@ qfo_encode_class (const type_t *type, defspace_t *space)
 
 	def = qfo_new_encoding (type, sizeof (enc->class), space);
 	enc = D_POINTER (qfot_type_t, def);
-	ENC_STR (enc->class, type->t.class->name);
+	ENC_STR (enc->class, type->class->name);
 	return def;
 }
 
@@ -265,8 +264,8 @@ qfo_encode_alias (const type_t *type, defspace_t *space)
 	def_t      *type_def;
 	def_t      *full_def;
 
-	type_def = qfo_encode_type (type->t.alias.aux_type, space);
-	full_def = qfo_encode_type (type->t.alias.full_type, space);
+	type_def = qfo_encode_type (type->alias.aux_type, space);
+	full_def = qfo_encode_type (type->alias.full_type, space);
 
 	def = qfo_new_encoding (type, sizeof (enc->alias), space);
 	enc = D_POINTER (qfot_type_t, def);
@@ -300,7 +299,7 @@ qfo_encode_algebra (const type_t *type, defspace_t *space)
 	def_t      *algebra_type_def = 0;
 
 	if (type->type != ev_invalid) {
-		auto m = (multivector_t *) type->t.algebra;
+		auto m = (multivector_t *) type->algebra;
 		algebra_type_def = qfo_encode_type (m->algebra->type, space);
 	}
 
diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y
index bea81a437..e5692d265 100644
--- a/tools/qfcc/source/qc-parse.y
+++ b/tools/qfcc/source/qc-parse.y
@@ -451,7 +451,7 @@ qc_function_spec (specifier_t spec, param_t *params)
 	// .float () foo; is a field holding a function variable rather
 	// than a function that returns a float field.
 	for (type = &spec.type; *type && is_field (*type);
-		 type = (const type_t **) &(*type)->t.fldptr.type) {
+		 type = (const type_t **) &(*type)->fldptr.type) {
 	}
 	const type_t *ret_type = *type;
 	*type = 0;
@@ -527,7 +527,7 @@ is_anonymous_struct (specifier_t spec)
 	if (!is_struct (spec.type) && !is_union (spec.type)) {
 		return 0;
 	}
-	if (!spec.type->t.symtab || spec.type->t.symtab->parent) {
+	if (!spec.type->symtab || spec.type->symtab->parent) {
 		return 0;
 	}
 	// struct and union type names always begin with "tag ". Untagged s/u
@@ -1042,7 +1042,7 @@ typespec_nonreserved
 	| OBJECT_NAME protocolrefs
 		{
 			if ($2) {
-				type_t      type = *type_id.t.fldptr.type;
+				type_t      type = *type_id.fldptr.type;
 				type.next = 0;
 				type.protos = $2;
 				$$ = type_spec (pointer_type (find_type (&type)));
@@ -1288,7 +1288,7 @@ enum_init
 		{
 			$$ = find_enum ($<symbol>-1);
 			start_enum ($$);
-			current_symtab = $$->type->t.symtab;
+			current_symtab = $$->type->symtab;
 		}
 	;
 
@@ -1381,7 +1381,7 @@ struct_defs
 				// replace the struct symbol table with one built from
 				// the class ivars and the current struct fields. ivars
 				// will replace any fields of the same name.
-				current_symtab = class_to_struct ($3->type->t.class,
+				current_symtab = class_to_struct ($3->type->class,
 												  current_symtab);
 			}
 		}
@@ -2110,7 +2110,7 @@ class_name
 				error (0, "`%s' is not a class", $1->name);
 				$$ = get_class (0, 1);
 			} else {
-				$$ = $1->type->t.class;
+				$$ = $1->type->class;
 			}
 		}
 	;
diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y
index 6bb677874..54734efa2 100644
--- a/tools/qfcc/source/qp-parse.y
+++ b/tools/qfcc/source/qp-parse.y
@@ -186,10 +186,10 @@ static symbol_t *
 function_value (function_t *func)
 {
 	symbol_t   *ret = 0;
-	if (func->type->t.func.ret_type) {
+	if (func->type->func.ret_type) {
 		ret = symtab_lookup (func->locals, ".ret");
 		if (!ret || ret->table != func->locals) {
-			ret = new_symbol_type (".ret", func->type->t.func.ret_type);
+			ret = new_symbol_type (".ret", func->type->func.ret_type);
 			initialize_def (ret, 0, func->locals->space, sc_local,
 							func->locals);
 		}
diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c
index 74d8e69ed..21a7731e6 100644
--- a/tools/qfcc/source/statements.c
+++ b/tools/qfcc/source/statements.c
@@ -686,7 +686,7 @@ statement_get_targetlist (statement_t *s)
 		count = 1;
 	} else if (statement_is_jumpb (s)) {
 		table = s->opa->def;
-		count = table->type->t.array.size;
+		count = table->type->array.size;
 	}
 	target_list = malloc ((count + 1) * sizeof (sblock_t *));
 	target_list[count] = 0;
@@ -1349,7 +1349,7 @@ ptr_addressing_mode (sblock_t *sblock, const expr_t *ref,
 				offs = lvalue->alias.offset;
 			}
 		}
-		type = type->t.fldptr.type;
+		type = type->fldptr.type;
 		if (offs) {
 			const expr_t *lv = lvalue->alias.expr;
 			auto lvtype = get_type (lv);
@@ -2627,7 +2627,7 @@ check_final_block (sblock_t *sblock)
 		if (statement_is_return (s))
 			return;
 	}
-	if (!is_void(current_func->sym->type->t.func.ret_type))
+	if (!is_void(current_func->sym->type->func.ret_type))
 		warning (0, "control reaches end of non-void function");
 	if (s && s->type >= st_func) {
 		// func and flow end blocks, so we need to add a new block to take the
diff --git a/tools/qfcc/source/struct.c b/tools/qfcc/source/struct.c
index 84ad94583..e452319e5 100644
--- a/tools/qfcc/source/struct.c
+++ b/tools/qfcc/source/struct.c
@@ -114,7 +114,7 @@ start_struct (int *su, symbol_t *tag, symtab_t *parent)
 			tag->type = sym->type;
 		}
 		if (sym->type->meta == ty_enum
-			|| (sym->type->meta == ty_struct && sym->type->t.symtab)) {
+			|| (sym->type->meta == ty_struct && sym->type->symtab)) {
 			error (0, "%s %s redefined",
 				   *su == 's' ? "struct" : "union", tag->name);
 		   *su = 0;
@@ -166,7 +166,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
 
 	symtab->parent = 0;		// disconnect struct's symtab from parent scope
 
-	if (sym->table == current_symtab && sym->type->t.symtab) {
+	if (sym->table == current_symtab && sym->type->symtab) {
 		error (0, "%s defined as wrong kind of tag", tag->name);
 		return sym;
 	}
@@ -175,7 +175,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
 			continue;
 		if (is_class (s->type)) {
 			error (0, "statically allocated instance of class %s",
-				   s->type->t.class->name);
+				   s->type->class->name);
 		}
 		if (su == 's') {
 			symtab->size = RUP (symtab->size + base, s->type->alignment) - base;
@@ -198,7 +198,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
 			if (!is_struct (s->type) && !is_union (s->type)) {
 				internal_error (0, "non-struct/union anonymous field");
 			}
-			anonymous = s->type->t.symtab;
+			anonymous = s->type->symtab;
 			for (as = anonymous->symbols; as; as = as->next) {
 				if (as->visibility == vis_anonymous || as->sy_type!= sy_var) {
 					continue;
@@ -220,7 +220,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
 	}
 	if (!type)
 		sym->type = find_type (sym->type);	// checks the tag, not the symtab
-	((type_t *) sym->type)->t.symtab = symtab;
+	((type_t *) sym->type)->symtab = symtab;
 	if (alignment > sym->type->alignment) {
 		((type_t *) sym->type)->alignment = alignment;
 	}
@@ -239,15 +239,15 @@ find_enum (symbol_t *tag)
 symtab_t *
 start_enum (symbol_t *sym)
 {
-	if (sym->table == current_symtab && sym->type->t.symtab) {
+	if (sym->table == current_symtab && sym->type->symtab) {
 		error (0, "%s defined as wrong kind of tag", sym->name);
 		sym = find_enum (0);
 	}
-	((type_t *) sym->type)->t.symtab = new_symtab (current_symtab, stab_enum);
+	((type_t *) sym->type)->symtab = new_symtab (current_symtab, stab_enum);
 	((type_t *) sym->type)->alignment = 1;
 	((type_t *) sym->type)->width = 1;
 	((type_t *) sym->type)->columns = 1;
-	return sym->type->t.symtab;
+	return sym->type->symtab;
 }
 
 symbol_t *
@@ -258,7 +258,7 @@ finish_enum (symbol_t *sym)
 	symtab_t   *enum_tab;
 
 	auto enum_type = sym->type = find_type (sym->type);
-	enum_tab = enum_type->t.symtab;
+	enum_tab = enum_type->symtab;
 
 	for (name = enum_tab->symbols; name; name = name->next) {
 		name->type = sym->type;
@@ -275,7 +275,7 @@ void
 add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
 {
 	auto enum_type = enm->type;
-	symtab_t   *enum_tab = enum_type->t.symtab;
+	symtab_t   *enum_tab = enum_type->symtab;
 	int         value;
 
 	if (name->table == current_symtab || name->table == enum_tab)
@@ -303,7 +303,7 @@ add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
 int
 enum_as_bool (const type_t *enm, expr_t **zero, expr_t **one)
 {
-	symtab_t   *symtab = enm->t.symtab;
+	symtab_t   *symtab = enm->symtab;
 	symbol_t   *zero_sym = 0;
 	symbol_t   *one_sym = 0;
 	symbol_t   *sym;
@@ -377,7 +377,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
 		type = make_structure (0, su, defs, 0)->type;
 	if ((su == 's' && !is_struct (type)) || (su == 'u' && !is_union (type)))
 		internal_error (0, "structure %s type mismatch", name);
-	for (i = 0, field_sym = type->t.symtab->symbols; field_sym;
+	for (i = 0, field_sym = type->symtab->symbols; field_sym;
 		 i++, field_sym = field_sym->next) {
 		if (!defs[i].name)
 			internal_error (0, "structure %s unexpected end of defs", name);
@@ -407,7 +407,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
 	struct_def->initialized = struct_def->constant = 1;
 	struct_def->nosave = 1;
 
-	for (i = 0, field_sym = type->t.symtab->symbols; field_sym;
+	for (i = 0, field_sym = type->symtab->symbols; field_sym;
 		 i++, field_sym = field_sym->next) {
 		field_def.type = field_sym->type;
 		field_def.name = save_string (va (0, "%s.%s", name, field_sym->name));
@@ -422,7 +422,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
 		} else {
 			if (is_array (field_def.type)) {
 				auto type = dereference_type (field_def.type);
-				for (j = 0; j < field_def.type->t.array.size; j++) {
+				for (j = 0; j < field_def.type->array.size; j++) {
 					defs[i].emit (&field_def, data, j);
 					field_def.offset += type_size (type);
 				}
diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c
index f7c4a928b..a3fa5cf73 100644
--- a/tools/qfcc/source/switch.c
+++ b/tools/qfcc/source/switch.c
@@ -381,7 +381,7 @@ check_enum_switch (switch_block_t *switch_block)
 	symbol_t   *enum_val;
 	auto type = get_type (switch_block->test);
 
-	for (enum_val = type->t.symtab->symbols; enum_val;
+	for (enum_val = type->symtab->symbols; enum_val;
 		 enum_val = enum_val->next) {
 		cl.value = new_int_expr (enum_val->value->int_val, false);
 		if (!Hash_FindElement (switch_block->labels, &cl)) {
diff --git a/tools/qfcc/source/symtab.c b/tools/qfcc/source/symtab.c
index fa75cd69d..09d77de22 100644
--- a/tools/qfcc/source/symtab.c
+++ b/tools/qfcc/source/symtab.c
@@ -229,8 +229,7 @@ make_symbol (const char *name, const type_t *type, defspace_t *space,
 		sym = new_symbol_type (name, type);
 	}
 	if (sym->type != type) {
-		if (is_array (sym->type) && is_array (type)
-			&& !sym->type->t.array.size) {
+		if (is_array (sym->type) && is_array (type) && !sym->type->array.size) {
 			sym->type = type;
 		} else {
 			error (0, "%s redefined", name);
diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c
index d1c10f058..5f01c634f 100644
--- a/tools/qfcc/source/type.c
+++ b/tools/qfcc/source/type.c
@@ -306,14 +306,14 @@ free_type (type_t *type)
 			break;
 		case ev_field:
 		case ev_ptr:
-			free_type ((type_t *) type->t.fldptr.type);
+			free_type ((type_t *) type->fldptr.type);
 			break;
 		case ev_func:
-			free_type ((type_t *) type->t.func.ret_type);
+			free_type ((type_t *) type->func.ret_type);
 			break;
 		case ev_invalid:
 			if (type->meta == ty_array)
-				free_type ((type_t *) type->t.array.type);
+				free_type ((type_t *) type->array.type);
 			break;
 	}
 	memset (type, 0, sizeof (*type));
@@ -350,12 +350,12 @@ copy_chain (type_t *type, type_t *append)
 						internal_error (0, "copy basic type");
 					case ev_field:
 					case ev_ptr:
-						n = (type_t **) &(*n)->t.fldptr.type;
-						type = (type_t *) type->t.fldptr.type;
+						n = (type_t **) &(*n)->fldptr.type;
+						type = (type_t *) type->fldptr.type;
 						break;
 					case ev_func:
-						n = (type_t **) &(*n)->t.func.ret_type;
-						type = (type_t *) type->t.func.ret_type;
+						n = (type_t **) &(*n)->func.ret_type;
+						type = (type_t *) type->func.ret_type;
 						break;
 					case ev_invalid:
 						internal_error (0, "invalid basic type");
@@ -363,8 +363,8 @@ copy_chain (type_t *type, type_t *append)
 				}
 				break;
 			case ty_array:
-				n = (type_t **) &(*n)->t.array.type;
-				type = (type_t *) type->t.array.type;
+				n = (type_t **) &(*n)->array.type;
+				type = (type_t *) type->array.type;
 				break;
 			case ty_struct:
 			case ty_union:
@@ -408,13 +408,13 @@ append_type (const type_t *type, const type_t *new)
 						internal_error (0, "append to basic type");
 					case ev_field:
 					case ev_ptr:
-						t = (const type_t **) &(*t)->t.fldptr.type;
+						t = (const type_t **) &(*t)->fldptr.type;
 						((type_t *) type)->alignment = 1;
 						((type_t *) type)->width = 1;
 						((type_t *) type)->columns = 1;
 						break;
 					case ev_func:
-						t = (const type_t **) &(*t)->t.func.ret_type;
+						t = (const type_t **) &(*t)->func.ret_type;
 						((type_t *) type)->alignment = 1;
 						((type_t *) type)->width = 1;
 						((type_t *) type)->columns = 1;
@@ -425,7 +425,7 @@ append_type (const type_t *type, const type_t *new)
 				}
 				break;
 			case ty_array:
-				t = (const type_t **) &(*t)->t.array.type;
+				t = (const type_t **) &(*t)->array.type;
 				((type_t *) type)->alignment = new->alignment;
 				((type_t *) type)->width = new->width;
 				((type_t *) type)->columns = new->columns;
@@ -443,7 +443,7 @@ append_type (const type_t *type, const type_t *new)
 	}
 	if (type && new->meta == ty_alias) {
 		auto chain = find_type (copy_chain ((type_t *) type, (type_t *) new));
-		*t = new->t.alias.aux_type;
+		*t = new->alias.aux_type;
 		type = alias_type (type, chain, 0);
 	} else {
 		*t = new;
@@ -454,8 +454,8 @@ append_type (const type_t *type, const type_t *new)
 void
 set_func_type_attrs (const type_t *func, specifier_t spec)
 {
-	((type_t *) func)->t.func.no_va_list = spec.no_va_list;//FIXME
-	((type_t *) func)->t.func.void_return = spec.void_return;
+	((type_t *) func)->func.no_va_list = spec.no_va_list;//FIXME
+	((type_t *) func)->func.void_return = spec.void_return;
 }
 
 specifier_t
@@ -554,16 +554,16 @@ find_type (const type_t *type)
 				switch (type->type) {
 					case ev_field:
 					case ev_ptr:
-						((type_t *) type)->t.fldptr.type = find_type (type->t.fldptr.type);
+						((type_t *) type)->fldptr.type = find_type (type->fldptr.type);
 						break;
 					case ev_func:
-						((type_t *) type)->t.func.ret_type = find_type (type->t.func.ret_type);
-						count = type->t.func.num_params;
+						((type_t *) type)->func.ret_type = find_type (type->func.ret_type);
+						count = type->func.num_params;
 						if (count < 0)
 							count = ~count;	// param count is one's complement
 						for (i = 0; i < count; i++)
-							((type_t *) type)->t.func.param_types[i]
-								= find_type (type->t.func.param_types[i]);
+							((type_t *) type)->func.param_types[i]
+								= find_type (type->func.param_types[i]);
 						break;
 					default:		// other types don't have aux data
 						break;
@@ -574,13 +574,13 @@ find_type (const type_t *type)
 			case ty_enum:
 				break;
 			case ty_array:
-				((type_t *) type)->t.array.type = find_type (type->t.array.type);
+				((type_t *) type)->array.type = find_type (type->array.type);
 				break;
 			case ty_class:
 				break;
 			case ty_alias:
-				((type_t *) type)->t.alias.aux_type = find_type (type->t.alias.aux_type);
-				((type_t *) type)->t.alias.full_type = find_type (type->t.alias.full_type);
+				((type_t *) type)->alias.aux_type = find_type (type->alias.aux_type);
+				((type_t *) type)->alias.full_type = find_type (type->alias.full_type);
 				break;
 			case ty_handle:
 				break;
@@ -600,16 +600,16 @@ find_type (const type_t *type)
 	check = new_type ();
 	*check = *type;
 	if (is_func (type)) {
-		check->t.func.param_types = 0;
+		check->func.param_types = 0;
 		const type_t *t = unalias_type (type);
-		int         num_params = t->t.func.num_params;
+		int         num_params = t->func.num_params;
 		if (num_params < 0) {
 			num_params = ~num_params;
 		}
 		if (num_params) {
-			check->t.func.param_types = malloc (sizeof (type_t *) * num_params);
+			check->func.param_types = malloc (sizeof (type_t *) * num_params);
 			for (int i = 0; i < num_params; i++) {
-				check->t.func.param_types[i] = t->t.func.param_types[i];
+				check->func.param_types[i] = t->func.param_types[i];
 			}
 		}
 	}
@@ -799,7 +799,7 @@ array_type (const type_t *aux, int size)
 		new->alignment = aux->alignment;
 		new->width = aux->width;
 	}
-	new->t.array.size = size;
+	new->array.size = size;
 	if (aux) {
 		return find_type (append_type (new, aux));
 	}
@@ -822,9 +822,9 @@ based_array_type (const type_t *aux, int base, int top)
 		new->width = aux->width;
 	}
 	new->meta = ty_array;
-	new->t.array.type = aux;
-	new->t.array.base = base;
-	new->t.array.size = top - base + 1;
+	new->array.type = aux;
+	new->array.base = base;
+	new->array.size = top - base + 1;
 	if (aux) {
 		return find_type (new);
 	}
@@ -842,15 +842,15 @@ alias_type (const type_t *type, const type_t *alias_chain, const char *name)
 	if (type == alias_chain && type->meta == ty_alias) {
 		// typedef of a type that contains a typedef somewhere
 		// grab the alias-free branch for type
-		type = alias_chain->t.alias.aux_type;
+		type = alias_chain->alias.aux_type;
 		if (!alias_chain->name) {
 			// the other typedef is further inside, so replace the unnamed
 			// alias node with the typedef
-			alias_chain = alias_chain->t.alias.full_type;
+			alias_chain = alias_chain->alias.full_type;
 		}
 	}
-	alias->t.alias.aux_type = type;
-	alias->t.alias.full_type = alias_chain;
+	alias->alias.aux_type = type;
+	alias->alias.full_type = alias_chain;
 	if (name) {
 		alias->name = save_string (name);
 	}
@@ -861,7 +861,7 @@ const type_t *
 unalias_type (const type_t *type)
 {
 	if (type->meta == ty_alias) {
-		type = type->t.alias.aux_type;
+		type = type->alias.aux_type;
 		if (type->meta == ty_alias) {
 			internal_error (0, "alias type node in alias-free chain");
 		}
@@ -876,9 +876,9 @@ dereference_type (const type_t *type)
 		internal_error (0, "dereference non pointer/field/array type");
 	}
 	if (type->meta == ty_alias) {
-		type = type->t.alias.full_type;
+		type = type->alias.full_type;
 	}
-	return type->t.fldptr.type;
+	return type->fldptr.type;
 }
 
 void
@@ -899,11 +899,11 @@ print_type_str (dstring_t *str, const type_t *type)
 			return;
 		case ty_alias:
 			dasprintf (str, "({%s=", type->name);
-			print_type_str (str, type->t.alias.aux_type);
+			print_type_str (str, type->alias.aux_type);
 			dstring_appendstr (str, "})");
 			return;
 		case ty_class:
-			dasprintf (str, " %s", type->t.class->name);
+			dasprintf (str, " %s", type->class->name);
 			if (type->protos)
 				print_protocollist (str, type->protos);
 			return;
@@ -917,12 +917,12 @@ print_type_str (dstring_t *str, const type_t *type)
 			dasprintf (str, " union %s", type->name);
 			return;
 		case ty_array:
-			print_type_str (str, type->t.array.type);
-			if (type->t.array.base) {
-				dasprintf (str, "[%d..%d]", type->t.array.base,
-						type->t.array.base + type->t.array.size - 1);
+			print_type_str (str, type->array.type);
+			if (type->array.base) {
+				dasprintf (str, "[%d..%d]", type->array.base,
+						type->array.base + type->array.size - 1);
 			} else {
-				dasprintf (str, "[%d]", type->t.array.size);
+				dasprintf (str, "[%d]", type->array.size);
 			}
 			return;
 		case ty_bool:
@@ -934,32 +934,32 @@ print_type_str (dstring_t *str, const type_t *type)
 			switch (type->type) {
 				case ev_field:
 					dasprintf (str, ".(");
-					print_type_str (str, type->t.fldptr.type);
+					print_type_str (str, type->fldptr.type);
 					dasprintf (str, ")");
 					return;
 				case ev_func:
-					print_type_str (str, type->t.func.ret_type);
-					if (type->t.func.num_params == -1) {
+					print_type_str (str, type->func.ret_type);
+					if (type->func.num_params == -1) {
 						dasprintf (str, "(...)");
 					} else {
 						int         c, i;
 						dasprintf (str, "(");
-						if ((c = type->t.func.num_params) < 0)
+						if ((c = type->func.num_params) < 0)
 							c = ~c;		// num_params is one's compliment
 						for (i = 0; i < c; i++) {
 							if (i)
 								dasprintf (str, ", ");
-							print_type_str (str, type->t.func.param_types[i]);
+							print_type_str (str, type->func.param_types[i]);
 						}
-						if (type->t.func.num_params < 0)
+						if (type->func.num_params < 0)
 								dasprintf (str, ", ...");
 						dasprintf (str, ")");
 					}
 					return;
 				case ev_ptr:
-					if (type->t.fldptr.type) {
+					if (type->fldptr.type) {
 						if (is_id (type)) {
-							__auto_type ptr = type->t.fldptr.type;
+							__auto_type ptr = type->fldptr.type;
 							dasprintf (str, "id");
 							if (ptr->protos)
 								print_protocollist (str, ptr->protos);
@@ -971,7 +971,7 @@ print_type_str (dstring_t *str, const type_t *type)
 						}
 					}
 					dasprintf (str, "(*");
-					print_type_str (str, type->t.fldptr.type);
+					print_type_str (str, type->fldptr.type);
 					dasprintf (str, ")");
 					return;
 				case ev_void:
@@ -1035,13 +1035,13 @@ encode_params (const type_t *type)
 	dstring_t  *encoding = dstring_newstr ();
 	int         i, count;
 
-	if (type->t.func.num_params < 0)
-		count = -type->t.func.num_params - 1;
+	if (type->func.num_params < 0)
+		count = -type->func.num_params - 1;
 	else
-		count = type->t.func.num_params;
+		count = type->func.num_params;
 	for (i = 0; i < count; i++)
-		encode_type (encoding, unalias_type (type->t.func.param_types[i]));
-	if (type->t.func.num_params < 0)
+		encode_type (encoding, unalias_type (type->func.param_types[i]));
+	if (type->func.num_params < 0)
 		dasprintf (encoding, ".");
 
 	ret = save_string (encoding->str);
@@ -1052,7 +1052,7 @@ encode_params (const type_t *type)
 static void
 encode_class (dstring_t *encoding, const type_t *type)
 {
-	class_t    *class = type->t.class;
+	class_t    *class = type->class;
 	const char *name ="?";
 
 	if (class->name)
@@ -1101,7 +1101,7 @@ encode_type (dstring_t *encoding, const type_t *type)
 			return;
 		case ty_alias:
 			dasprintf (encoding, "{%s>", type->name ? type->name : "");
-			encode_type (encoding, type->t.alias.full_type);
+			encode_type (encoding, type->alias.full_type);
 			dasprintf (encoding, "}");
 			return;
 		case ty_class:
@@ -1116,11 +1116,11 @@ encode_type (dstring_t *encoding, const type_t *type)
 			return;
 		case ty_array:
 			dasprintf (encoding, "[");
-			dasprintf (encoding, "%d", type->t.array.size);
-			if (type->t.array.base)
-				dasprintf (encoding, ":%d", type->t.array.base);
+			dasprintf (encoding, "%d", type->array.size);
+			if (type->array.base)
+				dasprintf (encoding, ":%d", type->array.base);
 			dasprintf (encoding, "=");
-			encode_type (encoding, type->t.array.type);
+			encode_type (encoding, type->array.type);
 			dasprintf (encoding, "]");
 			return;
 		case ty_bool:
@@ -1167,11 +1167,11 @@ encode_type (dstring_t *encoding, const type_t *type)
 					return;
 				case ev_field:
 					dasprintf (encoding, "F");
-					encode_type (encoding, type->t.fldptr.type);
+					encode_type (encoding, type->fldptr.type);
 					return;
 				case ev_func:
 					dasprintf (encoding, "(");
-					encode_type (encoding, type->t.func.ret_type);
+					encode_type (encoding, type->func.ret_type);
 					dasprintf (encoding, "%s)", encode_params (type));
 					return;
 				case ev_ptr:
@@ -1187,7 +1187,7 @@ encode_type (dstring_t *encoding, const type_t *type)
 						dasprintf (encoding, "#");
 						return;
 					}
-					type = type->t.fldptr.type;
+					type = type->fldptr.type;
 					dasprintf (encoding, "^");
 					encode_type (encoding, type);
 					return;
@@ -1407,8 +1407,8 @@ type_assignable (const type_t *dst, const type_t *src)
 		return 1;
 	// pointer = array
 	if (is_ptr (dst) && is_array (src)) {
-		if (is_void (dst->t.fldptr.type)
-			|| dst->t.fldptr.type == src->t.array.type)
+		if (is_void (dst->fldptr.type)
+			|| dst->fldptr.type == src->array.type)
 			return 1;
 		return 0;
 	}
@@ -1434,8 +1434,8 @@ type_assignable (const type_t *dst, const type_t *src)
 	if (ret >= 0)
 		return ret;
 
-	dst = dst->t.fldptr.type;
-	src = src->t.fldptr.type;
+	dst = dst->fldptr.type;
+	src = src->fldptr.type;
 	if (dst == src) {
 		return 1;
 	}
@@ -1507,18 +1507,18 @@ type_size (const type_t *type)
 			return pr_type_size[type->type] * type->width;
 		case ty_struct:
 		case ty_union:
-			if (!type->t.symtab)
+			if (!type->symtab)
 				return 0;
-			return type->t.symtab->size;
+			return type->symtab->size;
 		case ty_enum:
-			if (!type->t.symtab)
+			if (!type->symtab)
 				return 0;
 			return type_size (&type_int);
 		case ty_array:
-			return type->t.array.size * type_size (type->t.array.type);
+			return type->array.size * type_size (type->array.type);
 		case ty_class:
 			{
-				class_t    *class = type->t.class;
+				class_t    *class = type->class;
 				int         size;
 				if (!class->ivars)
 					return 0;
@@ -1528,7 +1528,7 @@ type_size (const type_t *type)
 				return size;
 			}
 		case ty_alias:
-			return type_size (type->t.alias.aux_type);
+			return type_size (type->alias.aux_type);
 		case ty_algebra:
 			return algebra_type_size (type);
 		case ty_meta_count:
@@ -1555,15 +1555,15 @@ type_width (const type_t *type)
 		case ty_union:
 			return 1;
 		case ty_enum:
-			if (!type->t.symtab)
+			if (!type->symtab)
 				return 0;
 			return type_width (&type_int);
 		case ty_array:
-			return type_width (type->t.array.type);
+			return type_width (type->array.type);
 		case ty_class:
 			return 1;
 		case ty_alias:
-			return type_width (type->t.alias.aux_type);
+			return type_width (type->alias.aux_type);
 		case ty_algebra:
 			return algebra_type_width (type);
 		case ty_meta_count:
@@ -1602,7 +1602,7 @@ type_aligned_size (const type_t *type)
 static void
 chain_basic_types (void)
 {
-	type_entity.t.symtab = pr.entity_fields;
+	type_entity.symtab = pr.entity_fields;
 	if (options.code.progsversion == PROG_VERSION) {
 		type_quaternion.alignment = 4;
 	}
@@ -1789,11 +1789,11 @@ init_types (void)
 
 		sym = new_symbol_type ("v", &type_vector);
 		sym->offset = 0;
-		symtab_addsymbol (type_quaternion.t.symtab, sym);
+		symtab_addsymbol (type_quaternion.symtab, sym);
 
 		sym = new_symbol_type ("s", &type_float);
 		sym->offset = 3;
-		symtab_addsymbol (type_quaternion.t.symtab, sym);
+		symtab_addsymbol (type_quaternion.symtab, sym);
 	}
 #define VEC_TYPE(type_name, base_type) build_vector_struct (&type_##type_name);
 #include "tools/qfcc/include/vec_types.h"
diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c
index cdeb60dfe..255843704 100644
--- a/tools/qfcc/source/value.c
+++ b/tools/qfcc/source/value.c
@@ -280,7 +280,7 @@ new_nil_val (const type_t *type)
 		val.lltype = type_nil->type;
 	}
 	if (val.lltype == ev_ptr || val.lltype == ev_field )
-		val.pointer.type = type->t.fldptr.type;
+		val.pointer.type = type->fldptr.type;
 	if (val.lltype == ev_func)
 		val.func_val.type = type;
 	return find_value (&val);