Merge pull request #1406 from ziglang/macos-stack-traces

MacOS stack traces
closes #1365 

6 files changed, 357 insertions, 277 deletions

diff --git a/src/analyze.cpp b/src/analyze.cpp
index da5a5ea69b..a8b3ea7132 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -19,12 +19,12 @@
 
 static const size_t default_backward_branch_quota = 1000;
 
-static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type);
-static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type);
+static Error resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type);
+static Error resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type);
 
-static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type);
-static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type);
-static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type);
+static Error ATTRIBUTE_MUST_USE resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type);
+static Error ATTRIBUTE_MUST_USE resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type);
+static Error ATTRIBUTE_MUST_USE resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type);
 static void analyze_fn_body(CodeGen *g, FnTableEntry *fn_table_entry);
 
 ErrorMsg *add_node_error(CodeGen *g, AstNode *node, Buf *msg) {
@@ -370,15 +370,20 @@ uint64_t type_size_bits(CodeGen *g, TypeTableEntry *type_entry) {
     return LLVMSizeOfTypeInBits(g->target_data_ref, type_entry->type_ref);
 }
 
-bool type_is_copyable(CodeGen *g, TypeTableEntry *type_entry) {
-    type_ensure_zero_bits_known(g, type_entry);
+Result<bool> type_is_copyable(CodeGen *g, TypeTableEntry *type_entry) {
+    Error err;
+    if ((err = type_ensure_zero_bits_known(g, type_entry)))
+        return err;
+
     if (!type_has_bits(type_entry))
         return true;
 
     if (!handle_is_ptr(type_entry))
         return true;
 
-    ensure_complete_type(g, type_entry);
+    if ((err = ensure_complete_type(g, type_entry)))
+        return err;
+
     return type_entry->is_copyable;
 }
 
@@ -447,7 +452,7 @@ TypeTableEntry *get_pointer_to_type_extra(CodeGen *g, TypeTableEntry *child_type
         }
     }
 
-    type_ensure_zero_bits_known(g, child_type);
+    assertNoError(type_ensure_zero_bits_known(g, child_type));
 
     TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdPointer);
     entry->is_copyable = true;
@@ -554,11 +559,11 @@ TypeTableEntry *get_optional_type(CodeGen *g, TypeTableEntry *child_type) {
         TypeTableEntry *entry = child_type->optional_parent;
         return entry;
     } else {
-        ensure_complete_type(g, child_type);
+        assertNoError(ensure_complete_type(g, child_type));
 
         TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdOptional);
         assert(child_type->type_ref || child_type->zero_bits);
-        entry->is_copyable = type_is_copyable(g, child_type);
+        entry->is_copyable = type_is_copyable(g, child_type).unwrap();
 
         buf_resize(&entry->name, 0);
         buf_appendf(&entry->name, "?%s", buf_ptr(&child_type->name));
@@ -650,7 +655,7 @@ TypeTableEntry *get_error_union_type(CodeGen *g, TypeTableEntry *err_set_type, T
     TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdErrorUnion);
     entry->is_copyable = true;
     assert(payload_type->di_type);
-    ensure_complete_type(g, payload_type);
+    assertNoError(ensure_complete_type(g, payload_type));
 
     buf_resize(&entry->name, 0);
     buf_appendf(&entry->name, "%s!%s", buf_ptr(&err_set_type->name), buf_ptr(&payload_type->name));
@@ -739,7 +744,7 @@ TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, uint64_t
         return entry;
     }
 
-    ensure_complete_type(g, child_type);
+    assertNoError(ensure_complete_type(g, child_type));
 
     TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArray);
     entry->zero_bits = (array_size == 0) || child_type->zero_bits;
@@ -1050,13 +1055,13 @@ TypeTableEntry *get_ptr_to_stack_trace_type(CodeGen *g) {
 }
 
 TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
+    Error err;
     auto table_entry = g->fn_type_table.maybe_get(fn_type_id);
     if (table_entry) {
         return table_entry->value;
     }
     if (fn_type_id->return_type != nullptr) {
-        ensure_complete_type(g, fn_type_id->return_type);
-        if (type_is_invalid(fn_type_id->return_type))
+        if ((err = ensure_complete_type(g, fn_type_id->return_type)))
             return g->builtin_types.entry_invalid;
         assert(fn_type_id->return_type->id != TypeTableEntryIdOpaque);
     } else {
@@ -1172,8 +1177,7 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
             gen_param_info->src_index = i;
             gen_param_info->gen_index = SIZE_MAX;
 
-            ensure_complete_type(g, type_entry);
-            if (type_is_invalid(type_entry))
+            if ((err = ensure_complete_type(g, type_entry)))
                 return g->builtin_types.entry_invalid;
 
             if (type_has_bits(type_entry)) {
@@ -1493,6 +1497,7 @@ TypeTableEntry *get_auto_err_set_type(CodeGen *g, FnTableEntry *fn_entry) {
 static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_scope, FnTableEntry *fn_entry) {
     assert(proto_node->type == NodeTypeFnProto);
     AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
+    Error err;
 
     FnTypeId fn_type_id = {0};
     init_fn_type_id(&fn_type_id, proto_node, proto_node->data.fn_proto.params.length);
@@ -1550,7 +1555,8 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
             return g->builtin_types.entry_invalid;
         }
         if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
-            type_ensure_zero_bits_known(g, type_entry);
+            if ((err = type_ensure_zero_bits_known(g, type_entry)))
+                return g->builtin_types.entry_invalid;
             if (!type_has_bits(type_entry)) {
                 add_node_error(g, param_node->data.param_decl.type,
                     buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'",
@@ -1598,7 +1604,8 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
             case TypeTableEntryIdUnion:
             case TypeTableEntryIdFn:
             case TypeTableEntryIdPromise:
-                type_ensure_zero_bits_known(g, type_entry);
+                if ((err = type_ensure_zero_bits_known(g, type_entry)))
+                    return g->builtin_types.entry_invalid;
                 if (type_requires_comptime(type_entry)) {
                     add_node_error(g, param_node->data.param_decl.type,
                         buf_sprintf("parameter of type '%s' must be declared comptime",
@@ -1729,24 +1736,28 @@ bool type_is_invalid(TypeTableEntry *type_entry) {
 }
 
 
-static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
+static Error resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
     assert(enum_type->id == TypeTableEntryIdEnum);
 
+    if (enum_type->data.enumeration.is_invalid)
+        return ErrorSemanticAnalyzeFail;
+
     if (enum_type->data.enumeration.complete)
-        return;
+        return ErrorNone;
 
-    resolve_enum_zero_bits(g, enum_type);
-    if (type_is_invalid(enum_type))
-        return;
+    Error err;
+    if ((err = resolve_enum_zero_bits(g, enum_type)))
+        return err;
 
     AstNode *decl_node = enum_type->data.enumeration.decl_node;
 
     if (enum_type->data.enumeration.embedded_in_current) {
         if (!enum_type->data.enumeration.reported_infinite_err) {
+            enum_type->data.enumeration.is_invalid = true;
             enum_type->data.enumeration.reported_infinite_err = true;
             add_node_error(g, decl_node, buf_sprintf("enum '%s' contains itself", buf_ptr(&enum_type->name)));
         }
-        return;
+        return ErrorSemanticAnalyzeFail;
     }
 
     assert(!enum_type->data.enumeration.zero_bits_loop_flag);
@@ -1778,7 +1789,7 @@ static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
     enum_type->data.enumeration.complete = true;
 
     if (enum_type->data.enumeration.is_invalid)
-        return;
+        return ErrorSemanticAnalyzeFail;
 
     if (enum_type->zero_bits) {
         enum_type->type_ref = LLVMVoidType();
@@ -1797,7 +1808,7 @@ static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
 
         ZigLLVMReplaceTemporary(g->dbuilder, enum_type->di_type, replacement_di_type);
         enum_type->di_type = replacement_di_type;
-        return;
+        return ErrorNone;
     }
 
     TypeTableEntry *tag_int_type = enum_type->data.enumeration.tag_int_type;
@@ -1815,6 +1826,7 @@ static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
 
     ZigLLVMReplaceTemporary(g->dbuilder, enum_type->di_type, tag_di_type);
     enum_type->di_type = tag_di_type;
+    return ErrorNone;
 }
 
 
@@ -1897,15 +1909,15 @@ TypeTableEntry *get_struct_type(CodeGen *g, const char *type_name, const char *f
     return struct_type;
 }
 
-static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
+static Error resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
     assert(struct_type->id == TypeTableEntryIdStruct);
 
     if (struct_type->data.structure.complete)
-        return;
+        return ErrorNone;
 
-    resolve_struct_zero_bits(g, struct_type);
-    if (struct_type->data.structure.is_invalid)
-        return;
+    Error err;
+    if ((err = resolve_struct_zero_bits(g, struct_type)))
+        return err;
 
     AstNode *decl_node = struct_type->data.structure.decl_node;
 
@@ -1916,7 +1928,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
             add_node_error(g, decl_node,
                     buf_sprintf("struct '%s' contains itself", buf_ptr(&struct_type->name)));
         }
-        return;
+        return ErrorSemanticAnalyzeFail;
     }
 
     assert(!struct_type->data.structure.zero_bits_loop_flag);
@@ -1943,8 +1955,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
         TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
         TypeTableEntry *field_type = type_struct_field->type_entry;
 
-        ensure_complete_type(g, field_type);
-        if (type_is_invalid(field_type)) {
+        if ((err = ensure_complete_type(g, field_type))) {
             struct_type->data.structure.is_invalid = true;
             break;
         }
@@ -2026,7 +2037,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
     struct_type->data.structure.complete = true;
 
     if (struct_type->data.structure.is_invalid)
-        return;
+        return ErrorSemanticAnalyzeFail;
 
     if (struct_type->zero_bits) {
         struct_type->type_ref = LLVMVoidType();
@@ -2045,7 +2056,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
                 0, nullptr, di_element_types, (int)debug_field_count, 0, nullptr, "");
         ZigLLVMReplaceTemporary(g->dbuilder, struct_type->di_type, replacement_di_type);
         struct_type->di_type = replacement_di_type;
-        return;
+        return ErrorNone;
     }
     assert(struct_type->di_type);
 
@@ -2128,17 +2139,19 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
 
     ZigLLVMReplaceTemporary(g->dbuilder, struct_type->di_type, replacement_di_type);
     struct_type->di_type = replacement_di_type;
+
+    return ErrorNone;
 }
 
-static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
+static Error resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
     assert(union_type->id == TypeTableEntryIdUnion);
 
     if (union_type->data.unionation.complete)
-        return;
+        return ErrorNone;
 
-    resolve_union_zero_bits(g, union_type);
-    if (type_is_invalid(union_type))
-        return;
+    Error err;
+    if ((err = resolve_union_zero_bits(g, union_type)))
+        return err;
 
     AstNode *decl_node = union_type->data.unionation.decl_node;
 
@@ -2148,7 +2161,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
             union_type->data.unionation.is_invalid = true;
             add_node_error(g, decl_node, buf_sprintf("union '%s' contains itself", buf_ptr(&union_type->name)));
         }
-        return;
+        return ErrorSemanticAnalyzeFail;
     }
 
     assert(!union_type->data.unionation.zero_bits_loop_flag);
@@ -2179,8 +2192,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
         TypeUnionField *union_field = &union_type->data.unionation.fields[i];
         TypeTableEntry *field_type = union_field->type_entry;
 
-        ensure_complete_type(g, field_type);
-        if (type_is_invalid(field_type)) {
+        if ((err = ensure_complete_type(g, field_type))) {
             union_type->data.unionation.is_invalid = true;
             continue;
         }
@@ -2219,7 +2231,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
     union_type->data.unionation.most_aligned_union_member = most_aligned_union_member;
 
     if (union_type->data.unionation.is_invalid)
-        return;
+        return ErrorSemanticAnalyzeFail;
 
     if (union_type->zero_bits) {
         union_type->type_ref = LLVMVoidType();
@@ -2238,7 +2250,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
 
         ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, replacement_di_type);
         union_type->di_type = replacement_di_type;
-        return;
+        return ErrorNone;
     }
 
     uint64_t padding_in_bits = biggest_size_in_bits - size_of_most_aligned_member_in_bits;
@@ -2274,7 +2286,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
 
         ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, replacement_di_type);
         union_type->di_type = replacement_di_type;
-        return;
+        return ErrorNone;
     }
 
     LLVMTypeRef union_type_ref;
@@ -2293,7 +2305,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
 
         ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, tag_type->di_type);
         union_type->di_type = tag_type->di_type;
-        return;
+        return ErrorNone;
     } else {
         union_type_ref = most_aligned_union_member->type_ref;
     }
@@ -2367,19 +2379,21 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
 
     ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, replacement_di_type);
     union_type->di_type = replacement_di_type;
+
+    return ErrorNone;
 }
 
-static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
+static Error resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
     assert(enum_type->id == TypeTableEntryIdEnum);
 
     if (enum_type->data.enumeration.zero_bits_known)
-        return;
+        return ErrorNone;
 
     if (enum_type->data.enumeration.zero_bits_loop_flag) {
         add_node_error(g, enum_type->data.enumeration.decl_node,
             buf_sprintf("'%s' depends on itself", buf_ptr(&enum_type->name)));
         enum_type->data.enumeration.is_invalid = true;
-        return;
+        return ErrorSemanticAnalyzeFail;
     }
 
     enum_type->data.enumeration.zero_bits_loop_flag = true;
@@ -2398,7 +2412,7 @@ static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
         enum_type->data.enumeration.is_invalid = true;
         enum_type->data.enumeration.zero_bits_loop_flag = false;
         enum_type->data.enumeration.zero_bits_known = true;
-        return;
+        return ErrorSemanticAnalyzeFail;
     }
 
     enum_type->data.enumeration.src_field_count = field_count;
@@ -2525,13 +2539,23 @@ static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
     enum_type->data.enumeration.zero_bits_loop_flag = false;
     enum_type->zero_bits = !type_has_bits(tag_int_type);
     enum_type->data.enumeration.zero_bits_known = true;
+
+    if (enum_type->data.enumeration.is_invalid)
+        return ErrorSemanticAnalyzeFail;
+
+    return ErrorNone;
 }
 
-static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
+static Error resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
     assert(struct_type->id == TypeTableEntryIdStruct);
 
+    Error err;
+
+    if (struct_type->data.structure.is_invalid)
+        return ErrorSemanticAnalyzeFail;
+
     if (struct_type->data.structure.zero_bits_known)
-        return;
+        return ErrorNone;
 
     if (struct_type->data.structure.zero_bits_loop_flag) {
         // If we get here it's due to recursion. This is a design flaw in the compiler,
@@ -2547,7 +2571,7 @@ static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
                 struct_type->data.structure.abi_alignment = LLVMABIAlignmentOfType(g->target_data_ref, LLVMPointerType(LLVMInt8Type(), 0));
             }
         }
-        return;
+        return ErrorNone;
     }
 
     struct_type->data.structure.zero_bits_loop_flag = true;
@@ -2596,8 +2620,7 @@ static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
                     buf_sprintf("enums, not structs, support field assignment"));
         }
 
-        type_ensure_zero_bits_known(g, field_type);
-        if (type_is_invalid(field_type)) {
+        if ((err = type_ensure_zero_bits_known(g, field_type))) {
             struct_type->data.structure.is_invalid = true;
             continue;
         }
@@ -2634,16 +2657,27 @@ static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
     struct_type->data.structure.gen_field_count = (uint32_t)gen_field_index;
     struct_type->zero_bits = (gen_field_index == 0);
     struct_type->data.structure.zero_bits_known = true;
+
+    if (struct_type->data.structure.is_invalid) {
+        return ErrorSemanticAnalyzeFail;
+    }
+
+    return ErrorNone;
 }
 
-static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
+static Error resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
     assert(union_type->id == TypeTableEntryIdUnion);
 
+    Error err;
+
+    if (union_type->data.unionation.is_invalid)
+        return ErrorSemanticAnalyzeFail;
+
     if (union_type->data.unionation.zero_bits_known)
-        return;
+        return ErrorNone;
 
     if (type_is_invalid(union_type))
-        return;
+        return ErrorSemanticAnalyzeFail;
 
     if (union_type->data.unionation.zero_bits_loop_flag) {
         // If we get here it's due to recursion. From this we conclude that the struct is
@@ -2660,7 +2694,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
                         LLVMPointerType(LLVMInt8Type(), 0));
             }
         }
-        return;
+        return ErrorNone;
     }
 
     union_type->data.unionation.zero_bits_loop_flag = true;
@@ -2679,7 +2713,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
         union_type->data.unionation.is_invalid = true;
         union_type->data.unionation.zero_bits_loop_flag = false;
         union_type->data.unionation.zero_bits_known = true;
-        return;
+        return ErrorSemanticAnalyzeFail;
     }
     union_type->data.unionation.src_field_count = field_count;
     union_type->data.unionation.fields = allocate<TypeUnionField>(field_count);
@@ -2711,13 +2745,13 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
             tag_int_type = analyze_type_expr(g, scope, enum_type_node);
             if (type_is_invalid(tag_int_type)) {
                 union_type->data.unionation.is_invalid = true;
-                return;
+                return ErrorSemanticAnalyzeFail;
             }
             if (tag_int_type->id != TypeTableEntryIdInt) {
                 add_node_error(g, enum_type_node,
                     buf_sprintf("expected integer tag type, found '%s'", buf_ptr(&tag_int_type->name)));
                 union_type->data.unionation.is_invalid = true;
-                return;
+                return ErrorSemanticAnalyzeFail;
             }
         } else {
             tag_int_type = get_smallest_unsigned_int_type(g, field_count - 1);
@@ -2744,13 +2778,13 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
         TypeTableEntry *enum_type = analyze_type_expr(g, scope, enum_type_node);
         if (type_is_invalid(enum_type)) {
             union_type->data.unionation.is_invalid = true;
-            return;
+            return ErrorSemanticAnalyzeFail;
         }
         if (enum_type->id != TypeTableEntryIdEnum) {
             union_type->data.unionation.is_invalid = true;
             add_node_error(g, enum_type_node,
                 buf_sprintf("expected enum tag type, found '%s'", buf_ptr(&enum_type->name)));
-            return;
+            return ErrorSemanticAnalyzeFail;
         }
         tag_type = enum_type;
         abi_alignment_so_far = get_abi_alignment(g, enum_type); // this populates src_field_count
@@ -2789,8 +2823,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
             }
         } else {
             field_type = analyze_type_expr(g, scope, field_node->data.struct_field.type);
-            type_ensure_zero_bits_known(g, field_type);
-            if (type_is_invalid(field_type)) {
+            if ((err = type_ensure_zero_bits_known(g, field_type))) {
                 union_type->data.unionation.is_invalid = true;
                 continue;
             }
@@ -2883,7 +2916,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
     union_type->data.unionation.abi_alignment = abi_alignment_so_far;
 
     if (union_type->data.unionation.is_invalid)
-        return;
+        return ErrorSemanticAnalyzeFail;
 
     bool src_have_tag = decl_node->data.container_decl.auto_enum ||
         decl_node->data.container_decl.init_arg_expr != nullptr;
@@ -2905,7 +2938,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
         add_node_error(g, source_node,
             buf_sprintf("%s union does not support enum tag type", qual_str));
         union_type->data.unionation.is_invalid = true;
-        return;
+        return ErrorSemanticAnalyzeFail;
     }
 
     if (create_enum_type) {
@@ -2970,6 +3003,11 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
     union_type->data.unionation.gen_field_count = gen_field_index;
     union_type->zero_bits = (gen_field_index == 0 && (field_count < 2 || !src_have_tag));
     union_type->data.unionation.zero_bits_known = true;
+
+    if (union_type->data.unionation.is_invalid)
+        return ErrorSemanticAnalyzeFail;
+
+    return ErrorNone;
 }
 
 static void get_fully_qualified_decl_name_internal(Buf *buf, Scope *scope, uint8_t sep) {
@@ -3463,13 +3501,13 @@ VariableTableEntry *add_variable(CodeGen *g, AstNode *source_node, Scope *parent
     variable_entry->shadowable = false;
     variable_entry->mem_slot_index = SIZE_MAX;
     variable_entry->src_arg_index = SIZE_MAX;
-    variable_entry->align_bytes = get_abi_alignment(g, value->type);
 
     assert(name);
-
     buf_init_from_buf(&variable_entry->name, name);
 
-    if (value->type->id != TypeTableEntryIdInvalid) {
+    if (!type_is_invalid(value->type)) {
+        variable_entry->align_bytes = get_abi_alignment(g, value->type);
+
         VariableTableEntry *existing_var = find_variable(g, parent_scope, name);
         if (existing_var && !existing_var->shadowable) {
             ErrorMsg *msg = add_node_error(g, source_node,
@@ -5311,13 +5349,13 @@ ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_
 
 
 void init_const_undefined(CodeGen *g, ConstExprValue *const_val) {
+    Error err;
     TypeTableEntry *wanted_type = const_val->type;
     if (wanted_type->id == TypeTableEntryIdArray) {
         const_val->special = ConstValSpecialStatic;
         const_val->data.x_array.special = ConstArraySpecialUndef;
     } else if (wanted_type->id == TypeTableEntryIdStruct) {
-        ensure_complete_type(g, wanted_type);
-        if (type_is_invalid(wanted_type)) {
+        if ((err = ensure_complete_type(g, wanted_type))) {
             return;
         }
 
@@ -5350,27 +5388,33 @@ ConstExprValue *create_const_vals(size_t count) {
     return vals;
 }
 
-void ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry) {
+Error ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry) {
+    if (type_is_invalid(type_entry))
+        return ErrorSemanticAnalyzeFail;
     if (type_entry->id == TypeTableEntryIdStruct) {
         if (!type_entry->data.structure.complete)
-            resolve_struct_type(g, type_entry);
+            return resolve_struct_type(g, type_entry);
     } else if (type_entry->id == TypeTableEntryIdEnum) {
         if (!type_entry->data.enumeration.complete)
-            resolve_enum_type(g, type_entry);
+            return resolve_enum_type(g, type_entry);
     } else if (type_entry->id == TypeTableEntryIdUnion) {
         if (!type_entry->data.unionation.complete)
-            resolve_union_type(g, type_entry);
+            return resolve_union_type(g, type_entry);
     }
+    return ErrorNone;
 }
 
-void type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry) {
+Error type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry) {
+    if (type_is_invalid(type_entry))
+        return ErrorSemanticAnalyzeFail;
     if (type_entry->id == TypeTableEntryIdStruct) {
-        resolve_struct_zero_bits(g, type_entry);
+        return resolve_struct_zero_bits(g, type_entry);
     } else if (type_entry->id == TypeTableEntryIdEnum) {
-        resolve_enum_zero_bits(g, type_entry);
+        return resolve_enum_zero_bits(g, type_entry);
     } else if (type_entry->id == TypeTableEntryIdUnion) {
-        resolve_union_zero_bits(g, type_entry);
+        return resolve_union_zero_bits(g, type_entry);
     }
+    return ErrorNone;
 }
 
 bool ir_get_var_is_comptime(VariableTableEntry *var) {
@@ -6213,7 +6257,7 @@ LinkLib *add_link_lib(CodeGen *g, Buf *name) {
 }
 
 uint32_t get_abi_alignment(CodeGen *g, TypeTableEntry *type_entry) {
-    type_ensure_zero_bits_known(g, type_entry);
+    assertNoError(type_ensure_zero_bits_known(g, type_entry));
     if (type_entry->zero_bits) return 0;
 
     // We need to make this function work without requiring ensure_complete_type
diff --git a/src/analyze.hpp b/src/analyze.hpp
index e4dfae4ecb..0b52e9a5e6 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -9,6 +9,7 @@
 #define ZIG_ANALYZE_HPP
 
 #include "all_types.hpp"
+#include "result.hpp"
 
 void semantic_analyze(CodeGen *g);
 ErrorMsg *add_node_error(CodeGen *g, AstNode *node, Buf *msg);
@@ -88,8 +89,8 @@ void init_fn_type_id(FnTypeId *fn_type_id, AstNode *proto_node, size_t param_cou
 AstNode *get_param_decl_node(FnTableEntry *fn_entry, size_t index);
 FnTableEntry *scope_get_fn_if_root(Scope *scope);
 bool type_requires_comptime(TypeTableEntry *type_entry);
-void ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry);
-void type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry);
+Error ATTRIBUTE_MUST_USE ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry);
+Error ATTRIBUTE_MUST_USE type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry);
 void complete_enum(CodeGen *g, TypeTableEntry *enum_type);
 bool ir_get_var_is_comptime(VariableTableEntry *var);
 bool const_values_equal(ConstExprValue *a, ConstExprValue *b);
@@ -178,7 +179,7 @@ TypeTableEntryId type_id_at_index(size_t index);
 size_t type_id_len();
 size_t type_id_index(TypeTableEntry *entry);
 TypeTableEntry *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id);
-bool type_is_copyable(CodeGen *g, TypeTableEntry *type_entry);
+Result<bool> type_is_copyable(CodeGen *g, TypeTableEntry *type_entry);
 LinkLib *create_link_lib(Buf *name);
 bool calling_convention_does_first_arg_return(CallingConvention cc);
 LinkLib *add_link_lib(CodeGen *codegen, Buf *lib);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index e926d14a7e..7ea322c1c3 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -5812,12 +5812,16 @@ static void do_code_gen(CodeGen *g) {
 
         LLVMValueRef global_value;
         if (var->linkage == VarLinkageExternal) {
-            global_value = LLVMAddGlobal(g->module, var->value->type->type_ref, buf_ptr(&var->name));
-
-            // TODO debug info for the extern variable
+            LLVMValueRef existing_llvm_var = LLVMGetNamedGlobal(g->module, buf_ptr(&var->name));
+            if (existing_llvm_var) {
+                global_value = LLVMConstBitCast(existing_llvm_var, LLVMPointerType(var->value->type->type_ref, 0));
+            } else {
+                global_value = LLVMAddGlobal(g->module, var->value->type->type_ref, buf_ptr(&var->name));
+                // TODO debug info for the extern variable
 
-            LLVMSetLinkage(global_value, LLVMExternalLinkage);
-            LLVMSetAlignment(global_value, var->align_bytes);
+                LLVMSetLinkage(global_value, LLVMExternalLinkage);
+                LLVMSetAlignment(global_value, var->align_bytes);
+            }
         } else {
             bool exported = (var->linkage == VarLinkageExport);
             const char *mangled_name = buf_ptr(get_mangled_name(g, &var->name, exported));
diff --git a/src/ir.cpp b/src/ir.cpp
index 406af8ee42..5bf39ee691 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -8711,6 +8711,7 @@ static void update_errors_helper(CodeGen *g, ErrorTableEntry ***errors, size_t *
 }
 
 static TypeTableEntry *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, TypeTableEntry *expected_type, IrInstruction **instructions, size_t instruction_count) {
+    Error err;
     assert(instruction_count >= 1);
     IrInstruction *prev_inst = instructions[0];
     if (type_is_invalid(prev_inst->value.type)) {
@@ -9172,8 +9173,7 @@ static TypeTableEntry *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_nod
         if (prev_type->id == TypeTableEntryIdEnum && cur_type->id == TypeTableEntryIdUnion &&
             (cur_type->data.unionation.decl_node->data.container_decl.auto_enum || cur_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
         {
-            type_ensure_zero_bits_known(ira->codegen, cur_type);
-            if (type_is_invalid(cur_type))
+            if ((err = type_ensure_zero_bits_known(ira->codegen, cur_type)))
                 return ira->codegen->builtin_types.entry_invalid;
             if (cur_type->data.unionation.tag_type == prev_type) {
                 continue;
@@ -9183,8 +9183,7 @@ static TypeTableEntry *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_nod
         if (cur_type->id == TypeTableEntryIdEnum && prev_type->id == TypeTableEntryIdUnion &&
             (prev_type->data.unionation.decl_node->data.container_decl.auto_enum || prev_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
         {
-            type_ensure_zero_bits_known(ira->codegen, prev_type);
-            if (type_is_invalid(prev_type))
+            if ((err = type_ensure_zero_bits_known(ira->codegen, prev_type)))
                 return ira->codegen->builtin_types.entry_invalid;
             if (prev_type->data.unionation.tag_type == cur_type) {
                 prev_inst = cur_inst;
@@ -9999,11 +9998,11 @@ static IrInstruction *ir_analyze_array_to_slice(IrAnalyze *ira, IrInstruction *s
 static IrInstruction *ir_analyze_enum_to_int(IrAnalyze *ira, IrInstruction *source_instr,
         IrInstruction *target, TypeTableEntry *wanted_type)
 {
+    Error err;
     assert(wanted_type->id == TypeTableEntryIdInt);
 
     TypeTableEntry *actual_type = target->value.type;
-    ensure_complete_type(ira->codegen, actual_type);
-    if (type_is_invalid(actual_type))
+    if ((err = ensure_complete_type(ira->codegen, actual_type)))
         return ira->codegen->invalid_instruction;
 
     if (wanted_type != actual_type->data.enumeration.tag_int_type) {
@@ -10069,6 +10068,7 @@ static IrInstruction *ir_analyze_undefined_to_anything(IrAnalyze *ira, IrInstruc
 static IrInstruction *ir_analyze_enum_to_union(IrAnalyze *ira, IrInstruction *source_instr,
         IrInstruction *target, TypeTableEntry *wanted_type)
 {
+    Error err;
     assert(wanted_type->id == TypeTableEntryIdUnion);
     assert(target->value.type->id == TypeTableEntryIdEnum);
 
@@ -10078,8 +10078,7 @@ static IrInstruction *ir_analyze_enum_to_union(IrAnalyze *ira, IrInstruction *so
             return ira->codegen->invalid_instruction;
         TypeUnionField *union_field = find_union_field_by_tag(wanted_type, &val->data.x_enum_tag);
         assert(union_field != nullptr);
-        type_ensure_zero_bits_known(ira->codegen, union_field->type_entry);
-        if (type_is_invalid(union_field->type_entry))
+        if ((err = type_ensure_zero_bits_known(ira->codegen, union_field->type_entry)))
             return ira->codegen->invalid_instruction;
         if (!union_field->type_entry->zero_bits) {
             AstNode *field_node = wanted_type->data.unionation.decl_node->data.container_decl.fields.at(
@@ -10169,12 +10168,12 @@ static IrInstruction *ir_analyze_widen_or_shorten(IrAnalyze *ira, IrInstruction
 static IrInstruction *ir_analyze_int_to_enum(IrAnalyze *ira, IrInstruction *source_instr,
         IrInstruction *target, TypeTableEntry *wanted_type)
 {
+    Error err;
     assert(wanted_type->id == TypeTableEntryIdEnum);
 
     TypeTableEntry *actual_type = target->value.type;
 
-    ensure_complete_type(ira->codegen, wanted_type);
-    if (type_is_invalid(wanted_type))
+    if ((err = ensure_complete_type(ira->codegen, wanted_type)))
         return ira->codegen->invalid_instruction;
 
     if (actual_type != wanted_type->data.enumeration.tag_int_type) {
@@ -10517,6 +10516,7 @@ static void report_recursive_error(IrAnalyze *ira, AstNode *source_node, ConstCa
 static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_instr,
     TypeTableEntry *wanted_type, IrInstruction *value)
 {
+    Error err;
     TypeTableEntry *actual_type = value->value.type;
     AstNode *source_node = source_instr->source_node;
 
@@ -10796,8 +10796,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
     if (actual_type->id == TypeTableEntryIdComptimeFloat ||
         actual_type->id == TypeTableEntryIdComptimeInt)
     {
-        ensure_complete_type(ira->codegen, wanted_type);
-        if (type_is_invalid(wanted_type))
+        if ((err = ensure_complete_type(ira->codegen, wanted_type)))
             return ira->codegen->invalid_instruction;
         if (wanted_type->id == TypeTableEntryIdEnum) {
             IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.enumeration.tag_int_type, value);
@@ -10853,8 +10852,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
 
     // cast from union to the enum type of the union
     if (actual_type->id == TypeTableEntryIdUnion && wanted_type->id == TypeTableEntryIdEnum) {
-        type_ensure_zero_bits_known(ira->codegen, actual_type);
-        if (type_is_invalid(actual_type))
+        if ((err = type_ensure_zero_bits_known(ira->codegen, actual_type)))
             return ira->codegen->invalid_instruction;
 
         if (actual_type->data.unionation.tag_type == wanted_type) {
@@ -10867,7 +10865,9 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         (wanted_type->data.unionation.decl_node->data.container_decl.auto_enum ||
         wanted_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
     {
-        type_ensure_zero_bits_known(ira->codegen, wanted_type);
+        if ((err = type_ensure_zero_bits_known(ira->codegen, wanted_type)))
+            return ira->codegen->invalid_instruction;
+
         if (wanted_type->data.unionation.tag_type == actual_type) {
             return ir_analyze_enum_to_union(ira, source_instr, value, wanted_type);
         }
@@ -10879,7 +10879,9 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         if (union_type->data.unionation.decl_node->data.container_decl.auto_enum ||
             union_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr)
         {
-            type_ensure_zero_bits_known(ira->codegen, union_type);
+            if ((err = type_ensure_zero_bits_known(ira->codegen, union_type)))
+                return ira->codegen->invalid_instruction;
+
             if (union_type->data.unionation.tag_type == actual_type) {
                 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, union_type, value);
                 if (type_is_invalid(cast1->value.type))
@@ -10923,8 +10925,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
             actual_type, source_node, !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
     {
-        type_ensure_zero_bits_known(ira->codegen, actual_type);
-        if (type_is_invalid(actual_type)) {
+        if ((err = type_ensure_zero_bits_known(ira->codegen, actual_type))) {
             return ira->codegen->invalid_instruction;
         }
         if (!type_has_bits(actual_type)) {
@@ -11323,6 +11324,7 @@ static bool optional_value_is_null(ConstExprValue *val) {
 }
 
 static TypeTableEntry *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
+    Error err;
     IrInstruction *op1 = bin_op_instruction->op1->other;
     IrInstruction *op2 = bin_op_instruction->op2->other;
     AstNode *source_node = bin_op_instruction->base.source_node;
@@ -11458,8 +11460,7 @@ static TypeTableEntry *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp
     TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
     if (type_is_invalid(resolved_type))
         return resolved_type;
-    type_ensure_zero_bits_known(ira->codegen, resolved_type);
-    if (type_is_invalid(resolved_type))
+    if ((err = type_ensure_zero_bits_known(ira->codegen, resolved_type)))
         return resolved_type;
 
     bool operator_allowed;
@@ -12406,6 +12407,7 @@ static TypeTableEntry *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructi
 }
 
 static TypeTableEntry *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDeclVar *decl_var_instruction) {
+    Error err;
     VariableTableEntry *var = decl_var_instruction->var;
 
     IrInstruction *init_value = decl_var_instruction->init_value->other;
@@ -12439,8 +12441,7 @@ static TypeTableEntry *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstruc
     if (type_is_invalid(result_type)) {
         result_type = ira->codegen->builtin_types.entry_invalid;
     } else {
-        type_ensure_zero_bits_known(ira->codegen, result_type);
-        if (type_is_invalid(result_type)) {
+        if ((err = type_ensure_zero_bits_known(ira->codegen, result_type))) {
             result_type = ira->codegen->builtin_types.entry_invalid;
         }
     }
@@ -12958,6 +12959,7 @@ static VariableTableEntry *get_fn_var_by_index(FnTableEntry *fn_entry, size_t in
 static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction,
         VariableTableEntry *var)
 {
+    Error err;
     if (var->mem_slot_index != SIZE_MAX && var->owner_exec->analysis == nullptr) {
         assert(ira->codegen->errors.length != 0);
         return ira->codegen->invalid_instruction;
@@ -13012,7 +13014,8 @@ no_mem_slot:
             instruction->scope, instruction->source_node, var);
     var_ptr_instruction->value.type = get_pointer_to_type_extra(ira->codegen, var->value->type,
             var->src_is_const, is_volatile, PtrLenSingle, var->align_bytes, 0, 0);
-    type_ensure_zero_bits_known(ira->codegen, var->value->type);
+    if ((err = type_ensure_zero_bits_known(ira->codegen, var->value->type)))
+        return ira->codegen->invalid_instruction;
 
     bool in_fn_scope = (scope_fn_entry(var->parent_scope) != nullptr);
     var_ptr_instruction->value.data.rh_ptr = in_fn_scope ? RuntimeHintPtrStack : RuntimeHintPtrNonStack;
@@ -13024,6 +13027,7 @@ static TypeTableEntry *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *cal
     FnTableEntry *fn_entry, TypeTableEntry *fn_type, IrInstruction *fn_ref,
     IrInstruction *first_arg_ptr, bool comptime_fn_call, FnInline fn_inline)
 {
+    Error err;
     FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
     size_t first_arg_1_or_0 = first_arg_ptr ? 1 : 0;
 
@@ -13388,8 +13392,7 @@ static TypeTableEntry *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *cal
                 inst_fn_type_id.return_type = specified_return_type;
             }
 
-            type_ensure_zero_bits_known(ira->codegen, specified_return_type);
-            if (type_is_invalid(specified_return_type))
+            if ((err = type_ensure_zero_bits_known(ira->codegen, specified_return_type)))
                 return ira->codegen->builtin_types.entry_invalid;
 
             if (type_requires_comptime(specified_return_type)) {
@@ -13664,12 +13667,12 @@ static TypeTableEntry *ir_analyze_dereference(IrAnalyze *ira, IrInstructionUnOp
 }
 
 static TypeTableEntry *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
+    Error err;
     IrInstruction *value = un_op_instruction->value->other;
     TypeTableEntry *type_entry = ir_resolve_type(ira, value);
     if (type_is_invalid(type_entry))
         return ira->codegen->builtin_types.entry_invalid;
-    ensure_complete_type(ira->codegen, type_entry);
-    if (type_is_invalid(type_entry))
+    if ((err = ensure_complete_type(ira->codegen, type_entry)))
         return ira->codegen->builtin_types.entry_invalid;
 
     switch (type_entry->id) {
@@ -14023,6 +14026,7 @@ static TypeTableEntry *adjust_ptr_len(CodeGen *g, TypeTableEntry *ptr_type, PtrL
 }
 
 static TypeTableEntry *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionElemPtr *elem_ptr_instruction) {
+    Error err;
     IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->other;
     if (type_is_invalid(array_ptr->value.type))
         return ira->codegen->builtin_types.entry_invalid;
@@ -14131,8 +14135,7 @@ static TypeTableEntry *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruc
         return ira->codegen->builtin_types.entry_invalid;
 
     bool safety_check_on = elem_ptr_instruction->safety_check_on;
-    ensure_complete_type(ira->codegen, return_type->data.pointer.child_type);
-    if (type_is_invalid(return_type->data.pointer.child_type))
+    if ((err = ensure_complete_type(ira->codegen, return_type->data.pointer.child_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     uint64_t elem_size = type_size(ira->codegen, return_type->data.pointer.child_type);
@@ -14352,9 +14355,10 @@ static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira,
 static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name,
     IrInstruction *source_instr, IrInstruction *container_ptr, TypeTableEntry *container_type)
 {
+    Error err;
+
     TypeTableEntry *bare_type = container_ref_type(container_type);
-    ensure_complete_type(ira->codegen, bare_type);
-    if (type_is_invalid(bare_type))
+    if ((err = ensure_complete_type(ira->codegen, bare_type)))
         return ira->codegen->invalid_instruction;
 
     assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
@@ -14553,6 +14557,7 @@ static ErrorTableEntry *find_err_table_entry(TypeTableEntry *err_set_type, Buf *
 }
 
 static TypeTableEntry *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFieldPtr *field_ptr_instruction) {
+    Error err;
     IrInstruction *container_ptr = field_ptr_instruction->container_ptr->other;
     if (type_is_invalid(container_ptr->value.type))
         return ira->codegen->builtin_types.entry_invalid;
@@ -14654,8 +14659,7 @@ static TypeTableEntry *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstru
                     ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
             }
             if (child_type->id == TypeTableEntryIdEnum) {
-                ensure_complete_type(ira->codegen, child_type);
-                if (type_is_invalid(child_type))
+                if ((err = ensure_complete_type(ira->codegen, child_type)))
                     return ira->codegen->builtin_types.entry_invalid;
 
                 TypeEnumField *field = find_enum_type_field(child_type, field_name);
@@ -14679,8 +14683,7 @@ static TypeTableEntry *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstru
                     (child_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr ||
                     child_type->data.unionation.decl_node->data.container_decl.auto_enum))
             {
-                ensure_complete_type(ira->codegen, child_type);
-                if (type_is_invalid(child_type))
+                if ((err = ensure_complete_type(ira->codegen, child_type)))
                     return ira->codegen->builtin_types.entry_invalid;
                 TypeUnionField *field = find_union_type_field(child_type, field_name);
                 if (field) {
@@ -15257,6 +15260,7 @@ static TypeTableEntry *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
 static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
         IrInstructionSliceType *slice_type_instruction)
 {
+    Error err;
     uint32_t align_bytes;
     if (slice_type_instruction->align_value != nullptr) {
         if (!ir_resolve_align(ira, slice_type_instruction->align_value->other, &align_bytes))
@@ -15268,6 +15272,8 @@ static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
         return ira->codegen->builtin_types.entry_invalid;
 
     if (slice_type_instruction->align_value == nullptr) {
+        if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
+            return ira->codegen->builtin_types.entry_invalid;
         align_bytes = get_abi_alignment(ira->codegen, child_type);
     }
 
@@ -15306,7 +15312,8 @@ static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
         case TypeTableEntryIdBoundFn:
         case TypeTableEntryIdPromise:
             {
-                type_ensure_zero_bits_known(ira->codegen, child_type);
+                if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
+                    return ira->codegen->builtin_types.entry_invalid;
                 TypeTableEntry *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
                         is_const, is_volatile, PtrLenUnknown, align_bytes, 0, 0);
                 TypeTableEntry *result_type = get_slice_type(ira->codegen, slice_ptr_type);
@@ -15444,11 +15451,11 @@ static TypeTableEntry *ir_analyze_instruction_promise_type(IrAnalyze *ira, IrIns
 static TypeTableEntry *ir_analyze_instruction_size_of(IrAnalyze *ira,
         IrInstructionSizeOf *size_of_instruction)
 {
+    Error err;
     IrInstruction *type_value = size_of_instruction->type_value->other;
     TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
 
-    ensure_complete_type(ira->codegen, type_entry);
-    if (type_is_invalid(type_entry))
+    if ((err = ensure_complete_type(ira->codegen, type_entry)))
         return ira->codegen->builtin_types.entry_invalid;
 
     switch (type_entry->id) {
@@ -15819,6 +15826,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_br(IrAnalyze *ira,
 static TypeTableEntry *ir_analyze_instruction_switch_target(IrAnalyze *ira,
         IrInstructionSwitchTarget *switch_target_instruction)
 {
+    Error err;
     IrInstruction *target_value_ptr = switch_target_instruction->target_value_ptr->other;
     if (type_is_invalid(target_value_ptr->value.type))
         return ira->codegen->builtin_types.entry_invalid;
@@ -15845,8 +15853,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_target(IrAnalyze *ira,
         if (pointee_val->special == ConstValSpecialRuntime)
             pointee_val = nullptr;
     }
-    ensure_complete_type(ira->codegen, target_type);
-    if (type_is_invalid(target_type))
+    if ((err = ensure_complete_type(ira->codegen, target_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     switch (target_type->id) {
@@ -15910,8 +15917,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_target(IrAnalyze *ira,
             return tag_type;
         }
         case TypeTableEntryIdEnum: {
-            type_ensure_zero_bits_known(ira->codegen, target_type);
-            if (type_is_invalid(target_type))
+            if ((err = type_ensure_zero_bits_known(ira->codegen, target_type)))
                 return ira->codegen->builtin_types.entry_invalid;
             if (target_type->data.enumeration.src_field_count < 2) {
                 TypeEnumField *only_field = &target_type->data.enumeration.fields[0];
@@ -16113,10 +16119,10 @@ static TypeTableEntry *ir_analyze_instruction_ref(IrAnalyze *ira, IrInstructionR
 static TypeTableEntry *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruction *instruction,
     TypeTableEntry *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
 {
+    Error err;
     assert(container_type->id == TypeTableEntryIdUnion);
 
-    ensure_complete_type(ira->codegen, container_type);
-    if (type_is_invalid(container_type))
+    if ((err = ensure_complete_type(ira->codegen, container_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     if (instr_field_count != 1) {
@@ -16145,8 +16151,7 @@ static TypeTableEntry *ir_analyze_container_init_fields_union(IrAnalyze *ira, Ir
     if (casted_field_value == ira->codegen->invalid_instruction)
         return ira->codegen->builtin_types.entry_invalid;
 
-    type_ensure_zero_bits_known(ira->codegen, casted_field_value->value.type);
-    if (type_is_invalid(casted_field_value->value.type))
+    if ((err = type_ensure_zero_bits_known(ira->codegen, casted_field_value->value.type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->scope);
@@ -16180,6 +16185,7 @@ static TypeTableEntry *ir_analyze_container_init_fields_union(IrAnalyze *ira, Ir
 static TypeTableEntry *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *instruction,
     TypeTableEntry *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
 {
+    Error err;
     if (container_type->id == TypeTableEntryIdUnion) {
         return ir_analyze_container_init_fields_union(ira, instruction, container_type, instr_field_count, fields);
     }
@@ -16190,8 +16196,7 @@ static TypeTableEntry *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstru
         return ira->codegen->builtin_types.entry_invalid;
     }
 
-    ensure_complete_type(ira->codegen, container_type);
-    if (type_is_invalid(container_type))
+    if ((err = ensure_complete_type(ira->codegen, container_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     size_t actual_field_count = container_type->data.structure.src_field_count;
@@ -16572,6 +16577,7 @@ static TypeTableEntry *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstruc
 }
 
 static TypeTableEntry *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrInstructionTagName *instruction) {
+    Error err;
     IrInstruction *target = instruction->target->other;
     if (type_is_invalid(target->value.type))
         return ira->codegen->builtin_types.entry_invalid;
@@ -16579,8 +16585,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrIn
     assert(target->value.type->id == TypeTableEntryIdEnum);
 
     if (instr_is_comptime(target)) {
-        type_ensure_zero_bits_known(ira->codegen, target->value.type);
-        if (type_is_invalid(target->value.type))
+        if ((err = type_ensure_zero_bits_known(ira->codegen, target->value.type)))
             return ira->codegen->builtin_types.entry_invalid;
         TypeEnumField *field = find_enum_field_by_tag(target->value.type, &target->value.data.x_bigint);
         ConstExprValue *array_val = create_const_str_lit(ira->codegen, field->name);
@@ -16604,6 +16609,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrIn
 static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
         IrInstructionFieldParentPtr *instruction)
 {
+    Error err;
     IrInstruction *type_value = instruction->type_value->other;
     TypeTableEntry *container_type = ir_resolve_type(ira, type_value);
     if (type_is_invalid(container_type))
@@ -16624,8 +16630,7 @@ static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
         return ira->codegen->builtin_types.entry_invalid;
     }
 
-    ensure_complete_type(ira->codegen, container_type);
-    if (type_is_invalid(container_type))
+    if ((err = ensure_complete_type(ira->codegen, container_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     TypeStructField *field = find_struct_type_field(container_type, field_name);
@@ -16697,13 +16702,13 @@ static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
 static TypeTableEntry *ir_analyze_instruction_offset_of(IrAnalyze *ira,
         IrInstructionOffsetOf *instruction)
 {
+    Error err;
     IrInstruction *type_value = instruction->type_value->other;
     TypeTableEntry *container_type = ir_resolve_type(ira, type_value);
     if (type_is_invalid(container_type))
         return ira->codegen->builtin_types.entry_invalid;
 
-    ensure_complete_type(ira->codegen, container_type);
-    if (type_is_invalid(container_type))
+    if ((err = ensure_complete_type(ira->codegen, container_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     IrInstruction *field_name_value = instruction->field_name->other;
@@ -16748,19 +16753,15 @@ static void ensure_field_index(TypeTableEntry *type, const char *field_name, siz
             (buf_deinit(field_name_buf), true));
 }
 
-static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_name, TypeTableEntry *root = nullptr)
-{
+static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_name, TypeTableEntry *root) {
+    Error err;
     static ConstExprValue *type_info_var = nullptr;
     static TypeTableEntry *type_info_type = nullptr;
-    if (type_info_var == nullptr)
-    {
+    if (type_info_var == nullptr) {
         type_info_var = get_builtin_value(ira->codegen, "TypeInfo");
         assert(type_info_var->type->id == TypeTableEntryIdMetaType);
 
-        ensure_complete_type(ira->codegen, type_info_var->data.x_type);
-        if (type_is_invalid(type_info_var->data.x_type))
-            return ira->codegen->builtin_types.entry_invalid;
-
+        assertNoError(ensure_complete_type(ira->codegen, type_info_var->data.x_type));
         type_info_type = type_info_var->data.x_type;
         assert(type_info_type->id == TypeTableEntryIdUnion);
     }
@@ -16785,8 +16786,7 @@ static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_na
 
     VariableTableEntry *var = tld->var;
 
-    ensure_complete_type(ira->codegen, var->value->type);
-    if (type_is_invalid(var->value->type))
+    if ((err = ensure_complete_type(ira->codegen, var->value->type)))
         return ira->codegen->builtin_types.entry_invalid;
     assert(var->value->type->id == TypeTableEntryIdMetaType);
     return var->value->data.x_type;
@@ -16794,9 +16794,9 @@ static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_na
 
 static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, ScopeDecls *decls_scope)
 {
-    TypeTableEntry *type_info_definition_type = ir_type_info_get_type(ira, "Definition");
-    ensure_complete_type(ira->codegen, type_info_definition_type);
-    if (type_is_invalid(type_info_definition_type))
+    Error err;
+    TypeTableEntry *type_info_definition_type = ir_type_info_get_type(ira, "Definition", nullptr);
+    if ((err = ensure_complete_type(ira->codegen, type_info_definition_type)))
         return false;
 
     ensure_field_index(type_info_definition_type, "name", 0);
@@ -16804,18 +16804,15 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
     ensure_field_index(type_info_definition_type, "data", 2);
 
     TypeTableEntry *type_info_definition_data_type = ir_type_info_get_type(ira, "Data", type_info_definition_type);
-    ensure_complete_type(ira->codegen, type_info_definition_data_type);
-    if (type_is_invalid(type_info_definition_data_type))
+    if ((err = ensure_complete_type(ira->codegen, type_info_definition_data_type)))
         return false;
 
     TypeTableEntry *type_info_fn_def_type = ir_type_info_get_type(ira, "FnDef", type_info_definition_data_type);
-    ensure_complete_type(ira->codegen, type_info_fn_def_type);
-    if (type_is_invalid(type_info_fn_def_type))
+    if ((err = ensure_complete_type(ira->codegen, type_info_fn_def_type)))
         return false;
 
     TypeTableEntry *type_info_fn_def_inline_type = ir_type_info_get_type(ira, "Inline", type_info_fn_def_type);
-    ensure_complete_type(ira->codegen, type_info_fn_def_inline_type);
-    if (type_is_invalid(type_info_fn_def_inline_type))
+    if ((err = ensure_complete_type(ira->codegen, type_info_fn_def_inline_type)))
         return false;
 
     // Loop through our definitions once to figure out how many definitions we will generate info for.
@@ -16895,8 +16892,7 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
             case TldIdVar:
                 {
                     VariableTableEntry *var = ((TldVar *)curr_entry->value)->var;
-                    ensure_complete_type(ira->codegen, var->value->type);
-                    if (type_is_invalid(var->value->type))
+                    if ((err = ensure_complete_type(ira->codegen, var->value->type)))
                         return false;
 
                     if (var->value->type->id == TypeTableEntryIdMetaType)
@@ -16953,7 +16949,7 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
                     // calling_convention: TypeInfo.CallingConvention
                     ensure_field_index(fn_def_val->type, "calling_convention", 2);
                     fn_def_fields[2].special = ConstValSpecialStatic;
-                    fn_def_fields[2].type = ir_type_info_get_type(ira, "CallingConvention");
+                    fn_def_fields[2].type = ir_type_info_get_type(ira, "CallingConvention", nullptr);
                     bigint_init_unsigned(&fn_def_fields[2].data.x_enum_tag, fn_node->cc);
                     // is_var_args: bool
                     ensure_field_index(fn_def_val->type, "is_var_args", 3);
@@ -17027,8 +17023,7 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
             case TldIdContainer:
                 {
                     TypeTableEntry *type_entry = ((TldContainer *)curr_entry->value)->type_entry;
-                    ensure_complete_type(ira->codegen, type_entry);
-                    if (type_is_invalid(type_entry))
+                    if ((err = ensure_complete_type(ira->codegen, type_entry)))
                         return false;
 
                     // This is a type.
@@ -17054,12 +17049,67 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
     return true;
 }
 
+static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, TypeTableEntry *ptr_type_entry) {
+    TypeTableEntry *attrs_type;
+    uint32_t size_enum_index;
+    if (is_slice(ptr_type_entry)) {
+        attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
+        size_enum_index = 2;
+    } else if (ptr_type_entry->id == TypeTableEntryIdPointer) {
+        attrs_type = ptr_type_entry;
+        size_enum_index = (ptr_type_entry->data.pointer.ptr_len == PtrLenSingle) ? 0 : 1;
+    } else {
+        zig_unreachable();
+    }
+
+    TypeTableEntry *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer", nullptr);
+    assertNoError(ensure_complete_type(ira->codegen, type_info_pointer_type));
+
+    ConstExprValue *result = create_const_vals(1);
+    result->special = ConstValSpecialStatic;
+    result->type = type_info_pointer_type;
+
+    ConstExprValue *fields = create_const_vals(5);
+    result->data.x_struct.fields = fields;
+
+    // size: Size
+    ensure_field_index(result->type, "size", 0);
+    TypeTableEntry *type_info_pointer_size_type = ir_type_info_get_type(ira, "Size", type_info_pointer_type);
+    assertNoError(ensure_complete_type(ira->codegen, type_info_pointer_size_type));
+    fields[0].special = ConstValSpecialStatic;
+    fields[0].type = type_info_pointer_size_type;
+    bigint_init_unsigned(&fields[0].data.x_enum_tag, size_enum_index);
+
+    // is_const: bool
+    ensure_field_index(result->type, "is_const", 1);
+    fields[1].special = ConstValSpecialStatic;
+    fields[1].type = ira->codegen->builtin_types.entry_bool;
+    fields[1].data.x_bool = attrs_type->data.pointer.is_const;
+    // is_volatile: bool
+    ensure_field_index(result->type, "is_volatile", 2);
+    fields[2].special = ConstValSpecialStatic;
+    fields[2].type = ira->codegen->builtin_types.entry_bool;
+    fields[2].data.x_bool = attrs_type->data.pointer.is_volatile;
+    // alignment: u32
+    ensure_field_index(result->type, "alignment", 3);
+    fields[3].special = ConstValSpecialStatic;
+    fields[3].type = get_int_type(ira->codegen, false, 29);
+    bigint_init_unsigned(&fields[3].data.x_bigint, attrs_type->data.pointer.alignment);
+    // child: type
+    ensure_field_index(result->type, "child", 4);
+    fields[4].special = ConstValSpecialStatic;
+    fields[4].type = ira->codegen->builtin_types.entry_type;
+    fields[4].data.x_type = attrs_type->data.pointer.child_type;
+
+    return result;
+};
+
 static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *type_entry) {
+    Error err;
     assert(type_entry != nullptr);
     assert(!type_is_invalid(type_entry));
 
-    ensure_complete_type(ira->codegen, type_entry);
-    if (type_is_invalid(type_entry))
+    if ((err = ensure_complete_type(ira->codegen, type_entry)))
         return nullptr;
 
     const auto make_enum_field_val = [ira](ConstExprValue *enum_field_val, TypeEnumField *enum_field,
@@ -17079,63 +17129,6 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
         enum_field_val->data.x_struct.fields = inner_fields;
     };
 
-    const auto create_ptr_like_type_info = [ira](TypeTableEntry *ptr_type_entry) {
-        TypeTableEntry *attrs_type;
-        uint32_t size_enum_index;
-        if (is_slice(ptr_type_entry)) {
-            attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
-            size_enum_index = 2;
-        } else if (ptr_type_entry->id == TypeTableEntryIdPointer) {
-            attrs_type = ptr_type_entry;
-            size_enum_index = (ptr_type_entry->data.pointer.ptr_len == PtrLenSingle) ? 0 : 1;
-        } else {
-            zig_unreachable();
-        }
-
-        TypeTableEntry *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer");
-        ensure_complete_type(ira->codegen, type_info_pointer_type);
-        assert(!type_is_invalid(type_info_pointer_type));
-
-        ConstExprValue *result = create_const_vals(1);
-        result->special = ConstValSpecialStatic;
-        result->type = type_info_pointer_type;
-
-        ConstExprValue *fields = create_const_vals(5);
-        result->data.x_struct.fields = fields;
-
-        // size: Size
-        ensure_field_index(result->type, "size", 0);
-        TypeTableEntry *type_info_pointer_size_type = ir_type_info_get_type(ira, "Size", type_info_pointer_type);
-        ensure_complete_type(ira->codegen, type_info_pointer_size_type);
-        assert(!type_is_invalid(type_info_pointer_size_type));
-        fields[0].special = ConstValSpecialStatic;
-        fields[0].type = type_info_pointer_size_type;
-        bigint_init_unsigned(&fields[0].data.x_enum_tag, size_enum_index);
-
-        // is_const: bool
-        ensure_field_index(result->type, "is_const", 1);
-        fields[1].special = ConstValSpecialStatic;
-        fields[1].type = ira->codegen->builtin_types.entry_bool;
-        fields[1].data.x_bool = attrs_type->data.pointer.is_const;
-        // is_volatile: bool
-        ensure_field_index(result->type, "is_volatile", 2);
-        fields[2].special = ConstValSpecialStatic;
-        fields[2].type = ira->codegen->builtin_types.entry_bool;
-        fields[2].data.x_bool = attrs_type->data.pointer.is_volatile;
-        // alignment: u32
-        ensure_field_index(result->type, "alignment", 3);
-        fields[3].special = ConstValSpecialStatic;
-        fields[3].type = get_int_type(ira->codegen, false, 29);
-        bigint_init_unsigned(&fields[3].data.x_bigint, attrs_type->data.pointer.alignment);
-        // child: type
-        ensure_field_index(result->type, "child", 4);
-        fields[4].special = ConstValSpecialStatic;
-        fields[4].type = ira->codegen->builtin_types.entry_type;
-        fields[4].data.x_type = attrs_type->data.pointer.child_type;
-
-        return result;
-    };
-
     if (type_entry == ira->codegen->builtin_types.entry_global_error_set) {
         zig_panic("TODO implement @typeInfo for global error set");
     }
@@ -17171,7 +17164,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Int");
+                result->type = ir_type_info_get_type(ira, "Int", nullptr);
 
                 ConstExprValue *fields = create_const_vals(2);
                 result->data.x_struct.fields = fields;
@@ -17193,7 +17186,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Float");
+                result->type = ir_type_info_get_type(ira, "Float", nullptr);
 
                 ConstExprValue *fields = create_const_vals(1);
                 result->data.x_struct.fields = fields;
@@ -17208,14 +17201,14 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             }
         case TypeTableEntryIdPointer:
             {
-                result = create_ptr_like_type_info(type_entry);
+                result = create_ptr_like_type_info(ira, type_entry);
                 break;
             }
         case TypeTableEntryIdArray:
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Array");
+                result->type = ir_type_info_get_type(ira, "Array", nullptr);
 
                 ConstExprValue *fields = create_const_vals(2);
                 result->data.x_struct.fields = fields;
@@ -17237,7 +17230,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Optional");
+                result->type = ir_type_info_get_type(ira, "Optional", nullptr);
 
                 ConstExprValue *fields = create_const_vals(1);
                 result->data.x_struct.fields = fields;
@@ -17254,7 +17247,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Promise");
+                result->type = ir_type_info_get_type(ira, "Promise", nullptr);
 
                 ConstExprValue *fields = create_const_vals(1);
                 result->data.x_struct.fields = fields;
@@ -17280,7 +17273,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Enum");
+                result->type = ir_type_info_get_type(ira, "Enum", nullptr);
 
                 ConstExprValue *fields = create_const_vals(4);
                 result->data.x_struct.fields = fields;
@@ -17288,7 +17281,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                 // layout: ContainerLayout
                 ensure_field_index(result->type, "layout", 0);
                 fields[0].special = ConstValSpecialStatic;
-                fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+                fields[0].type = ir_type_info_get_type(ira, "ContainerLayout", nullptr);
                 bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.enumeration.layout);
                 // tag_type: type
                 ensure_field_index(result->type, "tag_type", 1);
@@ -17298,7 +17291,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                 // fields: []TypeInfo.EnumField
                 ensure_field_index(result->type, "fields", 2);
 
-                TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
+                TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
                 uint32_t enum_field_count = type_entry->data.enumeration.src_field_count;
 
                 ConstExprValue *enum_field_array = create_const_vals(1);
@@ -17330,7 +17323,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "ErrorSet");
+                result->type = ir_type_info_get_type(ira, "ErrorSet", nullptr);
 
                 ConstExprValue *fields = create_const_vals(1);
                 result->data.x_struct.fields = fields;
@@ -17338,7 +17331,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                 // errors: []TypeInfo.Error
                 ensure_field_index(result->type, "errors", 0);
 
-                TypeTableEntry *type_info_error_type = ir_type_info_get_type(ira, "Error");
+                TypeTableEntry *type_info_error_type = ir_type_info_get_type(ira, "Error", nullptr);
                 uint32_t error_count = type_entry->data.error_set.err_count;
                 ConstExprValue *error_array = create_const_vals(1);
                 error_array->special = ConstValSpecialStatic;
@@ -17380,7 +17373,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "ErrorUnion");
+                result->type = ir_type_info_get_type(ira, "ErrorUnion", nullptr);
 
                 ConstExprValue *fields = create_const_vals(2);
                 result->data.x_struct.fields = fields;
@@ -17403,7 +17396,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Union");
+                result->type = ir_type_info_get_type(ira, "Union", nullptr);
 
                 ConstExprValue *fields = create_const_vals(4);
                 result->data.x_struct.fields = fields;
@@ -17411,7 +17404,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                 // layout: ContainerLayout
                 ensure_field_index(result->type, "layout", 0);
                 fields[0].special = ConstValSpecialStatic;
-                fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+                fields[0].type = ir_type_info_get_type(ira, "ContainerLayout", nullptr);
                 bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.unionation.layout);
                 // tag_type: ?type
                 ensure_field_index(result->type, "tag_type", 1);
@@ -17433,7 +17426,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                 // fields: []TypeInfo.UnionField
                 ensure_field_index(result->type, "fields", 2);
 
-                TypeTableEntry *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField");
+                TypeTableEntry *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField", nullptr);
                 uint32_t union_field_count = type_entry->data.unionation.src_field_count;
 
                 ConstExprValue *union_field_array = create_const_vals(1);
@@ -17445,7 +17438,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
 
                 init_const_slice(ira->codegen, &fields[2], union_field_array, 0, union_field_count, false);
 
-                TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
+                TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
 
                 for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++) {
                     TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
@@ -17487,13 +17480,13 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
         case TypeTableEntryIdStruct:
             {
                 if (type_entry->data.structure.is_slice) {
-                    result = create_ptr_like_type_info(type_entry);
+                    result = create_ptr_like_type_info(ira, type_entry);
                     break;
                 }
 
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Struct");
+                result->type = ir_type_info_get_type(ira, "Struct", nullptr);
 
                 ConstExprValue *fields = create_const_vals(3);
                 result->data.x_struct.fields = fields;
@@ -17501,12 +17494,12 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                 // layout: ContainerLayout
                 ensure_field_index(result->type, "layout", 0);
                 fields[0].special = ConstValSpecialStatic;
-                fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+                fields[0].type = ir_type_info_get_type(ira, "ContainerLayout", nullptr);
                 bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.structure.layout);
                 // fields: []TypeInfo.StructField
                 ensure_field_index(result->type, "fields", 1);
 
-                TypeTableEntry *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField");
+                TypeTableEntry *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField", nullptr);
                 uint32_t struct_field_count = type_entry->data.structure.src_field_count;
 
                 ConstExprValue *struct_field_array = create_const_vals(1);
@@ -17562,7 +17555,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
             {
                 result = create_const_vals(1);
                 result->special = ConstValSpecialStatic;
-                result->type = ir_type_info_get_type(ira, "Fn");
+                result->type = ir_type_info_get_type(ira, "Fn", nullptr);
 
                 ConstExprValue *fields = create_const_vals(6);
                 result->data.x_struct.fields = fields;
@@ -17570,7 +17563,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                 // calling_convention: TypeInfo.CallingConvention
                 ensure_field_index(result->type, "calling_convention", 0);
                 fields[0].special = ConstValSpecialStatic;
-                fields[0].type = ir_type_info_get_type(ira, "CallingConvention");
+                fields[0].type = ir_type_info_get_type(ira, "CallingConvention", nullptr);
                 bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.fn.fn_type_id.cc);
                 // is_generic: bool
                 ensure_field_index(result->type, "is_generic", 1);
@@ -17611,7 +17604,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
                     fields[4].data.x_optional = async_alloc_type;
                 }
                 // args: []TypeInfo.FnArg
-                TypeTableEntry *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg");
+                TypeTableEntry *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg", nullptr);
                 size_t fn_arg_count = type_entry->data.fn.fn_type_id.param_count -
                         (is_varargs && type_entry->data.fn.fn_type_id.cc != CallingConventionC);
 
@@ -17686,7 +17679,7 @@ static TypeTableEntry *ir_analyze_instruction_type_info(IrAnalyze *ira,
     if (type_is_invalid(type_entry))
         return ira->codegen->builtin_types.entry_invalid;
 
-    TypeTableEntry *result_type = ir_type_info_get_type(ira, nullptr);
+    TypeTableEntry *result_type = ir_type_info_get_type(ira, nullptr, nullptr);
 
     ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
     out_val->type = result_type;
@@ -18896,13 +18889,13 @@ static TypeTableEntry *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructio
 }
 
 static TypeTableEntry *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructionMemberCount *instruction) {
+    Error err;
     IrInstruction *container = instruction->container->other;
     if (type_is_invalid(container->value.type))
         return ira->codegen->builtin_types.entry_invalid;
     TypeTableEntry *container_type = ir_resolve_type(ira, container);
 
-    ensure_complete_type(ira->codegen, container_type);
-    if (type_is_invalid(container_type))
+    if ((err = ensure_complete_type(ira->codegen, container_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     uint64_t result;
@@ -18934,13 +18927,13 @@ static TypeTableEntry *ir_analyze_instruction_member_count(IrAnalyze *ira, IrIns
 }
 
 static TypeTableEntry *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInstructionMemberType *instruction) {
+    Error err;
     IrInstruction *container_type_value = instruction->container_type->other;
     TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
     if (type_is_invalid(container_type))
         return ira->codegen->builtin_types.entry_invalid;
 
-    ensure_complete_type(ira->codegen, container_type);
-    if (type_is_invalid(container_type))
+    if ((err = ensure_complete_type(ira->codegen, container_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
 
@@ -18981,13 +18974,13 @@ static TypeTableEntry *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInst
 }
 
 static TypeTableEntry *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstructionMemberName *instruction) {
+    Error err;
     IrInstruction *container_type_value = instruction->container_type->other;
     TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
     if (type_is_invalid(container_type))
         return ira->codegen->builtin_types.entry_invalid;
 
-    ensure_complete_type(ira->codegen, container_type);
-    if (type_is_invalid(container_type))
+    if ((err = ensure_complete_type(ira->codegen, container_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     uint64_t member_index;
@@ -19068,13 +19061,13 @@ static TypeTableEntry *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructi
 }
 
 static TypeTableEntry *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) {
+    Error err;
     IrInstruction *type_value = instruction->type_value->other;
     if (type_is_invalid(type_value->value.type))
         return ira->codegen->builtin_types.entry_invalid;
     TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
 
-    type_ensure_zero_bits_known(ira->codegen, type_entry);
-    if (type_is_invalid(type_entry))
+    if ((err = type_ensure_zero_bits_known(ira->codegen, type_entry)))
         return ira->codegen->builtin_types.entry_invalid;
 
     switch (type_entry->id) {
@@ -19930,6 +19923,7 @@ static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
 }
 
 static TypeTableEntry *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBitCast *instruction) {
+    Error err;
     IrInstruction *dest_type_value = instruction->dest_type->other;
     TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
     if (type_is_invalid(dest_type))
@@ -19940,12 +19934,10 @@ static TypeTableEntry *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstruc
     if (type_is_invalid(src_type))
         return ira->codegen->builtin_types.entry_invalid;
 
-    ensure_complete_type(ira->codegen, dest_type);
-    if (type_is_invalid(dest_type))
+    if ((err = ensure_complete_type(ira->codegen, dest_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
-    ensure_complete_type(ira->codegen, src_type);
-    if (type_is_invalid(src_type))
+    if ((err = ensure_complete_type(ira->codegen, src_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     if (get_codegen_ptr_type(src_type) != nullptr) {
@@ -20031,6 +20023,7 @@ static TypeTableEntry *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstruc
 }
 
 static TypeTableEntry *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionIntToPtr *instruction) {
+    Error err;
     IrInstruction *dest_type_value = instruction->dest_type->other;
     TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
     if (type_is_invalid(dest_type))
@@ -20041,7 +20034,8 @@ static TypeTableEntry *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstr
         return ira->codegen->builtin_types.entry_invalid;
     }
 
-    type_ensure_zero_bits_known(ira->codegen, dest_type);
+    if ((err = type_ensure_zero_bits_known(ira->codegen, dest_type)))
+        return ira->codegen->builtin_types.entry_invalid;
     if (!type_has_bits(dest_type)) {
         ir_add_error(ira, dest_type_value,
                 buf_sprintf("type '%s' has 0 bits and cannot store information", buf_ptr(&dest_type->name)));
@@ -20174,6 +20168,7 @@ static TypeTableEntry *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstr
 }
 
 static TypeTableEntry *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstructionPtrType *instruction) {
+    Error err;
     TypeTableEntry *child_type = ir_resolve_type(ira, instruction->child_type->other);
     if (type_is_invalid(child_type))
         return ira->codegen->builtin_types.entry_invalid;
@@ -20191,8 +20186,7 @@ static TypeTableEntry *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstruc
         if (!ir_resolve_align(ira, instruction->align_value->other, &align_bytes))
             return ira->codegen->builtin_types.entry_invalid;
     } else {
-        type_ensure_zero_bits_known(ira->codegen, child_type);
-        if (type_is_invalid(child_type))
+        if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
             return ira->codegen->builtin_types.entry_invalid;
         align_bytes = get_abi_alignment(ira->codegen, child_type);
     }
@@ -20312,22 +20306,21 @@ static TypeTableEntry *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstruc
 }
 
 static TypeTableEntry *ir_analyze_instruction_tag_type(IrAnalyze *ira, IrInstructionTagType *instruction) {
+    Error err;
     IrInstruction *target_inst = instruction->target->other;
     TypeTableEntry *enum_type = ir_resolve_type(ira, target_inst);
     if (type_is_invalid(enum_type))
         return ira->codegen->builtin_types.entry_invalid;
 
     if (enum_type->id == TypeTableEntryIdEnum) {
-        ensure_complete_type(ira->codegen, enum_type);
-        if (type_is_invalid(enum_type))
+        if ((err = ensure_complete_type(ira->codegen, enum_type)))
             return ira->codegen->builtin_types.entry_invalid;
 
         ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
         out_val->data.x_type = enum_type->data.enumeration.tag_int_type;
         return ira->codegen->builtin_types.entry_type;
     } else if (enum_type->id == TypeTableEntryIdUnion) {
-        ensure_complete_type(ira->codegen, enum_type);
-        if (type_is_invalid(enum_type))
+        if ((err = ensure_complete_type(ira->codegen, enum_type)))
             return ira->codegen->builtin_types.entry_invalid;
 
         AstNode *decl_node = enum_type->data.unionation.decl_node;
@@ -20830,6 +20823,7 @@ static TypeTableEntry *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstruction
 }
 
 static TypeTableEntry *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInstructionEnumToInt *instruction) {
+    Error err;
     IrInstruction *target = instruction->target->other;
     if (type_is_invalid(target->value.type))
         return ira->codegen->builtin_types.entry_invalid;
@@ -20840,8 +20834,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInst
         return ira->codegen->builtin_types.entry_invalid;
     }
 
-    type_ensure_zero_bits_known(ira->codegen, target->value.type);
-    if (type_is_invalid(target->value.type))
+    if ((err = type_ensure_zero_bits_known(ira->codegen, target->value.type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     TypeTableEntry *tag_type = target->value.type->data.enumeration.tag_int_type;
@@ -20852,6 +20845,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInst
 }
 
 static TypeTableEntry *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInstructionIntToEnum *instruction) {
+    Error err;
     IrInstruction *dest_type_value = instruction->dest_type->other;
     TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
     if (type_is_invalid(dest_type))
@@ -20863,8 +20857,7 @@ static TypeTableEntry *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInst
         return ira->codegen->builtin_types.entry_invalid;
     }
 
-    type_ensure_zero_bits_known(ira->codegen, dest_type);
-    if (type_is_invalid(dest_type))
+    if ((err = type_ensure_zero_bits_known(ira->codegen, dest_type)))
         return ira->codegen->builtin_types.entry_invalid;
 
     TypeTableEntry *tag_type = dest_type->data.enumeration.tag_int_type;
diff --git a/src/result.hpp b/src/result.hpp
new file mode 100644
index 0000000000..6c9f35c0b6
--- /dev/null
+++ b/src/result.hpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#ifndef ZIG_RESULT_HPP
+#define ZIG_RESULT_HPP
+
+#include "error.hpp"
+
+#include <assert.h>
+
+static inline void assertNoError(Error err) {
+    assert(err == ErrorNone);
+}
+
+template<typename T>
+struct Result {
+    T data;
+    Error err;
+
+    Result(T x) : data(x), err(ErrorNone) {}
+
+    Result(Error err) : err(err) {
+        assert(err != ErrorNone);
+    }
+
+    T unwrap() {
+        assert(err == ErrorNone);
+        return data;
+    }
+};
+
+#endif
diff --git a/src/util.hpp b/src/util.hpp
index b0402137bd..41f8feb591 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -21,6 +21,7 @@
 #define ATTRIBUTE_PRINTF(a, b)
 #define ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
 #define ATTRIBUTE_NORETURN __declspec(noreturn)
+#define ATTRIBUTE_MUST_USE
 
 #else
 
@@ -28,6 +29,7 @@
 #define ATTRIBUTE_PRINTF(a, b) __attribute__((format(printf, a, b)))
 #define ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
 #define ATTRIBUTE_NORETURN __attribute__((noreturn))
+#define ATTRIBUTE_MUST_USE __attribute__((warn_unused_result))
 
 #endif